{"version":3,"sources":["webpack:///./node_modules/@babel/parser/lib/index.js"],"names":["_objectWithoutPropertiesLoose","r","e","t","n","hasOwnProperty","call","includes","Object","defineProperty","exports","value","Position","line","col","index","this","column","SourceLocation","start","end","filename","identifierName","createPositionWithColumnOffset","position","columnOffset","code","ModuleErrors","ImportMetaOutsideModule","message","ImportOutsideModule","NodeDescriptions","ArrayPattern","AssignmentExpression","AssignmentPattern","ArrowFunctionExpression","ConditionalExpression","CatchClause","ForOfStatement","ForInStatement","ForStatement","FormalParameters","Identifier","ImportSpecifier","ImportDefaultSpecifier","ImportNamespaceSpecifier","ObjectPattern","ParenthesizedExpression","RestElement","UpdateExpression","true","false","VariableDeclarator","YieldExpression","toNodeDescription","node","type","prefix","StandardErrors","AccessorIsGenerator","kind","ArgumentsInClass","AsyncFunctionInSingleStatementContext","AwaitBindingIdentifier","AwaitBindingIdentifierInStaticBlock","AwaitExpressionFormalParameter","AwaitUsingNotInAsyncContext","AwaitNotInAsyncContext","AwaitNotInAsyncFunction","BadGetterArity","BadSetterArity","BadSetterRestParameter","ConstructorClassField","ConstructorClassPrivateField","ConstructorIsAccessor","ConstructorIsAsync","ConstructorIsGenerator","DeclarationMissingInitializer","DecoratorArgumentsOutsideParentheses","DecoratorBeforeExport","DecoratorsBeforeAfterExport","DecoratorConstructor","DecoratorExportClass","DecoratorSemicolon","DecoratorStaticBlock","DeferImportRequiresNamespace","DeletePrivateField","DestructureNamedImport","DuplicateConstructor","DuplicateDefaultExport","DuplicateExport","exportName","DuplicateProto","DuplicateRegExpFlags","DynamicImportPhaseRequiresImportExpressions","phase","ElementAfterRest","EscapedCharNotAnIdentifier","ExportBindingIsString","localName","ExportDefaultFromAsIdentifier","ForInOfLoopInitializer","ForInUsing","ForOfAsync","ForOfLet","GeneratorInSingleStatementContext","IllegalBreakContinue","IllegalLanguageModeDirective","IllegalReturn","ImportAttributesUseAssert","ImportBindingIsString","importName","ImportCallArgumentTrailingComma","ImportCallArity","maxArgumentCount","ImportCallNotNewExpression","ImportCallSpreadArgument","ImportJSONBindingNotDefault","ImportReflectionHasAssertion","ImportReflectionNotBinding","IncompatibleRegExpUVFlags","InvalidBigIntLiteral","InvalidCodePoint","InvalidCoverInitializedName","InvalidDecimal","InvalidDigit","radix","InvalidEscapeSequence","InvalidEscapeSequenceTemplate","InvalidEscapedReservedWord","reservedWord","InvalidIdentifier","InvalidLhs","ancestor","InvalidLhsBinding","InvalidLhsOptionalChaining","InvalidNumber","InvalidOrMissingExponent","InvalidOrUnexpectedToken","unexpected","InvalidParenthesizedAssignment","InvalidPrivateFieldResolution","InvalidPropertyBindingPattern","InvalidRecordProperty","InvalidRestAssignmentPattern","LabelRedeclaration","labelName","LetInLexicalBinding","LineTerminatorBeforeArrow","MalformedRegExpFlags","MissingClassName","MissingEqInAssignment","MissingSemicolon","MissingPlugin","missingPlugin","map","name","JSON","stringify","join","MissingOneOfPlugins","MissingUnicodeEscape","MixingCoalesceWithLogical","ModuleAttributeDifferentFromType","ModuleAttributeInvalidValue","ModuleAttributesWithDuplicateKeys","key","ModuleExportNameHasLoneSurrogate","surrogateCharCode","toString","ModuleExportUndefined","MultipleDefaultsInSwitch","NewlineAfterThrow","NoCatchOrFinally","NumberIdentifier","NumericSeparatorInEscapeSequence","ObsoleteAwaitStar","OptionalChainingNoNew","OptionalChainingNoTemplate","OverrideOnConstructor","ParamDupe","PatternHasAccessor","PatternHasMethod","PrivateInExpectedIn","PrivateNameRedeclaration","RecordExpressionBarIncorrectEndSyntaxType","RecordExpressionBarIncorrectStartSyntaxType","RecordExpressionHashIncorrectStartSyntaxType","RecordNoProto","RestTrailingComma","SloppyFunction","SloppyFunctionAnnexB","SourcePhaseImportRequiresDefault","StaticPrototype","SuperNotAllowed","SuperPrivateField","TrailingDecorator","TupleExpressionBarIncorrectEndSyntaxType","TupleExpressionBarIncorrectStartSyntaxType","TupleExpressionHashIncorrectStartSyntaxType","UnexpectedArgumentPlaceholder","UnexpectedAwaitAfterPipelineBody","UnexpectedDigitAfterHash","UnexpectedImportExport","UnexpectedKeyword","keyword","UnexpectedLeadingDecorator","UnexpectedLexicalDeclaration","UnexpectedNewTarget","UnexpectedNumericSeparator","UnexpectedPrivateField","UnexpectedReservedWord","UnexpectedSuper","UnexpectedToken","expected","UnexpectedTokenUnaryExponentiation","UnexpectedUsingDeclaration","UnsupportedBind","UnsupportedDecoratorExport","UnsupportedDefaultExport","UnsupportedImport","UnsupportedMetaProperty","target","onlyValidPropertyName","UnsupportedParameterDecorator","UnsupportedPropertyDecorator","UnsupportedSuper","UnterminatedComment","UnterminatedRegExp","UnterminatedString","UnterminatedTemplate","UsingDeclarationExport","UsingDeclarationHasBindingPattern","VarRedeclaration","YieldBindingIdentifier","YieldInParameter","ZeroDigitNumericSeparator","StrictModeErrors","StrictDelete","StrictEvalArguments","referenceName","StrictEvalArgumentsBinding","bindingName","StrictFunction","StrictNumericEscape","StrictOctalLiteral","StrictWith","UnparenthesizedPipeBodyDescriptions","Set","PipelineOperatorErrors","PipeBodyIsTighter","PipeTopicRequiresHackPipes","PipeTopicUnbound","PipeTopicUnconfiguredToken","token","PipeTopicUnused","PipeUnparenthesizedBody","PipelineBodyNoArrow","PipelineBodySequenceExpression","PipelineHeadSequenceExpression","PipelineTopicUnused","PrimaryTopicNotAllowed","PrimaryTopicRequiresSmartPipeline","_excluded","defineHidden","obj","enumerable","configurable","toParseErrorConstructor","toMessage","reasonCode","syntaxPlugin","hasMissingPlugin","oldReasonCodes","AccessorCannotDeclareThisParameter","AccessorCannotHaveTypeParameters","ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference","SetAccessorCannotHaveOptionalParameter","SetAccessorCannotHaveRestParameter","SetAccessorCannotHaveReturnType","constructor","loc","details","error","SyntaxError","pos","overrides","_overrides$loc","assign","writable","ParseErrorEnum","argument","Array","isArray","parseErrorTemplates","ParseErrorConstructors","keys","template","_ref","rest","Errors","toUnenumerable","object","toESTreeLocation","estree","superClass","file","super","parse","options","tokens","pattern","flags","regex","RegExp","_","estreeParseLiteral","bigInt","BigInt","_unused","bigint","String","decimal","parseLiteral","directive","expression","raw","extra","expressionValue","stmt","rawValue","isAsync","initFunction","isObjectProperty","checkDeclaration","method","params","_stmt$expression$extr","parenthesized","allowDirectives","topLevel","afterBlockParse","parseBlockBody","directiveStatements","directives","d","directiveToStmt","body","concat","classBody","isGenerator","isConstructor","allowsDirectSuper","parseMethod","typeParameters","push","parsePrivateName","getPluginOption","convertPrivateNameToPrivateIdentifier","getPrivateNameSV","id","isPrivateName","allowExpression","isMethod","parseFunctionBody","allowDirectSuper","inClassScope","funcNode","startNode","computed","finishNode","nameIsConstructor","args","propertyNode","parseClassProperty","parseClassPrivateProperty","prop","isPattern","isAccessor","parseObjectMethod","shorthand","startLoc","refExpressionErrors","parseObjectProperty","isUnparenthesizedInAssign","binding","isValidLVal","isBinding","isAssignable","isLHS","classScope","usePrivateName","toAssignable","isLast","raise","toAssignableObjectExpressionProp","unfinished","optional","finishCallExpression","callee","_ref2","source","arguments","hasPlugin","attributes","toReferencedArguments","decorators","exportStartLoc","state","lastTokStartLoc","parseExport","exported","specifiers","length","_declaration$decorato","declaration","resetStartLocation","base","noCalls","parseSubscript","optionalChainMember","substring","stop","chain","startNodeAtNode","isOptionalMemberExpression","hasPropertyAsPrivateName","endLoc","finishNodeAt","lastTokEndLoc","resetEndLocation","TokContext","preserveSpace","types","brace","j_oTag","j_cTag","j_expr","beforeExpr","startsExpr","isLoop","isAssign","postfix","ExportedTokenType","label","conf","rightAssociative","binop","updateContext","keywords$1","Map","createKeyword","createToken","set","createBinop","tokenTypeCounter","tokenTypes","tokenLabels","tokenBinops","tokenBeforeExprs","tokenStartsExprs","tokenPrefixes","_options$binop","_options$beforeExpr","_options$startsExpr","_options$prefix","createKeywordLike","_options$binop2","_options$beforeExpr2","_options$startsExpr2","_options$prefix2","tt","bracketL","bracketHashL","bracketBarL","bracketR","bracketBarR","braceL","braceBarL","braceHashL","braceR","braceBarR","parenL","parenR","comma","semi","colon","doubleColon","dot","question","questionDot","arrow","ellipsis","backQuote","dollarBraceL","templateTail","templateNonTail","at","hash","interpreterDirective","eq","slashAssign","xorAssign","moduloAssign","incDec","bang","tilde","doubleCaret","doubleAt","pipeline","nullishCoalescing","logicalOR","logicalAND","bitwiseOR","bitwiseXOR","bitwiseAND","equality","lt","gt","relational","bitShift","bitShiftL","bitShiftR","plusMin","modulo","star","slash","exponent","_in","_instanceof","_break","_case","_catch","_continue","_debugger","_default","_else","_finally","_function","_if","_return","_switch","_throw","_try","_var","_const","_with","_new","_this","_super","_class","_extends","_export","_import","_null","_true","_false","_typeof","_void","_delete","_do","_for","_while","_as","_assert","_async","_await","_defer","_from","_get","_let","_meta","_of","_sent","_set","_source","_static","_using","_yield","_asserts","_checks","_exports","_global","_implements","_intrinsic","_infer","_is","_mixins","_proto","_require","_satisfies","_keyof","_readonly","_unique","_abstract","_declare","_enum","_module","_namespace","_interface","_type","_opaque","string","num","regexp","privateName","eof","jsxName","jsxText","jsxTagStart","jsxTagEnd","placeholder","tokenIsIdentifier","tokenKeywordOrIdentifierIsKeyword","tokenIsKeywordOrIdentifier","tokenIsLiteralPropertyName","tokenComesBeforeExpression","tokenCanStartExpression","tokenIsAssignment","tokenIsFlowInterfaceOrTypeOrOpaque","tokenIsLoop","tokenIsKeyword","tokenIsOperator","tokenIsPostfix","tokenIsPrefix","tokenIsTSTypeOperator","tokenIsTSDeclarationStart","tokenLabelName","tokenOperatorPrecedence","tokenIsRightAssociative","tokenIsTemplate","getExportedToken","context","pop","nonASCIIidentifierStartChars","nonASCIIidentifierChars","nonASCIIidentifierStart","nonASCIIidentifier","astralIdentifierStartCodes","astralIdentifierCodes","isInAstralSet","i","isIdentifierStart","test","fromCharCode","isIdentifierChar","reservedWords","strict","strictBind","keywords","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","has","isStrictBindOnlyReservedWord","isStrictBindReservedWord","isKeyword","isIteratorStart","current","next","next2","reservedWordLikeSet","canBeReservedWord","Scope","names","firstLexicalName","ScopeHandler","parser","scopeStack","undefinedExports","currentScope","currentVarScopeFlags","currentThisScopeFlags","treatFunctionsAsVarInScope","createScope","scope","bindingType","checkRedeclarationInScope","get","maybeExportDefined","delete","isRedeclaredInScope","topLevelScope","FlowScope","declareFunctions","FlowScopeHandler","add","declareName","checkLocalExport","BaseParser","sawUnambiguousESM","ambiguousScriptDifferentAst","pluginConfig","plugins","pluginName","pluginOptions","actualOptions","plugin","_this$plugins$get","setTrailingComments","comments","undefined","trailingComments","unshift","setLeadingComments","leadingComments","setInnerComments","innerComments","adjustInnerComments","elements","commentWS","lastElement","CommentsParser","comment","commentsLen","commentStack","commentStackLength","lastCommentWS","leadingNode","nodeStart","commentEnd","trailingNode","containingNode","finalizeComment","splice","commentStart","input","charCodeAt","properties","lineBreak","lineBreakG","isNewLine","hasNewLine","skipWhiteSpace","skipWhiteSpaceInLine","isWhitespace","State","curLine","lineStart","errors","potentialArrowAt","noArrowAt","noArrowParamsConversionAt","topicContext","maxNumOfResolvableTopics","maxTopicIndex","labels","firstInvalidTemplateEscapePos","strictErrors","tokensLength","v","strictMode","sourceType","startLine","startColumn","slice","_isDigit","forbiddenNumericSeparatorSiblings","decBinOct","hex","isAllowedNumericSeparatorSibling","bin","ch","oct","dec","readStringContents","initialPos","initialLineStart","initialCurLine","out","firstInvalidLoc","chunkStart","unterminated","isStringEnd","res","readEscapedChar","str","containsInvalid","inTemplate","throwOnInvalid","readHexChar","readCodePoint","fromCodePoint","strictNumericEscape","startPos","match","exec","octalStr","octal","parseInt","len","forceLen","readInt","invalidEscapeSequence","allowNumSeparator","bailOnError","forbiddenSiblings","isAllowedSibling","invalid","total","Infinity","val","invalidDigit","prev","Number","isNaN","unexpectedNumericSeparator","numericSeparatorInEscapeSequence","indexOf","invalidCodePoint","buildPosition","VALID_REGEX_FLAGS","Token","Tokenizer","isLookahead","errorHandlers_readInt","errorRecovery","errorBuilder","errorHandlers_readCodePoint","errorHandlers_readStringContents_string","recordStrictModeErrors","errorHandlers_readStringContents_template","init","checkKeywordEscapes","pushToken","nextToken","curContext","inType","curPosition","old","createLookaheadState","curr","nextTokenStartSince","lastIndex","nextTokenStart","nextTokenInLineStartSince","nextTokenInLineStart","cp","trail","forEach","toParseError","clear","skipSpace","finishToken","getTokenFromCode","codePointAtPos","startSkip","spaceStart","loop","skipBlockComment","addComment","attachComment","skipLineComment","annexB","commentWhitespace","prevType","readToken_interpreter","nextPos","expectPlugin","readWord1","finishOp","readNumber","width","proposal","topicToken","lookaheadCh","codePointAt","size","readToken_dot","readToken_question","readTemplateToken","readRadixNumber","readString","readToken_slash","readToken_mult_modulo","readToken_pipe_amp","readToken_caret","readToken_plus_min","readToken_lt","readToken_gt","readToken_eq_excl","readToken_atSign","readToken_numberSign","readWord","escaped","inClass","content","mods","char","isBigInt","replace","startsWithDot","isFloat","isDecimal","hasExponent","isOctal","hasLeadingZero","integer","underscorePos","parseFloat","quote","opening","firstCode","containsEsc","escStart","identifierCheck","esc","pluginNames","some","ClassScope","privateNames","loneAccessors","undefinedPrivateNames","ClassScopeHandler","stack","oldClassScope","from","elementType","redefined","accessor","oldStatic","newStatic","oldKind","newKind","ExpressionScope","ArrowHeadParsingScope","declarationErrors","ParsingErrorClass","iterator","ExpressionScopeHandler","origin","isCertainlyParameterDeclaration","canBeArrowParameterDeclaration","recordDeclarationError","iterateErrors","clearDeclarationError","newParameterDeclarationScope","newArrowHeadScope","newAsyncArrowScope","newExpressionScope","ProductionParameterHandler","stacks","currentFlags","functionFlags","UtilParser","nameStart","nameEnd","nextCh","isUnparsedContextual","isContextual","eatContextual","hasPrecedingLineBreak","eat","canInsertSemicolon","allowAsi","isLineTerminator","fn","oldState","clone","abortSignal","failState","thrown","aborted","andThrow","shorthandAssignLoc","doubleProtoLoc","privateKeyLoc","optionalParametersLoc","hasErrors","property","oldLabels","oldExportedIdentifiers","exportedIdentifiers","oldInModule","oldScope","getScopeHandler","oldProdParam","prodParam","oldExpressionScope","expressionScope","paramFlags","enter","ExpressionErrors","Node","ranges","range","NodePrototype","prototype","clonePlaceholder","cloneIdentifier","cloned","create","expectedNode","cloneStringLiteral","__clone","newNode","NodeUtils","startNodeAt","processComment","locationNode","reservedTypes","FlowErrors","AmbiguousConditionalArrow","AmbiguousDeclareModuleKind","AssignReservedType","reservedType","DeclareClassElement","DeclareClassFieldInitializer","DuplicateDeclareModuleExports","EnumBooleanMemberNotInitialized","memberName","enumName","EnumDuplicateMemberName","EnumInconsistentMemberValues","EnumInvalidExplicitType","invalidEnumType","EnumInvalidExplicitTypeUnknownSupplied","EnumInvalidMemberInitializerPrimaryType","explicitType","EnumInvalidMemberInitializerSymbolType","EnumInvalidMemberInitializerUnknownType","EnumInvalidMemberName","suggestion","EnumNumberMemberNotInitialized","EnumStringMemberInconsistentlyInitialized","GetterMayNotHaveThisParam","ImportReflectionHasImportType","ImportTypeShorthandOnlyInPureImport","InexactInsideExact","InexactInsideNonObject","InexactVariance","InvalidNonTypeImportInDeclareModule","MissingTypeParamDefault","NestedDeclareModule","NestedFlowComment","PatternIsOptional","SetterMayNotHaveThisParam","SpreadVariance","ThisParamAnnotationRequired","ThisParamBannedInConstructor","ThisParamMayNotBeOptional","ThisParamMustBeFirst","ThisParamNoDefault","TypeBeforeInitializer","TypeCastInPattern","UnexpectedExplicitInexactInObject","UnexpectedReservedType","UnexpectedReservedUnderscore","UnexpectedSpaceBetweenModuloChecks","UnexpectedSpreadType","UnexpectedSubtractionOperand","UnexpectedTokenAfterTypeParameter","UnexpectedTypeParameterBeforeAsyncArrowFunction","UnsupportedDeclareExportKind","unsupportedExportKind","UnsupportedStatementInDeclareModule","UnterminatedFlowComment","isEsModuleType","bodyElement","hasTypeImportKind","importKind","exportSuggestions","const","let","interface","partition","list","list1","list2","FLOW_PRAGMA_REGEX","flow","flowPragma","matches","Error","tok","oldInType","expect","flowParseType","moduloLoc","expectContextual","parseExpression","predicate","flowParsePredicate","flowParseInterfaceish","parseIdentifier","typeNode","typeContainer","flowParseTypeParameterDeclaration","tmp","flowParseFunctionTypeParams","returnType","flowParseTypeAndPredicateInitialiser","typeAnnotation","semicolon","insideModule","flowParseDeclareClass","flowParseDeclareFunction","flowParseDeclareVariable","flowParseDeclareModuleExports","flowParseDeclareModule","flowParseDeclareTypeAlias","flowParseDeclareOpaqueType","flowParseDeclareInterface","flowParseDeclareExportDeclaration","flowParseTypeAnnotatableIdentifier","parseExprAtom","bodyNode","parseImport","flowParseDeclare","exit","hasModuleExport","default","isLet","exportKind","flowParseTypeAnnotation","finished","flowParseTypeAlias","flowParseOpaqueType","isClass","flowParseRestrictedIdentifier","extends","flowParseInterfaceExtends","implements","mixins","flowParseObjectType","allowStatic","allowExact","allowSpread","allowProto","allowInexact","flowParseQualifiedTypeIdentifier","flowParseTypeParameterInstantiation","liberal","checkReservedType","right","flowParseTypeInitialiser","declare","supertype","impltype","requireDefault","nodeStartLoc","variance","flowParseVariance","ident","bound","defaultRequired","typeParameter","flowParseTypeParameter","oldNoAnonFunctionType","noAnonFunctionType","flowParseTypeOrImplicitInstantiation","isStatic","static","lookahead","flowParseObjectPropertyKey","flowParseObjectTypeMethodish","flowParseFunctionTypeParam","valueNode","endDelim","exact","callProperties","indexers","internalSlots","inexact","protoStartLoc","inexactStartLoc","flowParseObjectTypeInternalSlot","flowParseObjectTypeIndexer","flowParseObjectTypeCallProperty","propOrInexact","flowParseObjectTypeProperty","flowObjectTypeSemicolon","isInexactToken","proto","flowCheckGetterSetterParams","paramCount","node2","qualification","flowParsePrimaryType","first","lh","isThis","checkNotUnderscore","flowParseGenericType","isGroupedType","flowParseTupleType","reinterpretTypeAsFunctionTypeParam","parseLiteralAtNode","flowParseTypeofType","createIdentifier","flowParseInterfaceType","flowIdentToTypeAnnotation","seenOptionalIndexedAccess","objectType","indexType","flowParsePrefixType","flowParsePostfixType","param","flowParseAnonFunctionWithoutParens","flowParseIntersectionType","flowParseUnionType","allowPrimitiveOverride","allowExpressionBody","forwardNoArrowParamsConversionAt","parseFunctionBodyAndFinish","flowParseInterface","shouldParseEnums","flowParseEnumDeclaration","parseStatementLike","isValidDirective","expr","parseExpressionStatement","shouldParseExportDeclaration","isExportDefaultSpecifier","parseExportDefaultExpression","maybeInArrowParameters","lookaheadCharCode","setOptionalParametersError","originalNoArrowAt","consequent","failed","tryParseConditionalConsequent","valid","getArrowLikeExpressions","alternate","parseMaybeAssign","parseMaybeAssignAllowIn","disallowInvalid","arrows","finishArrowValidation","every","_node$extra","toAssignableList","trailingCommaLoc","checkParams","result","parseParenItem","typeCastNode","assertModuleNodeAllowed","declarationNode","parseExportSpecifiers","parseExportFrom","parseExportDeclaration","eatExportStar","hasNamespace","maybeParseExportNamespaceSpecifier","isStatement","optionalId","parseClassId","member","parseClassMemberFromModifier","parseClassMember","fullWord","isIterator","readIterator","left","typeCastToParameter","exprList","isParenthesizedExpr","_expr$extra","close","canBePattern","isTuple","parseArrayLike","toReferencedList","isParenthesized","isClassMethod","isClassProperty","isNonstaticConstructor","pushClassMethod","isThisParam","pushClassPrivateMethod","parseClassSuper","superTypeParameters","implemented","checkGetterSetterParams","getObjectOrClassMethodParams","parseObjPropValue","parseMaybeDefault","checkImportReflection","module","specifier","local","finishImportSpecifier","isExport","isPotentialImportPhase","applyImportPhase","importedIsString","isInTypeOnlyImport","isMaybeTypeOnly","firstIdent","imported","specifierTypeKind","isLookaheadContextual","as_ident","specifierIsTypeImport","checkReservedWord","parseBindingAtom","parseFunctionParams","decl","parseVarId","parseAsyncArrowFromCallExpression","shouldParseAsyncArrow","afterLeftParse","_jsx","jsx","tryParse","currentContext","_jsx2","_jsx3","abort","_arrowExpression$extr","arrowExpression","resetStartLocationFromNode","maybeUnwrapTypeCastExpression","async","parseArrow","shouldParseArrow","setArrowFunctionParameters","allowDuplicates","isArrowFunction","strictModeChanged","canBeArrow","parseParenAndDistinguishExpression","parseCallExpressionArguments","parseAsyncArrowWithTypeParameters","parseSubscripts","subscriptState","isLookaheadToken_lt","typeArguments","shouldParseTypes","flowParseTypeParameterInstantiationCallOrNew","parseNewCallee","targs","parseArrowExpression","hasFlowComment","program","fileNode","parseTopLevel","skipFlowComment","hasFlowCommentCompletion","commentSkip","shiftToFirstNonWhiteSpace","ch2","ch3","enumContext","endOfInit","literal","parseNumericLiteral","parseStringLiteral","parseBooleanLiteral","flowEnumMemberInit","expectedType","flowEnumErrorInvalidMemberInitializer","seenNames","members","booleanMembers","numberMembers","stringMembers","defaultedMembers","hasUnknownMembers","memberNode","flowEnumMemberRaw","toUpperCase","flowEnumCheckExplicitTypeMismatch","flowEnumErrorBooleanMemberNotInitialized","flowEnumErrorNumberMemberNotInitialized","initializedMembers","flowEnumErrorStringMemberInconsistentlyInitialized","nameLoc","flowEnumParseExplicitType","flowEnumMembers","flowEnumStringMembers","empty","boolsLen","numsLen","strsLen","defaultedLen","flowEnumBody","afterNext","entities","__proto__","quot","amp","apos","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","nabla","isin","notin","ni","prod","sum","minus","lowast","radic","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","JsxErrors","AttributeIsEmpty","MissingClosingTagElement","openingTagName","MissingClosingTagFragment","UnexpectedSequenceExpression","HTMLEntity","UnsupportedJsxValue","UnterminatedJsxContent","UnwrappedAdjacentJSXElements","isFragment","getQualifiedJSXName","namespace","canStartJSXElement","jsxReadEntity","jsxReadNewLine","normalizeCRLF","codePoint","count","desc","entity","jsxParseIdentifier","jsxParseNamespacedName","setContext","jsxParseExpressionContainer","previousContext","jsxParseEmptyExpression","jsxParseAttributeValue","jsxParseElementName","jsxParseOpeningElementAfterName","jsxParseAttribute","selfClosing","children","openingElement","jsxParseOpeningElementAt","closingElement","contents","jsxParseClosingElementAt","jsxParseElementAt","jsxParseSpreadChild","openingFragment","closingFragment","newContext","jsxParseElement","replaceToken","jsxReadWord","jsxReadString","jsxReadToken","TypeScriptScope","tsNames","TypeScriptScopeHandler","importsStack","allowShadow","hasImport","isConst","wasConst","unwrapParenthesizedExpression","LValParser","_node$extra3","recordArrowParameterBindingError","last","_node$extra2","operator","arg","checkToRestConversion","elt","element","toReferencedListDeep","parseBindingList","parseObjectLike","closeCharCode","allowEmpty","elts","parseAssignableListItemTypes","parseRestBinding","checkCommaAfterRest","parseDecorator","parseAssignableListItem","parseBindingRestProperty","parsePropertyName","_left","checkClashes","hasParenthesizedAncestor","_expression$extra","isObjectMethod","checkIdentifier","validity","ParseErrorClass","isParenthesizedExpression","nextAncestor","child","checkLVal","declareNameFromIdentifier","identifier","allowPattern","nonNull","x","assert","TSErrors","AbstractMethodHasImplementation","methodName","AbstractPropertyHasInitializer","propertyName","AccessorCannotBeOptional","ClassMethodHasDeclare","ClassMethodHasReadonly","ConstructorHasTypeParameters","DeclareAccessor","DeclareClassFieldHasInitializer","DeclareFunctionHasImplementation","DuplicateAccessibilityModifier","modifier","DuplicateModifier","EmptyHeritageClauseType","EmptyTypeArguments","EmptyTypeParameters","ExpectedAmbientAfterExportDeclare","ImportAliasHasImportType","IncompatibleModifiers","modifiers","IndexSignatureHasAbstract","IndexSignatureHasAccessibility","IndexSignatureHasDeclare","IndexSignatureHasOverride","IndexSignatureHasStatic","InitializerNotAllowedInAmbientContext","InvalidModifierOnTypeMember","InvalidModifierOnTypeParameter","InvalidModifierOnTypeParameterPositions","InvalidModifiersOrder","orderedModifiers","InvalidPropertyAccessAfterInstantiationExpression","InvalidTupleMemberLabel","MissingInterfaceName","NonAbstractClassHasAbstractMethod","NonClassMethodPropertyHasAbstractModifer","OptionalTypeBeforeRequired","OverrideNotInSubClass","PrivateElementHasAbstract","PrivateElementHasAccessibility","ReadonlyForMethodSignature","ReservedArrowTypeParam","ReservedTypeAssertion","SingleTypeParameterWithoutTrailingComma","typeParameterName","StaticBlockCannotHaveModifier","TupleOptionalAfterType","TypeAnnotationAfterAssign","TypeImportCannotSpecifyDefaultAndNamed","TypeModifierIsUsedInTypeExports","TypeModifierIsUsedInTypeImports","UnexpectedParameterModifier","UnexpectedReadonly","UnexpectedTypeAnnotation","UnexpectedTypeCastInParameter","UnsupportedImportTypeArgument","UnsupportedParameterPropertyKind","UnsupportedSignatureParameterKind","keywordTypeFromName","tsIsAccessModifier","tsIsVarianceAnnotations","typescript","tsParseInOutModifiers","tsParseModifiers","bind","allowedModifiers","disallowedModifiers","errorTemplate","tsParseConstModifier","tsParseInOutConstModifiers","isLiteralPropertyName","tsTokenCanFollowModifier","tsNextTokenOnSameLineAndCanFollowModifier","stopOnStartOfClassStaticBlock","tsIsStartOfStaticBlocks","tsTryParse","tsNextTokenCanFollowModifier","modified","enforceOrder","before","after","incompatible","mod1","mod2","tsParseModifier","accessibility","parseElement","tsIsListTerminator","refTrailingCommaPos","tsParseDelimitedListWorker","expectSuccess","trailingCommaPos","bracket","skipFirstToken","tsParseDelimitedList","expectImportAttributesPlugin","qualifier","tsParseEntityName","tsParseTypeArguments","allowReservedWords","typeName","lhs","parameterName","tsParseTypeAnnotation","asserts","exprName","tsParseImportType","parseModifiers","tsParseTypeParameterName","constraint","tsEatThenParseType","tsParseTypeParameters","tsParseBracketedList","tsParseTypeParameter","addExtra","returnToken","signature","returnTokenRequired","paramsKey","returnTypeKey","tsTryParseTypeParameters","tsParseBindingListForSignature","tsParseTypeOrTypePredicateAnnotation","tsFillSignature","tsParseTypeMemberSemicolon","tsLookAhead","tsIsUnambiguouslyIndexSignature","parameters","tsTryParseTypeAnnotation","readonly","nodeAny","firstParameter","tsParseSignatureMember","tsParsePropertyOrMethodSignature","idx","tsTryParseIndexSignature","tsParseObjectTypeMembers","tsParseList","tsParseTypeMember","tsIsIdentifier","tsExpectThenParseType","nameType","tsParseType","tsTryParseType","elementTypes","tsParseTupleElementType","seenOptionalElement","elementNode","labeled","isWord","chAfterWord","wordName","typeOrLabel","tsParseNonArrayType","labeledNode","optionalTypeNode","restNode","abstract","tsInAllowConditionalTypesContext","parseTemplate","parseTemplateSubstitution","thisKeyword","tsParseThisTypeNode","tsParseThisTypePredicate","tsParseLiteralTypeNode","parseMaybeUnary","tsParseThisTypeOrThisTypePredicate","tsParseTypeQuery","tsIsStartOfMappedType","tsParseMappedType","tsParseTypeLiteral","tsParseTupleType","tsParseParenthesizedType","tsParseTemplateLiteralType","nodeType","tsParseTypeReference","tsParseTypeOperatorOrHigher","tsCheckTypeAnnotationForReadOnly","tsParseConstraintForInferType","tsInDisallowConditionalTypesContext","inDisallowConditionalTypesContext","isTypeOperator","tsParseTypeOperator","tsParseInferType","tsParseArrayTypeOrHigher","parseConstituentType","hasLeadingOperator","tsParseUnionOrIntersectionType","tsParseIntersectionTypeOrHigher","tsIsUnambiguouslyStartOfFunctionType","previousErrorCount","_unused2","tsSkipParameterStart","tsInType","tsParseTypePredicateAsserts","thisTypePredicate","typePredicateVariable","tsParseTypePredicatePrefix","eatColon","tsParseNonConditionalType","checkType","extendsType","trueType","falseType","tsIsStartOfFunctionType","tsParseFunctionOrConstructorType","isAbstractConstructorSignature","tsParseUnionTypeOrHigher","originalStartLoc","delimitedList","hasFollowingLineBreak","tsParseHeritageClause","cb","oldContext","oldInDisallowConditionalTypesContext","tsNextThenParseType","initializer","tsParseEnumMember","parseBlockOrModuleBlockBody","nested","inner","tsParseModuleOrNamespaceDeclaration","tsParseModuleBlock","global","maybeDefaultIdentifier","moduleReference","tsParseModuleReference","tsIsExternalModuleReference","tsParseExternalModuleReference","f","nany","startType","tsInAmbientContext","parseFunctionStatement","parseClass","tsParseEnumDeclaration","tsParseAmbientExternalModuleDeclaration","parseVarStatement","tsParseInterfaceDeclaration","tsParseDeclaration","tsTryParseDeclare","mod","tsCheckLineTerminator","tsParseAbstractDeclaration","tsParseTypeAliasDeclaration","oldMaybeInArrowParameters","tsTryParseAndCatch","tsTryParseTypeOrTypePredicateAnnotation","reScan_lt","tsInNoContext","reScan_lt_gt","tsIsDeclarationStart","override","pp","parameter","isSimpleParameter","isAmbientContext","tsDisallowOptionalPattern","bodilessType","registerFunctionStatementId","items","isInParens","tsCheckForInvalidTypeCasts","nonNullExpression","isOptionalCall","missingParenErrorLoc","atPossibleAsyncArrow","asyncArrowFn","tsTryParseGenericAsyncArrowFunction","tsParseTypeArgumentsInExpression","parseTaggedTemplateExpression","tokenType","_callee$extra","leftStartLoc","minPrec","isSatisfies","parseExprOp","checkKeywords","importNode","tsParseImportEqualsDeclaration","parseMaybeImportPhase","parseImportSpecifiersAndAfter","nodeImportEquals","isAbstractClass","cls","allowMissingInitializer","declarations","isValidAmbientConstInitializer","parseStatementContent","callParseClassMemberWithIsStatic","tsHasSomeModifiers","parseClassStaticBlock","parseClassMemberWithIsStatic","inAbstractClass","hadSuperClass","methodOrProp","tsParseExpressionStatement","parseConditional","isDeclare","isIdentifier","tsTryParseExportDeclaration","definite","parseClassPropertyAnnotation","parseClassAccessorProperty","declareClassPrivateMethodInScope","_typeCast","_typeCast2","typeCast","_typeParameters","reportReservedArrowTypeParam","trailingComma","sawUnary","tsParseTypeAssertion","toAssignableParenthesizedExpression","parseMaybeDecoratorArguments","canHaveLeadingDecorator","baseCount","getGetterSetterExpectedParamCount","firstParam","hasContextParam","parseCatchClauseParam","oldIsAmbientContext","oldStrict","oldInAbstractClass","maybeTakeDecorators","hasBody","shouldParseAsAmbientContext","getExpression","isString","isInTypeExport","parseTypeOnlyImportExportSpecifier","parseExportSpecifier","parseImportSpecifier","isImport","isInTypeOnlyImportExport","leftOfAsKey","rightOfAsKey","rightOfAs","leftOfAs","hasTypeSpecifier","canParseAsKeyword","firstAs","secondAs","parseModuleExportName","kindKey","isPossiblyLiteralEnum","expressions","isUncomputedMemberExpressionChain","isNumber","isNegativeNumber","PlaceholderErrors","ClassNameIsRequired","UnexpectedSpace","placeholders","assertNoSpace","finishPlaceholder","parsePlaceholder","chStartsBindingIdentifier","isBreak","verifyBreakContinue","parseStatementOrSloppyAnnexBFunctionDeclaration","stmtPlaceholder","createNewLexicalScope","parseBlock","requireId","parseFunctionId","parseClassBody","startsWith","_specifiers","maybeParseExportDefaultSpecifier","filter","checkExport","hasStarImport","maybeParseStarImportSpecifier","parseNamedImportSpecifiers","parseImportSource","v8intrinsic","v8IntrinsicStartLoc","parseIdentifierName","parseV8Intrinsic","PIPELINE_PROPOSALS","TOPIC_TOKENS","validatePlugins","pluginsMap","decoratorsBeforeExport","allowCallParenthesized","_pluginsMap$get","proposalList","p","tupleSyntaxIsHash","syntaxType","tokenList","moduleAttributesVersionPluginOption","version","RECORD_AND_TUPLE_SYNTAX_TYPES","missingPlugins","mixinPlugins","mixinPluginNames","defaultOptions","sourceFilename","allowAwaitOutsideFunction","allowReturnOutsideFunction","allowNewTargetOutsideFunction","allowImportExportEverywhere","allowSuperOutsideMethod","allowUndeclaredExports","createImportExpressions","createParenthesizedExpressions","getOptions","opts","_opts$key","ExpressionParser","isRecord","protoRef","used","enterInitialScopes","finalizeRemainingComments","disallowIn","disallowInAnd","parseExpressionBase","allowInAnd","resultError","_resultError$loc","hasYield","parseYield","ownExpressionErrors","parseMaybeConditional","startIndex","checkDestructuringPrivate","checkExpressionErrors","parseExprOps","shouldExitDescending","parseMaybeUnaryOrPrivate","hasIn","op","prec","inFSharpPipelineDirectBody","checkPipelineAtInfixOperator","logical","coalesce","hasAwait","parseExprOpRightExpr","finishedNode","nextOp","withTopicBindingContext","parseHackPipeBody","parseSmartPipelineBodyInStyle","parseExprOpBaseRightExpr","withSoloAwaitPermittingContext","parseFSharpPipelineBody","_body$extra","requiredParentheses","topicReferenceWasUsedInCurrentContext","isAwait","recordAwaitIfAllowed","parseAwait","checkExponentialAfterUnary","update","isDelete","parseUpdate","isAmbiguousAwait","raiseOverwrite","updateExpressionNode","parseExprSubscripts","maybeAsyncArrow","parseBind","parseCoverCallAndAsyncArrowHead","parseMember","parseNoCallExpr","validateAsPattern","tag","quasi","dynamicImport","allowPlaceholder","nodeForExtra","oldInFSharpPipelineDirectBody","addTrailingCommaExtraToNode","parseExprListItem","_call$extra","resetPreviousNodeTrailingComments","parseSuper","parseImportMetaProperty","parseImportCall","parseDo","readRegexp","parseRegExpLiteral","parseBigIntLiteral","parseDecimalLiteral","parseNullLiteral","parseFunctionOrFunctionSent","parseDecorators","parseNewOrNewTarget","parseTopicReferenceThenEqualsSign","parseTopicReference","pipeProposal","expectOnePlugin","lookaheadInLineCharCode","parseModuleExpression","parseAsyncFunctionExpression","parseAsyncArrowUnaryFunction","topicTokenType","topicTokenValue","finishTopicReference","testTopicReferenceConfiguration","topicReferenceIsAllowedInCurrentContext","registerTopicReference","allowSuper","meta","parseMetaProperty","parseFunction","isSource","innerStartLoc","spreadStartLoc","optionalCommaStartLoc","spreadNodeStartLoc","innerEndLoc","arrowNode","wrapParenthesis","takeSurroundingComments","parenExpression","metaProp","inNonArrowFunction","parseNew","parseExprList","isTagged","elemStart","elem","isTail","endOffset","elemEnd","cooked","tail","curElt","parseTemplateElement","quasis","substitutions","readTemplateContinuation","propHash","parseBindingProperty","parsePropertyDefinition","checkProto","parseSpread","parsePropertyNamePrefixOperator","maybeAsyncOrAccessorProp","keyName","_params","finishedProp","generator","isExpression","hasStrictModeDirective","nonSimple","isSimpleParamList","formalParameters","reservedTest","inStaticBlock","recordAsyncArrowParametersError","inClassAndNotInNonArrowFunction","isAwaitAllowed","inFunction","hasTopLevelAwait","recordParameterInitializerError","soloAwait","delegating","delegate","childExpr","isSimpleReference","checkSmartPipeTopicBodyEarlyErrors","callback","outerContextTopicState","outerContextSoloAwaitState","prodParamToSet","prodParamToClear","ret","revertScopes","initializeScopes","parseProgram","loopLabel","switchLabel","loneSurrogate","keywordRelationalOperator","babel7CompatTokens","hashEndPos","hashEndLoc","backquoteEnd","backquoteEndLoc","startToken","templateValue","templateElementEnd","templateElementEndLoc","endToken","StatementParser","interpreter","parseInterpreterDirective","finishedProgram","directiveLiteral","hasFollowingBindingAtom","endCh","chStartsBindingPattern","allowLabeledFunction","allowDeclaration","allowFunctionDeclaration","parseBreakContinueStatement","parseDebuggerStatement","parseDoWhileStatement","parseForStatement","parseIfStatement","parseReturnStatement","parseSwitchStatement","parseThrowStatement","parseTryStatement","startsAwaitUsing","hasInLineFollowingBindingIdentifierOrBrace","inTopLevel","parseWhileStatement","parseWithStatement","parseEmptyStatement","nextTokenCharCode","isAsyncFunction","maybeName","parseLabeledStatement","maybeDecorators","classNode","exportNode","allowExport","decoratorsEnabledBeforeExport","paramsStartLoc","lab","withSmartMixTopicForbiddingContext","parseStatement","parseHeaderExpression","awaitAt","parseFor","startsWithLet","startsWithAwaitUsing","starsWithUsingDeclaration","startsUsingForOf","isLetOrUsing","initNode","parseVar","isForIn","parseForIn","startsWithAsync","isForOf","isHangingDeclaration","hasReturn","discriminant","cases","cur","sawDefault","isCase","parseStatementListItem","block","handler","clause","finalizer","statementStart","parsedNonDirective","parseModuleItem","stmtToDirective","setStrict","await","isFor","parseMaybeAssignDisallowIn","hangingDeclaration","isDeclaration","treatFunctionsAsVar","hadConstructor","publicMethod","privateMethod","publicProp","privateProp","accessorProp","publicMember","parseClassElementName","maybeContextualKw","isPrivate","maybeQuestionTokenStartLoc","parsePostMemberNameModifiers","pushClassPrivateProperty","pushClassProperty","pushClassAccessorProperty","_member$decorators","declarePrivateName","parseInitializer","hasDefault","parseAfterDefault","hasStar","parseAfterNamespace","isFromRequired","hasSpecifiers","maybeParseExportNamedSpecifiers","hasDeclaration","maybeParseExportDeclaration","_node2$declaration","isTypeExport","assertions","nextType","hasFrom","nextAfterFrom","maybeParseImportAttributes","checkJSONModuleImport","checkNames","isDefault","isFrom","_node$specifiers","checkDuplicateExports","_declaration$extra","nodes","surrogate","singleBindingType","_node$assertions","isJSONModuleImport","nonDefaultNamedSpecifier","find","phaseIdentifier","isImportPhase","resetPreviousIdentifierLeadingComments","parseImportSourceAndAttributes","maybeParseDefaultImportSpecifier","parseNext","attrs","attrNames","useWith","parseModuleAttributes","parseImportAttributes","parseImportSpecifierLocal","importSpecifier","Parser","_options","getParser","ast","moduleError","generateExportedTokenTypes","internalTokenTypes","tokTypes","getParserClass","parserClassCache","pluginList"],"mappings":"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AG,GAAI,GAAI,GAAI,GAAI,GAAI,EAAG,GAAI,GAAI,GAAI,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,IAAK,GAAI,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,GAAI,GAAI,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,IAAK,GAAI,GAAI,GAAI,EAAG,GAAI,EAAG,EAAG,GAAI,EAAG,EAAG,GAAI,EAAG,EAAG,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,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,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,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,GAAI,EAAG,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,GAAI,EAAG,EAAG,GAAI,EAAG,GAAI,IAAK,EAAG,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,GAAI,GAAI,KAAM,GAAI,EAAG,KAAM,IAAK,KAAM,IAAK,EAAG,GAAI,GAAI,GAAI,GAAI,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,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,IAAK,GAAI,EAAG,GAAI,EAAG,EAAG,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,EAAG,EAAG,IAAK,GAAI,IAAK,GAAI,GAAI,EAAG,GAAI,EAAG,IAAK,GAAI,GAAI,GAAI,IAAK,GAAI,IAAK,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,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,EAAG,IAAK,EAAG,KAAM,GAAI,KAAM,GAAI,IAAK,KAAM,IAAK,KAAM,KAAM,EAAG,MAChhEC,GAAwB,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,GAAI,EAAG,GAAI,GAAI,GAAI,EAAG,IAAK,EAAG,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,GAAI,EAAG,GAAI,GAAI,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,IAAK,GAAI,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,IAAK,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,EAAG,IAAK,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,GAAI,GAAI,EAAG,GAAI,GAAI,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,IAAK,GAAI,IAAK,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,IAAK,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,IAAK,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,GAAI,EAAG,GAAI,IAAK,EAAG,EAAG,EAAG,EAAG,EAA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","file":"js/Production~6deefb52.5e53e7cd.js","sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nfunction _objectWithoutPropertiesLoose(r, e) {\n  if (null == r) return {};\n  var t = {};\n  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n    if (e.includes(n)) continue;\n    t[n] = r[n];\n  }\n  return t;\n}\nclass Position {\n  constructor(line, col, index) {\n    this.line = void 0;\n    this.column = void 0;\n    this.index = void 0;\n    this.line = line;\n    this.column = col;\n    this.index = index;\n  }\n}\nclass SourceLocation {\n  constructor(start, end) {\n    this.start = void 0;\n    this.end = void 0;\n    this.filename = void 0;\n    this.identifierName = void 0;\n    this.start = start;\n    this.end = end;\n  }\n}\nfunction createPositionWithColumnOffset(position, columnOffset) {\n  const {\n    line,\n    column,\n    index\n  } = position;\n  return new Position(line, column + columnOffset, index + columnOffset);\n}\nconst code = \"BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED\";\nvar ModuleErrors = {\n  ImportMetaOutsideModule: {\n    message: `import.meta may appear only with 'sourceType: \"module\"'`,\n    code\n  },\n  ImportOutsideModule: {\n    message: `'import' and 'export' may appear only with 'sourceType: \"module\"'`,\n    code\n  }\n};\nconst NodeDescriptions = {\n  ArrayPattern: \"array destructuring pattern\",\n  AssignmentExpression: \"assignment expression\",\n  AssignmentPattern: \"assignment expression\",\n  ArrowFunctionExpression: \"arrow function expression\",\n  ConditionalExpression: \"conditional expression\",\n  CatchClause: \"catch clause\",\n  ForOfStatement: \"for-of statement\",\n  ForInStatement: \"for-in statement\",\n  ForStatement: \"for-loop\",\n  FormalParameters: \"function parameter list\",\n  Identifier: \"identifier\",\n  ImportSpecifier: \"import specifier\",\n  ImportDefaultSpecifier: \"import default specifier\",\n  ImportNamespaceSpecifier: \"import namespace specifier\",\n  ObjectPattern: \"object destructuring pattern\",\n  ParenthesizedExpression: \"parenthesized expression\",\n  RestElement: \"rest element\",\n  UpdateExpression: {\n    true: \"prefix operation\",\n    false: \"postfix operation\"\n  },\n  VariableDeclarator: \"variable declaration\",\n  YieldExpression: \"yield expression\"\n};\nconst toNodeDescription = node => node.type === \"UpdateExpression\" ? NodeDescriptions.UpdateExpression[`${node.prefix}`] : NodeDescriptions[node.type];\nvar StandardErrors = {\n  AccessorIsGenerator: ({\n    kind\n  }) => `A ${kind}ter cannot be a generator.`,\n  ArgumentsInClass: \"'arguments' is only allowed in functions and class methods.\",\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  AwaitBindingIdentifierInStaticBlock: \"Can not use 'await' as identifier inside a static block.\",\n  AwaitExpressionFormalParameter: \"'await' is not allowed in async function parameters.\",\n  AwaitUsingNotInAsyncContext: \"'await using' is only allowed within async functions and at the top levels of modules.\",\n  AwaitNotInAsyncContext: \"'await' is only allowed within async functions and at the top levels of modules.\",\n  AwaitNotInAsyncFunction: \"'await' is only allowed within async functions.\",\n  BadGetterArity: \"A 'get' accessor must not have any formal parameters.\",\n  BadSetterArity: \"A 'set' accessor must have exactly one formal parameter.\",\n  BadSetterRestParameter: \"A 'set' accessor 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: ({\n    kind\n  }) => `Missing initializer in ${kind} declaration.`,\n  DecoratorArgumentsOutsideParentheses: \"Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.\",\n  DecoratorBeforeExport: \"Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.\",\n  DecoratorsBeforeAfterExport: \"Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.\",\n  DecoratorConstructor: \"Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?\",\n  DecoratorExportClass: \"Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.\",\n  DecoratorSemicolon: \"Decorators must not be followed by a semicolon.\",\n  DecoratorStaticBlock: \"Decorators can't be used with a static block.\",\n  DeferImportRequiresNamespace: 'Only `import defer * as x from \"./module\"` is valid.',\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: ({\n    exportName\n  }) => `\\`${exportName}\\` has already been exported. Exported identifiers must be unique.`,\n  DuplicateProto: \"Redefinition of __proto__ property.\",\n  DuplicateRegExpFlags: \"Duplicate regular expression flag.\",\n  DynamicImportPhaseRequiresImportExpressions: ({\n    phase\n  }) => `'import.${phase}(...)' can only be parsed when using the 'createImportExpressions' option.`,\n  ElementAfterRest: \"Rest element must be last element.\",\n  EscapedCharNotAnIdentifier: \"Invalid Unicode escape.\",\n  ExportBindingIsString: ({\n    localName,\n    exportName\n  }) => `A string literal cannot be used as an exported binding without \\`from\\`.\\n- Did you mean \\`export { '${localName}' as '${exportName}' } from 'some-module'\\`?`,\n  ExportDefaultFromAsIdentifier: \"'from' is not allowed as an identifier after 'export default'.\",\n  ForInOfLoopInitializer: ({\n    type\n  }) => `'${type === \"ForInStatement\" ? \"for-in\" : \"for-of\"}' loop variable declaration may not have an initializer.`,\n  ForInUsing: \"For-in loop may not start with 'using' declaration.\",\n  ForOfAsync: \"The left-hand side of a for-of loop may not be 'async'.\",\n  ForOfLet: \"The left-hand side of a for-of loop may not start with 'let'.\",\n  GeneratorInSingleStatementContext: \"Generators can only be declared at the top level or inside a block.\",\n  IllegalBreakContinue: ({\n    type\n  }) => `Unsyntactic ${type === \"BreakStatement\" ? \"break\" : \"continue\"}.`,\n  IllegalLanguageModeDirective: \"Illegal 'use strict' directive in function with non-simple parameter list.\",\n  IllegalReturn: \"'return' outside of function.\",\n  ImportAttributesUseAssert: \"The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedAssertSyntax: true` option in the import attributes plugin to suppress this error.\",\n  ImportBindingIsString: ({\n    importName\n  }) => `A string literal cannot be used as an imported binding.\\n- Did you mean \\`import { \"${importName}\" as foo }\\`?`,\n  ImportCallArgumentTrailingComma: \"Trailing comma is disallowed inside import(...) arguments.\",\n  ImportCallArity: ({\n    maxArgumentCount\n  }) => `\\`import()\\` requires exactly ${maxArgumentCount === 1 ? \"one argument\" : \"one or two arguments\"}.`,\n  ImportCallNotNewExpression: \"Cannot use new with import(...).\",\n  ImportCallSpreadArgument: \"`...` is not allowed in `import()`.\",\n  ImportJSONBindingNotDefault: \"A JSON module can only be imported with `default`.\",\n  ImportReflectionHasAssertion: \"`import module x` cannot have assertions.\",\n  ImportReflectionNotBinding: 'Only `import module x from \"./module\"` is valid.',\n  IncompatibleRegExpUVFlags: \"The 'u' and 'v' regular expression flags cannot be enabled at the same time.\",\n  InvalidBigIntLiteral: \"Invalid BigIntLiteral.\",\n  InvalidCodePoint: \"Code point out of bounds.\",\n  InvalidCoverInitializedName: \"Invalid shorthand property initializer.\",\n  InvalidDecimal: \"Invalid decimal.\",\n  InvalidDigit: ({\n    radix\n  }) => `Expected number in radix ${radix}.`,\n  InvalidEscapeSequence: \"Bad character escape sequence.\",\n  InvalidEscapeSequenceTemplate: \"Invalid escape sequence in template.\",\n  InvalidEscapedReservedWord: ({\n    reservedWord\n  }) => `Escape sequence in keyword ${reservedWord}.`,\n  InvalidIdentifier: ({\n    identifierName\n  }) => `Invalid identifier ${identifierName}.`,\n  InvalidLhs: ({\n    ancestor\n  }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,\n  InvalidLhsBinding: ({\n    ancestor\n  }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,\n  InvalidLhsOptionalChaining: ({\n    ancestor\n  }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`,\n  InvalidNumber: \"Invalid number.\",\n  InvalidOrMissingExponent: \"Floating-point numbers require a valid exponent after the 'e'.\",\n  InvalidOrUnexpectedToken: ({\n    unexpected\n  }) => `Unexpected character '${unexpected}'.`,\n  InvalidParenthesizedAssignment: \"Invalid parenthesized assignment pattern.\",\n  InvalidPrivateFieldResolution: ({\n    identifierName\n  }) => `Private name #${identifierName} 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: ({\n    labelName\n  }) => `Label '${labelName}' is already declared.`,\n  LetInLexicalBinding: \"'let' is disallowed as a lexically bound name.\",\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  MissingSemicolon: \"Missing semicolon.\",\n  MissingPlugin: ({\n    missingPlugin\n  }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map(name => JSON.stringify(name)).join(\", \")}.`,\n  MissingOneOfPlugins: ({\n    missingPlugin\n  }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map(name => JSON.stringify(name)).join(\", \")}.`,\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: ({\n    key\n  }) => `Duplicate key \"${key}\" is not allowed in module attributes.`,\n  ModuleExportNameHasLoneSurrogate: ({\n    surrogateCharCode\n  }) => `An export name cannot include a lone surrogate, found '\\\\u${surrogateCharCode.toString(16)}'.`,\n  ModuleExportUndefined: ({\n    localName\n  }) => `Export '${localName}' 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  OverrideOnConstructor: \"'override' modifier cannot appear on a constructor declaration.\",\n  ParamDupe: \"Argument name clash.\",\n  PatternHasAccessor: \"Object pattern can't contain getter or setter.\",\n  PatternHasMethod: \"Object pattern can't contain methods.\",\n  PrivateInExpectedIn: ({\n    identifierName\n  }) => `Private names are only allowed in property accesses (\\`obj.#${identifierName}\\`) or in \\`in\\` expressions (\\`#${identifierName} in obj\\`).`,\n  PrivateNameRedeclaration: ({\n    identifierName\n  }) => `Duplicate private name #${identifierName}.`,\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 or inside a block.\",\n  SloppyFunctionAnnexB: \"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  SourcePhaseImportRequiresDefault: 'Only `import source x from \"./module\"` is valid.',\n  StaticPrototype: \"Classes may not have static property named prototype.\",\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: ({\n    keyword\n  }) => `Unexpected keyword '${keyword}'.`,\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 or class properties.\",\n  UnexpectedNumericSeparator: \"A numeric separator is only allowed between two digits.\",\n  UnexpectedPrivateField: \"Unexpected private name.\",\n  UnexpectedReservedWord: ({\n    reservedWord\n  }) => `Unexpected reserved word '${reservedWord}'.`,\n  UnexpectedSuper: \"'super' is only allowed in object methods and classes.\",\n  UnexpectedToken: ({\n    expected,\n    unexpected\n  }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : \"\"}${expected ? `, expected \"${expected}\"` : \"\"}`,\n  UnexpectedTokenUnaryExponentiation: \"Illegal expression. Wrap left hand side or entire exponentiation in parentheses.\",\n  UnexpectedUsingDeclaration: \"Using declaration cannot appear in the top level when source type is `script`.\",\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: ({\n    target,\n    onlyValidPropertyName\n  }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,\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  UsingDeclarationExport: \"Using declaration cannot be exported.\",\n  UsingDeclarationHasBindingPattern: \"Using declaration cannot have destructuring patterns.\",\n  VarRedeclaration: ({\n    identifierName\n  }) => `Identifier '${identifierName}' has already been declared.`,\n  YieldBindingIdentifier: \"Can not use 'yield' as identifier inside a generator.\",\n  YieldInParameter: \"Yield expression is not allowed in formal parameters.\",\n  ZeroDigitNumericSeparator: \"Numeric separator can not be used after leading 0.\"\n};\nvar StrictModeErrors = {\n  StrictDelete: \"Deleting local variable in strict mode.\",\n  StrictEvalArguments: ({\n    referenceName\n  }) => `Assigning to '${referenceName}' in strict mode.`,\n  StrictEvalArgumentsBinding: ({\n    bindingName\n  }) => `Binding '${bindingName}' 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};\nconst UnparenthesizedPipeBodyDescriptions = new Set([\"ArrowFunctionExpression\", \"AssignmentExpression\", \"ConditionalExpression\", \"YieldExpression\"]);\nvar PipelineOperatorErrors = {\n  PipeBodyIsTighter: \"Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.\",\n  PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.',\n  PipeTopicUnbound: \"Topic reference is unbound; it must be inside a pipe body.\",\n  PipeTopicUnconfiguredToken: ({\n    token\n  }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { \"proposal\": \"hack\", \"topicToken\": \"${token}\" }.`,\n  PipeTopicUnused: \"Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.\",\n  PipeUnparenthesizedBody: ({\n    type\n  }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({\n    type\n  })}; please wrap it in parentheses.`,\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: 'Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.'\n};\nconst _excluded = [\"message\"];\nfunction defineHidden(obj, key, value) {\n  Object.defineProperty(obj, key, {\n    enumerable: false,\n    configurable: true,\n    value\n  });\n}\nfunction toParseErrorConstructor({\n  toMessage,\n  code,\n  reasonCode,\n  syntaxPlugin\n}) {\n  const hasMissingPlugin = reasonCode === \"MissingPlugin\" || reasonCode === \"MissingOneOfPlugins\";\n  {\n    const oldReasonCodes = {\n      AccessorCannotDeclareThisParameter: \"AccesorCannotDeclareThisParameter\",\n      AccessorCannotHaveTypeParameters: \"AccesorCannotHaveTypeParameters\",\n      ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: \"ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference\",\n      SetAccessorCannotHaveOptionalParameter: \"SetAccesorCannotHaveOptionalParameter\",\n      SetAccessorCannotHaveRestParameter: \"SetAccesorCannotHaveRestParameter\",\n      SetAccessorCannotHaveReturnType: \"SetAccesorCannotHaveReturnType\"\n    };\n    if (oldReasonCodes[reasonCode]) {\n      reasonCode = oldReasonCodes[reasonCode];\n    }\n  }\n  return function constructor(loc, details) {\n    const error = new SyntaxError();\n    error.code = code;\n    error.reasonCode = reasonCode;\n    error.loc = loc;\n    error.pos = loc.index;\n    error.syntaxPlugin = syntaxPlugin;\n    if (hasMissingPlugin) {\n      error.missingPlugin = details.missingPlugin;\n    }\n    defineHidden(error, \"clone\", function clone(overrides = {}) {\n      var _overrides$loc;\n      const {\n        line,\n        column,\n        index\n      } = (_overrides$loc = overrides.loc) != null ? _overrides$loc : loc;\n      return constructor(new Position(line, column, index), Object.assign({}, details, overrides.details));\n    });\n    defineHidden(error, \"details\", details);\n    Object.defineProperty(error, \"message\", {\n      configurable: true,\n      get() {\n        const message = `${toMessage(details)} (${loc.line}:${loc.column})`;\n        this.message = message;\n        return message;\n      },\n      set(value) {\n        Object.defineProperty(this, \"message\", {\n          value,\n          writable: true\n        });\n      }\n    });\n    return error;\n  };\n}\nfunction ParseErrorEnum(argument, syntaxPlugin) {\n  if (Array.isArray(argument)) {\n    return parseErrorTemplates => ParseErrorEnum(parseErrorTemplates, argument[0]);\n  }\n  const ParseErrorConstructors = {};\n  for (const reasonCode of Object.keys(argument)) {\n    const template = argument[reasonCode];\n    const _ref = typeof template === \"string\" ? {\n        message: () => template\n      } : typeof template === \"function\" ? {\n        message: template\n      } : template,\n      {\n        message\n      } = _ref,\n      rest = _objectWithoutPropertiesLoose(_ref, _excluded);\n    const toMessage = typeof message === \"string\" ? () => message : message;\n    ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({\n      code: \"BABEL_PARSER_SYNTAX_ERROR\",\n      reasonCode,\n      toMessage\n    }, syntaxPlugin ? {\n      syntaxPlugin\n    } : {}, rest));\n  }\n  return ParseErrorConstructors;\n}\nconst Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));\nconst {\n  defineProperty\n} = Object;\nconst toUnenumerable = (object, key) => {\n  if (object) {\n    defineProperty(object, key, {\n      enumerable: false,\n      value: object[key]\n    });\n  }\n};\nfunction toESTreeLocation(node) {\n  toUnenumerable(node.loc.start, \"index\");\n  toUnenumerable(node.loc.end, \"index\");\n  return node;\n}\nvar estree = superClass => class ESTreeParserMixin extends superClass {\n  parse() {\n    const file = toESTreeLocation(super.parse());\n    if (this.options.tokens) {\n      file.tokens = file.tokens.map(toESTreeLocation);\n    }\n    return file;\n  }\n  parseRegExpLiteral({\n    pattern,\n    flags\n  }) {\n    let regex = null;\n    try {\n      regex = new RegExp(pattern, flags);\n    } catch (_) {}\n    const node = this.estreeParseLiteral(regex);\n    node.regex = {\n      pattern,\n      flags\n    };\n    return node;\n  }\n  parseBigIntLiteral(value) {\n    let bigInt;\n    try {\n      bigInt = BigInt(value);\n    } catch (_unused) {\n      bigInt = null;\n    }\n    const node = this.estreeParseLiteral(bigInt);\n    node.bigint = String(node.value || value);\n    return node;\n  }\n  parseDecimalLiteral(value) {\n    const decimal = null;\n    const node = this.estreeParseLiteral(decimal);\n    node.decimal = String(node.value || value);\n    return node;\n  }\n  estreeParseLiteral(value) {\n    return this.parseLiteral(value, \"Literal\");\n  }\n  parseStringLiteral(value) {\n    return this.estreeParseLiteral(value);\n  }\n  parseNumericLiteral(value) {\n    return this.estreeParseLiteral(value);\n  }\n  parseNullLiteral() {\n    return this.estreeParseLiteral(null);\n  }\n  parseBooleanLiteral(value) {\n    return this.estreeParseLiteral(value);\n  }\n  directiveToStmt(directive) {\n    const expression = directive.value;\n    delete directive.value;\n    expression.type = \"Literal\";\n    expression.raw = expression.extra.raw;\n    expression.value = expression.extra.expressionValue;\n    const stmt = directive;\n    stmt.type = \"ExpressionStatement\";\n    stmt.expression = expression;\n    stmt.directive = expression.extra.rawValue;\n    delete expression.extra;\n    return stmt;\n  }\n  initFunction(node, isAsync) {\n    super.initFunction(node, isAsync);\n    node.expression = false;\n  }\n  checkDeclaration(node) {\n    if (node != null && this.isObjectProperty(node)) {\n      this.checkDeclaration(node.value);\n    } else {\n      super.checkDeclaration(node);\n    }\n  }\n  getObjectOrClassMethodParams(method) {\n    return method.value.params;\n  }\n  isValidDirective(stmt) {\n    var _stmt$expression$extr;\n    return stmt.type === \"ExpressionStatement\" && stmt.expression.type === \"Literal\" && typeof stmt.expression.value === \"string\" && !((_stmt$expression$extr = stmt.expression.extra) != null && _stmt$expression$extr.parenthesized);\n  }\n  parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {\n    super.parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse);\n    const directiveStatements = node.directives.map(d => this.directiveToStmt(d));\n    node.body = directiveStatements.concat(node.body);\n    delete node.directives;\n  }\n  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n    this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, \"ClassMethod\", true);\n    if (method.typeParameters) {\n      method.value.typeParameters = method.typeParameters;\n      delete method.typeParameters;\n    }\n    classBody.body.push(method);\n  }\n  parsePrivateName() {\n    const node = super.parsePrivateName();\n    {\n      if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n        return node;\n      }\n    }\n    return this.convertPrivateNameToPrivateIdentifier(node);\n  }\n  convertPrivateNameToPrivateIdentifier(node) {\n    const name = super.getPrivateNameSV(node);\n    node = node;\n    delete node.id;\n    node.name = name;\n    node.type = \"PrivateIdentifier\";\n    return node;\n  }\n  isPrivateName(node) {\n    {\n      if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n        return super.isPrivateName(node);\n      }\n    }\n    return node.type === \"PrivateIdentifier\";\n  }\n  getPrivateNameSV(node) {\n    {\n      if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n        return super.getPrivateNameSV(node);\n      }\n    }\n    return node.name;\n  }\n  parseLiteral(value, type) {\n    const node = super.parseLiteral(value, type);\n    node.raw = node.extra.raw;\n    delete node.extra;\n    return node;\n  }\n  parseFunctionBody(node, allowExpression, isMethod = false) {\n    super.parseFunctionBody(node, allowExpression, isMethod);\n    node.expression = node.body.type !== \"BlockStatement\";\n  }\n  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {\n    let funcNode = this.startNode();\n    funcNode.kind = node.kind;\n    funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);\n    funcNode.type = \"FunctionExpression\";\n    delete funcNode.kind;\n    node.value = funcNode;\n    if (type === \"ClassPrivateMethod\") {\n      node.computed = false;\n    }\n    return this.finishNode(node, \"MethodDefinition\");\n  }\n  nameIsConstructor(key) {\n    if (key.type === \"Literal\") return key.value === \"constructor\";\n    return super.nameIsConstructor(key);\n  }\n  parseClassProperty(...args) {\n    const propertyNode = super.parseClassProperty(...args);\n    {\n      if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n        return propertyNode;\n      }\n    }\n    propertyNode.type = \"PropertyDefinition\";\n    return propertyNode;\n  }\n  parseClassPrivateProperty(...args) {\n    const propertyNode = super.parseClassPrivateProperty(...args);\n    {\n      if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n        return propertyNode;\n      }\n    }\n    propertyNode.type = \"PropertyDefinition\";\n    propertyNode.computed = false;\n    return propertyNode;\n  }\n  parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {\n    const node = super.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor);\n    if (node) {\n      node.type = \"Property\";\n      if (node.kind === \"method\") {\n        node.kind = \"init\";\n      }\n      node.shorthand = false;\n    }\n    return node;\n  }\n  parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {\n    const node = super.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);\n    if (node) {\n      node.kind = \"init\";\n      node.type = \"Property\";\n    }\n    return node;\n  }\n  isValidLVal(type, isUnparenthesizedInAssign, binding) {\n    return type === \"Property\" ? \"value\" : super.isValidLVal(type, isUnparenthesizedInAssign, binding);\n  }\n  isAssignable(node, isBinding) {\n    if (node != null && this.isObjectProperty(node)) {\n      return this.isAssignable(node.value, isBinding);\n    }\n    return super.isAssignable(node, isBinding);\n  }\n  toAssignable(node, isLHS = false) {\n    if (node != null && this.isObjectProperty(node)) {\n      const {\n        key,\n        value\n      } = node;\n      if (this.isPrivateName(key)) {\n        this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);\n      }\n      this.toAssignable(value, isLHS);\n    } else {\n      super.toAssignable(node, isLHS);\n    }\n  }\n  toAssignableObjectExpressionProp(prop, isLast, isLHS) {\n    if (prop.type === \"Property\" && (prop.kind === \"get\" || prop.kind === \"set\")) {\n      this.raise(Errors.PatternHasAccessor, prop.key);\n    } else if (prop.type === \"Property\" && prop.method) {\n      this.raise(Errors.PatternHasMethod, prop.key);\n    } else {\n      super.toAssignableObjectExpressionProp(prop, isLast, isLHS);\n    }\n  }\n  finishCallExpression(unfinished, optional) {\n    const node = super.finishCallExpression(unfinished, optional);\n    if (node.callee.type === \"Import\") {\n      node.type = \"ImportExpression\";\n      node.source = node.arguments[0];\n      if (this.hasPlugin(\"importAttributes\") || this.hasPlugin(\"importAssertions\")) {\n        var _ref, _ref2;\n        node.options = (_ref = node.arguments[1]) != null ? _ref : null;\n        node.attributes = (_ref2 = node.arguments[1]) != null ? _ref2 : null;\n      }\n      delete node.arguments;\n      delete node.callee;\n    }\n    return node;\n  }\n  toReferencedArguments(node) {\n    if (node.type === \"ImportExpression\") {\n      return;\n    }\n    super.toReferencedArguments(node);\n  }\n  parseExport(unfinished, decorators) {\n    const exportStartLoc = this.state.lastTokStartLoc;\n    const node = super.parseExport(unfinished, decorators);\n    switch (node.type) {\n      case \"ExportAllDeclaration\":\n        node.exported = null;\n        break;\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      case \"ExportDefaultDeclaration\":\n        {\n          var _declaration$decorato;\n          const {\n            declaration\n          } = node;\n          if ((declaration == null ? void 0 : declaration.type) === \"ClassDeclaration\" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) {\n            this.resetStartLocation(node, exportStartLoc);\n          }\n        }\n        break;\n    }\n    return node;\n  }\n  parseSubscript(base, startLoc, noCalls, state) {\n    const node = super.parseSubscript(base, startLoc, noCalls, state);\n    if (state.optionalChainMember) {\n      if (node.type === \"OptionalMemberExpression\" || node.type === \"OptionalCallExpression\") {\n        node.type = node.type.substring(8);\n      }\n      if (state.stop) {\n        const 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    return node;\n  }\n  isOptionalMemberExpression(node) {\n    if (node.type === \"ChainExpression\") {\n      return node.expression.type === \"MemberExpression\";\n    }\n    return super.isOptionalMemberExpression(node);\n  }\n  hasPropertyAsPrivateName(node) {\n    if (node.type === \"ChainExpression\") {\n      node = node.expression;\n    }\n    return super.hasPropertyAsPrivateName(node);\n  }\n  isObjectProperty(node) {\n    return node.type === \"Property\" && node.kind === \"init\" && !node.method;\n  }\n  isObjectMethod(node) {\n    return node.type === \"Property\" && (node.method || node.kind === \"get\" || node.kind === \"set\");\n  }\n  finishNodeAt(node, type, endLoc) {\n    return toESTreeLocation(super.finishNodeAt(node, type, endLoc));\n  }\n  resetStartLocation(node, startLoc) {\n    super.resetStartLocation(node, startLoc);\n    toESTreeLocation(node);\n  }\n  resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {\n    super.resetEndLocation(node, endLoc);\n    toESTreeLocation(node);\n  }\n};\nclass TokContext {\n  constructor(token, preserveSpace) {\n    this.token = void 0;\n    this.preserveSpace = void 0;\n    this.token = token;\n    this.preserveSpace = !!preserveSpace;\n  }\n}\nconst types = {\n  brace: new TokContext(\"{\"),\n  j_oTag: new TokContext(\"<tag\"),\n  j_cTag: new TokContext(\"</tag\"),\n  j_expr: new TokContext(\"<tag>...</tag>\", true)\n};\n{\n  types.template = new TokContext(\"`\", true);\n}\nconst beforeExpr = true;\nconst startsExpr = true;\nconst isLoop = true;\nconst isAssign = true;\nconst prefix = true;\nconst postfix = true;\nclass ExportedTokenType {\n  constructor(label, conf = {}) {\n    this.label = void 0;\n    this.keyword = void 0;\n    this.beforeExpr = void 0;\n    this.startsExpr = void 0;\n    this.rightAssociative = void 0;\n    this.isLoop = void 0;\n    this.isAssign = void 0;\n    this.prefix = void 0;\n    this.postfix = void 0;\n    this.binop = void 0;\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    {\n      this.updateContext = null;\n    }\n  }\n}\nconst keywords$1 = new Map();\nfunction createKeyword(name, options = {}) {\n  options.keyword = name;\n  const token = createToken(name, options);\n  keywords$1.set(name, token);\n  return token;\n}\nfunction createBinop(name, binop) {\n  return createToken(name, {\n    beforeExpr,\n    binop\n  });\n}\nlet tokenTypeCounter = -1;\nconst tokenTypes = [];\nconst tokenLabels = [];\nconst tokenBinops = [];\nconst tokenBeforeExprs = [];\nconst tokenStartsExprs = [];\nconst tokenPrefixes = [];\nfunction createToken(name, options = {}) {\n  var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;\n  ++tokenTypeCounter;\n  tokenLabels.push(name);\n  tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1);\n  tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false);\n  tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false);\n  tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false);\n  tokenTypes.push(new ExportedTokenType(name, options));\n  return tokenTypeCounter;\n}\nfunction createKeywordLike(name, options = {}) {\n  var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;\n  ++tokenTypeCounter;\n  keywords$1.set(name, tokenTypeCounter);\n  tokenLabels.push(name);\n  tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1);\n  tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false);\n  tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false);\n  tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false);\n  tokenTypes.push(new ExportedTokenType(\"name\", options));\n  return tokenTypeCounter;\n}\nconst tt = {\n  bracketL: createToken(\"[\", {\n    beforeExpr,\n    startsExpr\n  }),\n  bracketHashL: createToken(\"#[\", {\n    beforeExpr,\n    startsExpr\n  }),\n  bracketBarL: createToken(\"[|\", {\n    beforeExpr,\n    startsExpr\n  }),\n  bracketR: createToken(\"]\"),\n  bracketBarR: createToken(\"|]\"),\n  braceL: createToken(\"{\", {\n    beforeExpr,\n    startsExpr\n  }),\n  braceBarL: createToken(\"{|\", {\n    beforeExpr,\n    startsExpr\n  }),\n  braceHashL: createToken(\"#{\", {\n    beforeExpr,\n    startsExpr\n  }),\n  braceR: createToken(\"}\"),\n  braceBarR: createToken(\"|}\"),\n  parenL: createToken(\"(\", {\n    beforeExpr,\n    startsExpr\n  }),\n  parenR: createToken(\")\"),\n  comma: createToken(\",\", {\n    beforeExpr\n  }),\n  semi: createToken(\";\", {\n    beforeExpr\n  }),\n  colon: createToken(\":\", {\n    beforeExpr\n  }),\n  doubleColon: createToken(\"::\", {\n    beforeExpr\n  }),\n  dot: createToken(\".\"),\n  question: createToken(\"?\", {\n    beforeExpr\n  }),\n  questionDot: createToken(\"?.\"),\n  arrow: createToken(\"=>\", {\n    beforeExpr\n  }),\n  template: createToken(\"template\"),\n  ellipsis: createToken(\"...\", {\n    beforeExpr\n  }),\n  backQuote: createToken(\"`\", {\n    startsExpr\n  }),\n  dollarBraceL: createToken(\"${\", {\n    beforeExpr,\n    startsExpr\n  }),\n  templateTail: createToken(\"...`\", {\n    startsExpr\n  }),\n  templateNonTail: createToken(\"...${\", {\n    beforeExpr,\n    startsExpr\n  }),\n  at: createToken(\"@\"),\n  hash: createToken(\"#\", {\n    startsExpr\n  }),\n  interpreterDirective: createToken(\"#!...\"),\n  eq: createToken(\"=\", {\n    beforeExpr,\n    isAssign\n  }),\n  assign: createToken(\"_=\", {\n    beforeExpr,\n    isAssign\n  }),\n  slashAssign: createToken(\"_=\", {\n    beforeExpr,\n    isAssign\n  }),\n  xorAssign: createToken(\"_=\", {\n    beforeExpr,\n    isAssign\n  }),\n  moduloAssign: createToken(\"_=\", {\n    beforeExpr,\n    isAssign\n  }),\n  incDec: createToken(\"++/--\", {\n    prefix,\n    postfix,\n    startsExpr\n  }),\n  bang: createToken(\"!\", {\n    beforeExpr,\n    prefix,\n    startsExpr\n  }),\n  tilde: createToken(\"~\", {\n    beforeExpr,\n    prefix,\n    startsExpr\n  }),\n  doubleCaret: createToken(\"^^\", {\n    startsExpr\n  }),\n  doubleAt: createToken(\"@@\", {\n    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  lt: createBinop(\"</>/<=/>=\", 7),\n  gt: createBinop(\"</>/<=/>=\", 7),\n  relational: createBinop(\"</>/<=/>=\", 7),\n  bitShift: createBinop(\"<</>>/>>>\", 8),\n  bitShiftL: createBinop(\"<</>>/>>>\", 8),\n  bitShiftR: createBinop(\"<</>>/>>>\", 8),\n  plusMin: createToken(\"+/-\", {\n    beforeExpr,\n    binop: 9,\n    prefix,\n    startsExpr\n  }),\n  modulo: createToken(\"%\", {\n    binop: 10,\n    startsExpr\n  }),\n  star: createToken(\"*\", {\n    binop: 10\n  }),\n  slash: createBinop(\"/\", 10),\n  exponent: createToken(\"**\", {\n    beforeExpr,\n    binop: 11,\n    rightAssociative: true\n  }),\n  _in: createKeyword(\"in\", {\n    beforeExpr,\n    binop: 7\n  }),\n  _instanceof: createKeyword(\"instanceof\", {\n    beforeExpr,\n    binop: 7\n  }),\n  _break: createKeyword(\"break\"),\n  _case: createKeyword(\"case\", {\n    beforeExpr\n  }),\n  _catch: createKeyword(\"catch\"),\n  _continue: createKeyword(\"continue\"),\n  _debugger: createKeyword(\"debugger\"),\n  _default: createKeyword(\"default\", {\n    beforeExpr\n  }),\n  _else: createKeyword(\"else\", {\n    beforeExpr\n  }),\n  _finally: createKeyword(\"finally\"),\n  _function: createKeyword(\"function\", {\n    startsExpr\n  }),\n  _if: createKeyword(\"if\"),\n  _return: createKeyword(\"return\", {\n    beforeExpr\n  }),\n  _switch: createKeyword(\"switch\"),\n  _throw: createKeyword(\"throw\", {\n    beforeExpr,\n    prefix,\n    startsExpr\n  }),\n  _try: createKeyword(\"try\"),\n  _var: createKeyword(\"var\"),\n  _const: createKeyword(\"const\"),\n  _with: createKeyword(\"with\"),\n  _new: createKeyword(\"new\", {\n    beforeExpr,\n    startsExpr\n  }),\n  _this: createKeyword(\"this\", {\n    startsExpr\n  }),\n  _super: createKeyword(\"super\", {\n    startsExpr\n  }),\n  _class: createKeyword(\"class\", {\n    startsExpr\n  }),\n  _extends: createKeyword(\"extends\", {\n    beforeExpr\n  }),\n  _export: createKeyword(\"export\"),\n  _import: createKeyword(\"import\", {\n    startsExpr\n  }),\n  _null: createKeyword(\"null\", {\n    startsExpr\n  }),\n  _true: createKeyword(\"true\", {\n    startsExpr\n  }),\n  _false: createKeyword(\"false\", {\n    startsExpr\n  }),\n  _typeof: createKeyword(\"typeof\", {\n    beforeExpr,\n    prefix,\n    startsExpr\n  }),\n  _void: createKeyword(\"void\", {\n    beforeExpr,\n    prefix,\n    startsExpr\n  }),\n  _delete: createKeyword(\"delete\", {\n    beforeExpr,\n    prefix,\n    startsExpr\n  }),\n  _do: createKeyword(\"do\", {\n    isLoop,\n    beforeExpr\n  }),\n  _for: createKeyword(\"for\", {\n    isLoop\n  }),\n  _while: createKeyword(\"while\", {\n    isLoop\n  }),\n  _as: createKeywordLike(\"as\", {\n    startsExpr\n  }),\n  _assert: createKeywordLike(\"assert\", {\n    startsExpr\n  }),\n  _async: createKeywordLike(\"async\", {\n    startsExpr\n  }),\n  _await: createKeywordLike(\"await\", {\n    startsExpr\n  }),\n  _defer: createKeywordLike(\"defer\", {\n    startsExpr\n  }),\n  _from: createKeywordLike(\"from\", {\n    startsExpr\n  }),\n  _get: createKeywordLike(\"get\", {\n    startsExpr\n  }),\n  _let: createKeywordLike(\"let\", {\n    startsExpr\n  }),\n  _meta: createKeywordLike(\"meta\", {\n    startsExpr\n  }),\n  _of: createKeywordLike(\"of\", {\n    startsExpr\n  }),\n  _sent: createKeywordLike(\"sent\", {\n    startsExpr\n  }),\n  _set: createKeywordLike(\"set\", {\n    startsExpr\n  }),\n  _source: createKeywordLike(\"source\", {\n    startsExpr\n  }),\n  _static: createKeywordLike(\"static\", {\n    startsExpr\n  }),\n  _using: createKeywordLike(\"using\", {\n    startsExpr\n  }),\n  _yield: createKeywordLike(\"yield\", {\n    startsExpr\n  }),\n  _asserts: createKeywordLike(\"asserts\", {\n    startsExpr\n  }),\n  _checks: createKeywordLike(\"checks\", {\n    startsExpr\n  }),\n  _exports: createKeywordLike(\"exports\", {\n    startsExpr\n  }),\n  _global: createKeywordLike(\"global\", {\n    startsExpr\n  }),\n  _implements: createKeywordLike(\"implements\", {\n    startsExpr\n  }),\n  _intrinsic: createKeywordLike(\"intrinsic\", {\n    startsExpr\n  }),\n  _infer: createKeywordLike(\"infer\", {\n    startsExpr\n  }),\n  _is: createKeywordLike(\"is\", {\n    startsExpr\n  }),\n  _mixins: createKeywordLike(\"mixins\", {\n    startsExpr\n  }),\n  _proto: createKeywordLike(\"proto\", {\n    startsExpr\n  }),\n  _require: createKeywordLike(\"require\", {\n    startsExpr\n  }),\n  _satisfies: createKeywordLike(\"satisfies\", {\n    startsExpr\n  }),\n  _keyof: createKeywordLike(\"keyof\", {\n    startsExpr\n  }),\n  _readonly: createKeywordLike(\"readonly\", {\n    startsExpr\n  }),\n  _unique: createKeywordLike(\"unique\", {\n    startsExpr\n  }),\n  _abstract: createKeywordLike(\"abstract\", {\n    startsExpr\n  }),\n  _declare: createKeywordLike(\"declare\", {\n    startsExpr\n  }),\n  _enum: createKeywordLike(\"enum\", {\n    startsExpr\n  }),\n  _module: createKeywordLike(\"module\", {\n    startsExpr\n  }),\n  _namespace: createKeywordLike(\"namespace\", {\n    startsExpr\n  }),\n  _interface: createKeywordLike(\"interface\", {\n    startsExpr\n  }),\n  _type: createKeywordLike(\"type\", {\n    startsExpr\n  }),\n  _opaque: createKeywordLike(\"opaque\", {\n    startsExpr\n  }),\n  name: createToken(\"name\", {\n    startsExpr\n  }),\n  string: createToken(\"string\", {\n    startsExpr\n  }),\n  num: createToken(\"num\", {\n    startsExpr\n  }),\n  bigint: createToken(\"bigint\", {\n    startsExpr\n  }),\n  decimal: createToken(\"decimal\", {\n    startsExpr\n  }),\n  regexp: createToken(\"regexp\", {\n    startsExpr\n  }),\n  privateName: createToken(\"#name\", {\n    startsExpr\n  }),\n  eof: createToken(\"eof\"),\n  jsxName: createToken(\"jsxName\"),\n  jsxText: createToken(\"jsxText\", {\n    beforeExpr: true\n  }),\n  jsxTagStart: createToken(\"jsxTagStart\", {\n    startsExpr: true\n  }),\n  jsxTagEnd: createToken(\"jsxTagEnd\"),\n  placeholder: createToken(\"%%\", {\n    startsExpr: true\n  })\n};\nfunction tokenIsIdentifier(token) {\n  return token >= 93 && token <= 132;\n}\nfunction tokenKeywordOrIdentifierIsKeyword(token) {\n  return token <= 92;\n}\nfunction tokenIsKeywordOrIdentifier(token) {\n  return token >= 58 && token <= 132;\n}\nfunction tokenIsLiteralPropertyName(token) {\n  return token >= 58 && token <= 136;\n}\nfunction tokenComesBeforeExpression(token) {\n  return tokenBeforeExprs[token];\n}\nfunction tokenCanStartExpression(token) {\n  return tokenStartsExprs[token];\n}\nfunction tokenIsAssignment(token) {\n  return token >= 29 && token <= 33;\n}\nfunction tokenIsFlowInterfaceOrTypeOrOpaque(token) {\n  return token >= 129 && token <= 131;\n}\nfunction tokenIsLoop(token) {\n  return token >= 90 && token <= 92;\n}\nfunction tokenIsKeyword(token) {\n  return token >= 58 && token <= 92;\n}\nfunction tokenIsOperator(token) {\n  return token >= 39 && token <= 59;\n}\nfunction tokenIsPostfix(token) {\n  return token === 34;\n}\nfunction tokenIsPrefix(token) {\n  return tokenPrefixes[token];\n}\nfunction tokenIsTSTypeOperator(token) {\n  return token >= 121 && token <= 123;\n}\nfunction tokenIsTSDeclarationStart(token) {\n  return token >= 124 && token <= 130;\n}\nfunction tokenLabelName(token) {\n  return tokenLabels[token];\n}\nfunction tokenOperatorPrecedence(token) {\n  return tokenBinops[token];\n}\nfunction tokenIsRightAssociative(token) {\n  return token === 57;\n}\nfunction tokenIsTemplate(token) {\n  return token >= 24 && token <= 25;\n}\nfunction getExportedToken(token) {\n  return tokenTypes[token];\n}\n{\n  tokenTypes[8].updateContext = context => {\n    context.pop();\n  };\n  tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = context => {\n    context.push(types.brace);\n  };\n  tokenTypes[22].updateContext = context => {\n    if (context[context.length - 1] === types.template) {\n      context.pop();\n    } else {\n      context.push(types.template);\n    }\n  };\n  tokenTypes[142].updateContext = context => {\n    context.push(types.j_expr, types.j_oTag);\n  };\n}\nlet 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\\u0870-\\u0887\\u0889-\\u088e\\u08a0-\\u08c9\\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\\u0c5d\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cdd\\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-\\u1711\\u171f-\\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-\\u1b4c\\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-\\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-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7ca\\ua7d0\\ua7d1\\ua7d3\\ua7d5-\\ua7d9\\ua7f2-\\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\";\nlet 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\\u0898-\\u089f\\u08ca-\\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\\u0c3c\\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\\u0cf3\\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-\\u0ece\\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-\\u1715\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b4-\\u17d3\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u180f-\\u1819\\u18a9\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u194f\\u19d0-\\u19da\\u1a17-\\u1a1b\\u1a55-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1ab0-\\u1abd\\u1abf-\\u1ace\\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-\\u1dff\\u200c\\u200d\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2cef-\\u2cf1\\u2d7f\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\u30fb\\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\\uff65\";\nconst nonASCIIidentifierStart = new RegExp(\"[\" + nonASCIIidentifierStartChars + \"]\");\nconst nonASCIIidentifier = new RegExp(\"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\");\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null;\nconst 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, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 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, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 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, 20, 1, 64, 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, 38, 6, 186, 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, 19, 72, 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, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 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, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 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, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 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, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191];\nconst 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, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 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, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 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, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];\nfunction isInAstralSet(code, set) {\n  let pos = 0x10000;\n  for (let 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  return false;\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  if (code <= 0xffff) {\n    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));\n  }\n  return isInAstralSet(code, astralIdentifierStartCodes);\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  if (code <= 0xffff) {\n    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));\n  }\n  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);\n}\nconst 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};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\nfunction isReservedWord(word, inModule) {\n  return inModule && word === \"await\" || word === \"enum\";\n}\nfunction isStrictReservedWord(word, inModule) {\n  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\nfunction isStrictBindOnlyReservedWord(word) {\n  return reservedWordsStrictBindSet.has(word);\n}\nfunction isStrictBindReservedWord(word, inModule) {\n  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);\n}\nfunction isKeyword(word) {\n  return keywords.has(word);\n}\nfunction isIteratorStart(current, next, next2) {\n  return current === 64 && next === 64 && isIdentifierStart(next2);\n}\nconst reservedWordLikeSet = new Set([\"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\", \"implements\", \"interface\", \"let\", \"package\", \"private\", \"protected\", \"public\", \"static\", \"yield\", \"eval\", \"arguments\", \"enum\", \"await\"]);\nfunction canBeReservedWord(word) {\n  return reservedWordLikeSet.has(word);\n}\nclass Scope {\n  constructor(flags) {\n    this.flags = 0;\n    this.names = new Map();\n    this.firstLexicalName = \"\";\n    this.flags = flags;\n  }\n}\nclass ScopeHandler {\n  constructor(parser, inModule) {\n    this.parser = void 0;\n    this.scopeStack = [];\n    this.inModule = void 0;\n    this.undefinedExports = new Map();\n    this.parser = parser;\n    this.inModule = inModule;\n  }\n  get inTopLevel() {\n    return (this.currentScope().flags & 1) > 0;\n  }\n  get inFunction() {\n    return (this.currentVarScopeFlags() & 2) > 0;\n  }\n  get allowSuper() {\n    return (this.currentThisScopeFlags() & 16) > 0;\n  }\n  get allowDirectSuper() {\n    return (this.currentThisScopeFlags() & 32) > 0;\n  }\n  get inClass() {\n    return (this.currentThisScopeFlags() & 64) > 0;\n  }\n  get inClassAndNotInNonArrowFunction() {\n    const flags = this.currentThisScopeFlags();\n    return (flags & 64) > 0 && (flags & 2) === 0;\n  }\n  get inStaticBlock() {\n    for (let i = this.scopeStack.length - 1;; i--) {\n      const {\n        flags\n      } = this.scopeStack[i];\n      if (flags & 128) {\n        return true;\n      }\n      if (flags & (387 | 64)) {\n        return false;\n      }\n    }\n  }\n  get inNonArrowFunction() {\n    return (this.currentThisScopeFlags() & 2) > 0;\n  }\n  get treatFunctionsAsVar() {\n    return this.treatFunctionsAsVarInScope(this.currentScope());\n  }\n  createScope(flags) {\n    return new Scope(flags);\n  }\n  enter(flags) {\n    this.scopeStack.push(this.createScope(flags));\n  }\n  exit() {\n    const scope = this.scopeStack.pop();\n    return scope.flags;\n  }\n  treatFunctionsAsVarInScope(scope) {\n    return !!(scope.flags & (2 | 128) || !this.parser.inModule && scope.flags & 1);\n  }\n  declareName(name, bindingType, loc) {\n    let scope = this.currentScope();\n    if (bindingType & 8 || bindingType & 16) {\n      this.checkRedeclarationInScope(scope, name, bindingType, loc);\n      let type = scope.names.get(name) || 0;\n      if (bindingType & 16) {\n        type = type | 4;\n      } else {\n        if (!scope.firstLexicalName) {\n          scope.firstLexicalName = name;\n        }\n        type = type | 2;\n      }\n      scope.names.set(name, type);\n      if (bindingType & 8) {\n        this.maybeExportDefined(scope, name);\n      }\n    } else if (bindingType & 4) {\n      for (let i = this.scopeStack.length - 1; i >= 0; --i) {\n        scope = this.scopeStack[i];\n        this.checkRedeclarationInScope(scope, name, bindingType, loc);\n        scope.names.set(name, (scope.names.get(name) || 0) | 1);\n        this.maybeExportDefined(scope, name);\n        if (scope.flags & 387) break;\n      }\n    }\n    if (this.parser.inModule && scope.flags & 1) {\n      this.undefinedExports.delete(name);\n    }\n  }\n  maybeExportDefined(scope, name) {\n    if (this.parser.inModule && scope.flags & 1) {\n      this.undefinedExports.delete(name);\n    }\n  }\n  checkRedeclarationInScope(scope, name, bindingType, loc) {\n    if (this.isRedeclaredInScope(scope, name, bindingType)) {\n      this.parser.raise(Errors.VarRedeclaration, loc, {\n        identifierName: name\n      });\n    }\n  }\n  isRedeclaredInScope(scope, name, bindingType) {\n    if (!(bindingType & 1)) return false;\n    if (bindingType & 8) {\n      return scope.names.has(name);\n    }\n    const type = scope.names.get(name);\n    if (bindingType & 16) {\n      return (type & 2) > 0 || !this.treatFunctionsAsVarInScope(scope) && (type & 1) > 0;\n    }\n    return (type & 2) > 0 && !(scope.flags & 8 && scope.firstLexicalName === name) || !this.treatFunctionsAsVarInScope(scope) && (type & 4) > 0;\n  }\n  checkLocalExport(id) {\n    const {\n      name\n    } = id;\n    const topLevelScope = this.scopeStack[0];\n    if (!topLevelScope.names.has(name)) {\n      this.undefinedExports.set(name, id.loc.start);\n    }\n  }\n  currentScope() {\n    return this.scopeStack[this.scopeStack.length - 1];\n  }\n  currentVarScopeFlags() {\n    for (let i = this.scopeStack.length - 1;; i--) {\n      const {\n        flags\n      } = this.scopeStack[i];\n      if (flags & 387) {\n        return flags;\n      }\n    }\n  }\n  currentThisScopeFlags() {\n    for (let i = this.scopeStack.length - 1;; i--) {\n      const {\n        flags\n      } = this.scopeStack[i];\n      if (flags & (387 | 64) && !(flags & 4)) {\n        return flags;\n      }\n    }\n  }\n}\nclass FlowScope extends Scope {\n  constructor(...args) {\n    super(...args);\n    this.declareFunctions = new Set();\n  }\n}\nclass FlowScopeHandler extends ScopeHandler {\n  createScope(flags) {\n    return new FlowScope(flags);\n  }\n  declareName(name, bindingType, loc) {\n    const scope = this.currentScope();\n    if (bindingType & 2048) {\n      this.checkRedeclarationInScope(scope, name, bindingType, loc);\n      this.maybeExportDefined(scope, name);\n      scope.declareFunctions.add(name);\n      return;\n    }\n    super.declareName(name, bindingType, loc);\n  }\n  isRedeclaredInScope(scope, name, bindingType) {\n    if (super.isRedeclaredInScope(scope, name, bindingType)) return true;\n    if (bindingType & 2048 && !scope.declareFunctions.has(name)) {\n      const type = scope.names.get(name);\n      return (type & 4) > 0 || (type & 2) > 0;\n    }\n    return false;\n  }\n  checkLocalExport(id) {\n    if (!this.scopeStack[0].declareFunctions.has(id.name)) {\n      super.checkLocalExport(id);\n    }\n  }\n}\nclass BaseParser {\n  constructor() {\n    this.sawUnambiguousESM = false;\n    this.ambiguousScriptDifferentAst = false;\n  }\n  hasPlugin(pluginConfig) {\n    if (typeof pluginConfig === \"string\") {\n      return this.plugins.has(pluginConfig);\n    } else {\n      const [pluginName, pluginOptions] = pluginConfig;\n      if (!this.hasPlugin(pluginName)) {\n        return false;\n      }\n      const actualOptions = this.plugins.get(pluginName);\n      for (const key of Object.keys(pluginOptions)) {\n        if ((actualOptions == null ? void 0 : actualOptions[key]) !== pluginOptions[key]) {\n          return false;\n        }\n      }\n      return true;\n    }\n  }\n  getPluginOption(plugin, name) {\n    var _this$plugins$get;\n    return (_this$plugins$get = this.plugins.get(plugin)) == null ? void 0 : _this$plugins$get[name];\n  }\n}\nfunction setTrailingComments(node, comments) {\n  if (node.trailingComments === undefined) {\n    node.trailingComments = comments;\n  } else {\n    node.trailingComments.unshift(...comments);\n  }\n}\nfunction setLeadingComments(node, comments) {\n  if (node.leadingComments === undefined) {\n    node.leadingComments = comments;\n  } else {\n    node.leadingComments.unshift(...comments);\n  }\n}\nfunction setInnerComments(node, comments) {\n  if (node.innerComments === undefined) {\n    node.innerComments = comments;\n  } else {\n    node.innerComments.unshift(...comments);\n  }\n}\nfunction adjustInnerComments(node, elements, commentWS) {\n  let lastElement = null;\n  let i = elements.length;\n  while (lastElement === null && i > 0) {\n    lastElement = elements[--i];\n  }\n  if (lastElement === null || lastElement.start > commentWS.start) {\n    setInnerComments(node, commentWS.comments);\n  } else {\n    setTrailingComments(lastElement, commentWS.comments);\n  }\n}\nclass CommentsParser extends BaseParser {\n  addComment(comment) {\n    if (this.filename) comment.loc.filename = this.filename;\n    const {\n      commentsLen\n    } = this.state;\n    if (this.comments.length !== commentsLen) {\n      this.comments.length = commentsLen;\n    }\n    this.comments.push(comment);\n    this.state.commentsLen++;\n  }\n  processComment(node) {\n    const {\n      commentStack\n    } = this.state;\n    const commentStackLength = commentStack.length;\n    if (commentStackLength === 0) return;\n    let i = commentStackLength - 1;\n    const lastCommentWS = commentStack[i];\n    if (lastCommentWS.start === node.end) {\n      lastCommentWS.leadingNode = node;\n      i--;\n    }\n    const {\n      start: nodeStart\n    } = node;\n    for (; i >= 0; i--) {\n      const commentWS = commentStack[i];\n      const commentEnd = commentWS.end;\n      if (commentEnd > nodeStart) {\n        commentWS.containingNode = node;\n        this.finalizeComment(commentWS);\n        commentStack.splice(i, 1);\n      } else {\n        if (commentEnd === nodeStart) {\n          commentWS.trailingNode = node;\n        }\n        break;\n      }\n    }\n  }\n  finalizeComment(commentWS) {\n    const {\n      comments\n    } = commentWS;\n    if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) {\n      if (commentWS.leadingNode !== null) {\n        setTrailingComments(commentWS.leadingNode, comments);\n      }\n      if (commentWS.trailingNode !== null) {\n        setLeadingComments(commentWS.trailingNode, comments);\n      }\n    } else {\n      const {\n        containingNode: node,\n        start: commentStart\n      } = commentWS;\n      if (this.input.charCodeAt(commentStart - 1) === 44) {\n        switch (node.type) {\n          case \"ObjectExpression\":\n          case \"ObjectPattern\":\n          case \"RecordExpression\":\n            adjustInnerComments(node, node.properties, commentWS);\n            break;\n          case \"CallExpression\":\n          case \"OptionalCallExpression\":\n            adjustInnerComments(node, node.arguments, commentWS);\n            break;\n          case \"FunctionDeclaration\":\n          case \"FunctionExpression\":\n          case \"ArrowFunctionExpression\":\n          case \"ObjectMethod\":\n          case \"ClassMethod\":\n          case \"ClassPrivateMethod\":\n            adjustInnerComments(node, node.params, commentWS);\n            break;\n          case \"ArrayExpression\":\n          case \"ArrayPattern\":\n          case \"TupleExpression\":\n            adjustInnerComments(node, node.elements, commentWS);\n            break;\n          case \"ExportNamedDeclaration\":\n          case \"ImportDeclaration\":\n            adjustInnerComments(node, node.specifiers, commentWS);\n            break;\n          default:\n            {\n              setInnerComments(node, comments);\n            }\n        }\n      } else {\n        setInnerComments(node, comments);\n      }\n    }\n  }\n  finalizeRemainingComments() {\n    const {\n      commentStack\n    } = this.state;\n    for (let i = commentStack.length - 1; i >= 0; i--) {\n      this.finalizeComment(commentStack[i]);\n    }\n    this.state.commentStack = [];\n  }\n  resetPreviousNodeTrailingComments(node) {\n    const {\n      commentStack\n    } = this.state;\n    const {\n      length\n    } = commentStack;\n    if (length === 0) return;\n    const commentWS = commentStack[length - 1];\n    if (commentWS.leadingNode === node) {\n      commentWS.leadingNode = null;\n    }\n  }\n  resetPreviousIdentifierLeadingComments(node) {\n    const {\n      commentStack\n    } = this.state;\n    const {\n      length\n    } = commentStack;\n    if (length === 0) return;\n    if (commentStack[length - 1].trailingNode === node) {\n      commentStack[length - 1].trailingNode = null;\n    } else if (length >= 2 && commentStack[length - 2].trailingNode === node) {\n      commentStack[length - 2].trailingNode = null;\n    }\n  }\n  takeSurroundingComments(node, start, end) {\n    const {\n      commentStack\n    } = this.state;\n    const commentStackLength = commentStack.length;\n    if (commentStackLength === 0) return;\n    let i = commentStackLength - 1;\n    for (; i >= 0; i--) {\n      const commentWS = commentStack[i];\n      const commentEnd = commentWS.end;\n      const commentStart = commentWS.start;\n      if (commentStart === end) {\n        commentWS.leadingNode = node;\n      } else if (commentEnd === start) {\n        commentWS.trailingNode = node;\n      } else if (commentEnd < start) {\n        break;\n      }\n    }\n  }\n}\nconst lineBreak = /\\r\\n|[\\r\\n\\u2028\\u2029]/;\nconst lineBreakG = new RegExp(lineBreak.source, \"g\");\nfunction isNewLine(code) {\n  switch (code) {\n    case 10:\n    case 13:\n    case 8232:\n    case 8233:\n      return true;\n    default:\n      return false;\n  }\n}\nfunction hasNewLine(input, start, end) {\n  for (let i = start; i < end; i++) {\n    if (isNewLine(input.charCodeAt(i))) {\n      return true;\n    }\n  }\n  return false;\n}\nconst skipWhiteSpace = /(?:\\s|\\/\\/.*|\\/\\*[^]*?\\*\\/)*/g;\nconst skipWhiteSpaceInLine = /(?:[^\\S\\n\\r\\u2028\\u2029]|\\/\\/.*|\\/\\*.*?\\*\\/)*/g;\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    default:\n      return false;\n  }\n}\nclass State {\n  constructor() {\n    this.flags = 1024;\n    this.curLine = void 0;\n    this.lineStart = void 0;\n    this.startLoc = void 0;\n    this.endLoc = void 0;\n    this.errors = [];\n    this.potentialArrowAt = -1;\n    this.noArrowAt = [];\n    this.noArrowParamsConversionAt = [];\n    this.topicContext = {\n      maxNumOfResolvableTopics: 0,\n      maxTopicIndex: null\n    };\n    this.labels = [];\n    this.commentsLen = 0;\n    this.commentStack = [];\n    this.pos = 0;\n    this.type = 139;\n    this.value = null;\n    this.start = 0;\n    this.end = 0;\n    this.lastTokEndLoc = null;\n    this.lastTokStartLoc = null;\n    this.context = [types.brace];\n    this.firstInvalidTemplateEscapePos = null;\n    this.strictErrors = new Map();\n    this.tokensLength = 0;\n  }\n  get strict() {\n    return (this.flags & 1) > 0;\n  }\n  set strict(v) {\n    if (v) this.flags |= 1;else this.flags &= -2;\n  }\n  init({\n    strictMode,\n    sourceType,\n    startLine,\n    startColumn\n  }) {\n    this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === \"module\";\n    this.curLine = startLine;\n    this.lineStart = -startColumn;\n    this.startLoc = this.endLoc = new Position(startLine, startColumn, 0);\n  }\n  get maybeInArrowParameters() {\n    return (this.flags & 2) > 0;\n  }\n  set maybeInArrowParameters(v) {\n    if (v) this.flags |= 2;else this.flags &= -3;\n  }\n  get inType() {\n    return (this.flags & 4) > 0;\n  }\n  set inType(v) {\n    if (v) this.flags |= 4;else this.flags &= -5;\n  }\n  get noAnonFunctionType() {\n    return (this.flags & 8) > 0;\n  }\n  set noAnonFunctionType(v) {\n    if (v) this.flags |= 8;else this.flags &= -9;\n  }\n  get hasFlowComment() {\n    return (this.flags & 16) > 0;\n  }\n  set hasFlowComment(v) {\n    if (v) this.flags |= 16;else this.flags &= -17;\n  }\n  get isAmbientContext() {\n    return (this.flags & 32) > 0;\n  }\n  set isAmbientContext(v) {\n    if (v) this.flags |= 32;else this.flags &= -33;\n  }\n  get inAbstractClass() {\n    return (this.flags & 64) > 0;\n  }\n  set inAbstractClass(v) {\n    if (v) this.flags |= 64;else this.flags &= -65;\n  }\n  get inDisallowConditionalTypesContext() {\n    return (this.flags & 128) > 0;\n  }\n  set inDisallowConditionalTypesContext(v) {\n    if (v) this.flags |= 128;else this.flags &= -129;\n  }\n  get soloAwait() {\n    return (this.flags & 256) > 0;\n  }\n  set soloAwait(v) {\n    if (v) this.flags |= 256;else this.flags &= -257;\n  }\n  get inFSharpPipelineDirectBody() {\n    return (this.flags & 512) > 0;\n  }\n  set inFSharpPipelineDirectBody(v) {\n    if (v) this.flags |= 512;else this.flags &= -513;\n  }\n  get canStartJSXElement() {\n    return (this.flags & 1024) > 0;\n  }\n  set canStartJSXElement(v) {\n    if (v) this.flags |= 1024;else this.flags &= -1025;\n  }\n  get containsEsc() {\n    return (this.flags & 2048) > 0;\n  }\n  set containsEsc(v) {\n    if (v) this.flags |= 2048;else this.flags &= -2049;\n  }\n  get hasTopLevelAwait() {\n    return (this.flags & 4096) > 0;\n  }\n  set hasTopLevelAwait(v) {\n    if (v) this.flags |= 4096;else this.flags &= -4097;\n  }\n  curPosition() {\n    return new Position(this.curLine, this.pos - this.lineStart, this.pos);\n  }\n  clone() {\n    const state = new State();\n    state.flags = this.flags;\n    state.curLine = this.curLine;\n    state.lineStart = this.lineStart;\n    state.startLoc = this.startLoc;\n    state.endLoc = this.endLoc;\n    state.errors = this.errors.slice();\n    state.potentialArrowAt = this.potentialArrowAt;\n    state.noArrowAt = this.noArrowAt.slice();\n    state.noArrowParamsConversionAt = this.noArrowParamsConversionAt.slice();\n    state.topicContext = this.topicContext;\n    state.labels = this.labels.slice();\n    state.commentsLen = this.commentsLen;\n    state.commentStack = this.commentStack.slice();\n    state.pos = this.pos;\n    state.type = this.type;\n    state.value = this.value;\n    state.start = this.start;\n    state.end = this.end;\n    state.lastTokEndLoc = this.lastTokEndLoc;\n    state.lastTokStartLoc = this.lastTokStartLoc;\n    state.context = this.context.slice();\n    state.firstInvalidTemplateEscapePos = this.firstInvalidTemplateEscapePos;\n    state.strictErrors = this.strictErrors;\n    state.tokensLength = this.tokensLength;\n    return state;\n  }\n}\nvar _isDigit = function isDigit(code) {\n  return code >= 48 && code <= 57;\n};\nconst forbiddenNumericSeparatorSiblings = {\n  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),\n  hex: new Set([46, 88, 95, 120])\n};\nconst isAllowedNumericSeparatorSibling = {\n  bin: ch => ch === 48 || ch === 49,\n  oct: ch => ch >= 48 && ch <= 55,\n  dec: ch => ch >= 48 && ch <= 57,\n  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102\n};\nfunction readStringContents(type, input, pos, lineStart, curLine, errors) {\n  const initialPos = pos;\n  const initialLineStart = lineStart;\n  const initialCurLine = curLine;\n  let out = \"\";\n  let firstInvalidLoc = null;\n  let chunkStart = pos;\n  const {\n    length\n  } = input;\n  for (;;) {\n    if (pos >= length) {\n      errors.unterminated(initialPos, initialLineStart, initialCurLine);\n      out += input.slice(chunkStart, pos);\n      break;\n    }\n    const ch = input.charCodeAt(pos);\n    if (isStringEnd(type, ch, input, pos)) {\n      out += input.slice(chunkStart, pos);\n      break;\n    }\n    if (ch === 92) {\n      out += input.slice(chunkStart, pos);\n      const res = readEscapedChar(input, pos, lineStart, curLine, type === \"template\", errors);\n      if (res.ch === null && !firstInvalidLoc) {\n        firstInvalidLoc = {\n          pos,\n          lineStart,\n          curLine\n        };\n      } else {\n        out += res.ch;\n      }\n      ({\n        pos,\n        lineStart,\n        curLine\n      } = res);\n      chunkStart = pos;\n    } else if (ch === 8232 || ch === 8233) {\n      ++pos;\n      ++curLine;\n      lineStart = pos;\n    } else if (ch === 10 || ch === 13) {\n      if (type === \"template\") {\n        out += input.slice(chunkStart, pos) + \"\\n\";\n        ++pos;\n        if (ch === 13 && input.charCodeAt(pos) === 10) {\n          ++pos;\n        }\n        ++curLine;\n        chunkStart = lineStart = pos;\n      } else {\n        errors.unterminated(initialPos, initialLineStart, initialCurLine);\n      }\n    } else {\n      ++pos;\n    }\n  }\n  return {\n    pos,\n    str: out,\n    firstInvalidLoc,\n    lineStart,\n    curLine,\n    containsInvalid: !!firstInvalidLoc\n  };\n}\nfunction isStringEnd(type, ch, input, pos) {\n  if (type === \"template\") {\n    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;\n  }\n  return ch === (type === \"double\" ? 34 : 39);\n}\nfunction readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {\n  const throwOnInvalid = !inTemplate;\n  pos++;\n  const res = ch => ({\n    pos,\n    ch,\n    lineStart,\n    curLine\n  });\n  const ch = input.charCodeAt(pos++);\n  switch (ch) {\n    case 110:\n      return res(\"\\n\");\n    case 114:\n      return res(\"\\r\");\n    case 120:\n      {\n        let code;\n        ({\n          code,\n          pos\n        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));\n        return res(code === null ? null : String.fromCharCode(code));\n      }\n    case 117:\n      {\n        let code;\n        ({\n          code,\n          pos\n        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));\n        return res(code === null ? null : String.fromCodePoint(code));\n      }\n    case 116:\n      return res(\"\\t\");\n    case 98:\n      return res(\"\\b\");\n    case 118:\n      return res(\"\\u000b\");\n    case 102:\n      return res(\"\\f\");\n    case 13:\n      if (input.charCodeAt(pos) === 10) {\n        ++pos;\n      }\n    case 10:\n      lineStart = pos;\n      ++curLine;\n    case 8232:\n    case 8233:\n      return res(\"\");\n    case 56:\n    case 57:\n      if (inTemplate) {\n        return res(null);\n      } else {\n        errors.strictNumericEscape(pos - 1, lineStart, curLine);\n      }\n    default:\n      if (ch >= 48 && ch <= 55) {\n        const startPos = pos - 1;\n        const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));\n        let octalStr = match[0];\n        let octal = parseInt(octalStr, 8);\n        if (octal > 255) {\n          octalStr = octalStr.slice(0, -1);\n          octal = parseInt(octalStr, 8);\n        }\n        pos += octalStr.length - 1;\n        const next = input.charCodeAt(pos);\n        if (octalStr !== \"0\" || next === 56 || next === 57) {\n          if (inTemplate) {\n            return res(null);\n          } else {\n            errors.strictNumericEscape(startPos, lineStart, curLine);\n          }\n        }\n        return res(String.fromCharCode(octal));\n      }\n      return res(String.fromCharCode(ch));\n  }\n}\nfunction readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {\n  const initialPos = pos;\n  let n;\n  ({\n    n,\n    pos\n  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));\n  if (n === null) {\n    if (throwOnInvalid) {\n      errors.invalidEscapeSequence(initialPos, lineStart, curLine);\n    } else {\n      pos = initialPos - 1;\n    }\n  }\n  return {\n    code: n,\n    pos\n  };\n}\nfunction readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {\n  const start = pos;\n  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;\n  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;\n  let invalid = false;\n  let total = 0;\n  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {\n    const code = input.charCodeAt(pos);\n    let val;\n    if (code === 95 && allowNumSeparator !== \"bail\") {\n      const prev = input.charCodeAt(pos - 1);\n      const next = input.charCodeAt(pos + 1);\n      if (!allowNumSeparator) {\n        if (bailOnError) return {\n          n: null,\n          pos\n        };\n        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);\n      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {\n        if (bailOnError) return {\n          n: null,\n          pos\n        };\n        errors.unexpectedNumericSeparator(pos, lineStart, curLine);\n      }\n      ++pos;\n      continue;\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    if (val >= radix) {\n      if (val <= 9 && bailOnError) {\n        return {\n          n: null,\n          pos\n        };\n      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {\n        val = 0;\n      } else if (forceLen) {\n        val = 0;\n        invalid = true;\n      } else {\n        break;\n      }\n    }\n    ++pos;\n    total = total * radix + val;\n  }\n  if (pos === start || len != null && pos - start !== len || invalid) {\n    return {\n      n: null,\n      pos\n    };\n  }\n  return {\n    n: total,\n    pos\n  };\n}\nfunction readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {\n  const ch = input.charCodeAt(pos);\n  let code;\n  if (ch === 123) {\n    ++pos;\n    ({\n      code,\n      pos\n    } = readHexChar(input, pos, lineStart, curLine, input.indexOf(\"}\", pos) - pos, true, throwOnInvalid, errors));\n    ++pos;\n    if (code !== null && code > 0x10ffff) {\n      if (throwOnInvalid) {\n        errors.invalidCodePoint(pos, lineStart, curLine);\n      } else {\n        return {\n          code: null,\n          pos\n        };\n      }\n    }\n  } else {\n    ({\n      code,\n      pos\n    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));\n  }\n  return {\n    code,\n    pos\n  };\n}\nfunction buildPosition(pos, lineStart, curLine) {\n  return new Position(curLine, pos - lineStart, pos);\n}\nconst VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]);\nclass Token {\n  constructor(state) {\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}\nclass Tokenizer extends CommentsParser {\n  constructor(options, input) {\n    super();\n    this.isLookahead = void 0;\n    this.tokens = [];\n    this.errorHandlers_readInt = {\n      invalidDigit: (pos, lineStart, curLine, radix) => {\n        if (!this.options.errorRecovery) return false;\n        this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), {\n          radix\n        });\n        return true;\n      },\n      numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence),\n      unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator)\n    };\n    this.errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, {\n      invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),\n      invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint)\n    });\n    this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, {\n      strictNumericEscape: (pos, lineStart, curLine) => {\n        this.recordStrictModeErrors(Errors.StrictNumericEscape, buildPosition(pos, lineStart, curLine));\n      },\n      unterminated: (pos, lineStart, curLine) => {\n        throw this.raise(Errors.UnterminatedString, buildPosition(pos - 1, lineStart, curLine));\n      }\n    });\n    this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, {\n      strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),\n      unterminated: (pos, lineStart, curLine) => {\n        throw this.raise(Errors.UnterminatedTemplate, buildPosition(pos, lineStart, curLine));\n      }\n    });\n    this.state = new State();\n    this.state.init(options);\n    this.input = input;\n    this.length = input.length;\n    this.comments = [];\n    this.isLookahead = false;\n  }\n  pushToken(token) {\n    this.tokens.length = this.state.tokensLength;\n    this.tokens.push(token);\n    ++this.state.tokensLength;\n  }\n  next() {\n    this.checkKeywordEscapes();\n    if (this.options.tokens) {\n      this.pushToken(new Token(this.state));\n    }\n    this.state.lastTokEndLoc = this.state.endLoc;\n    this.state.lastTokStartLoc = this.state.startLoc;\n    this.nextToken();\n  }\n  eat(type) {\n    if (this.match(type)) {\n      this.next();\n      return true;\n    } else {\n      return false;\n    }\n  }\n  match(type) {\n    return this.state.type === type;\n  }\n  createLookaheadState(state) {\n    return {\n      pos: state.pos,\n      value: null,\n      type: state.type,\n      start: state.start,\n      end: state.end,\n      context: [this.curContext()],\n      inType: state.inType,\n      startLoc: state.startLoc,\n      lastTokEndLoc: state.lastTokEndLoc,\n      curLine: state.curLine,\n      lineStart: state.lineStart,\n      curPosition: state.curPosition\n    };\n  }\n  lookahead() {\n    const old = this.state;\n    this.state = this.createLookaheadState(old);\n    this.isLookahead = true;\n    this.nextToken();\n    this.isLookahead = false;\n    const curr = this.state;\n    this.state = old;\n    return curr;\n  }\n  nextTokenStart() {\n    return this.nextTokenStartSince(this.state.pos);\n  }\n  nextTokenStartSince(pos) {\n    skipWhiteSpace.lastIndex = pos;\n    return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos;\n  }\n  lookaheadCharCode() {\n    return this.input.charCodeAt(this.nextTokenStart());\n  }\n  nextTokenInLineStart() {\n    return this.nextTokenInLineStartSince(this.state.pos);\n  }\n  nextTokenInLineStartSince(pos) {\n    skipWhiteSpaceInLine.lastIndex = pos;\n    return skipWhiteSpaceInLine.test(this.input) ? skipWhiteSpaceInLine.lastIndex : pos;\n  }\n  lookaheadInLineCharCode() {\n    return this.input.charCodeAt(this.nextTokenInLineStart());\n  }\n  codePointAtPos(pos) {\n    let cp = this.input.charCodeAt(pos);\n    if ((cp & 0xfc00) === 0xd800 && ++pos < this.input.length) {\n      const trail = this.input.charCodeAt(pos);\n      if ((trail & 0xfc00) === 0xdc00) {\n        cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);\n      }\n    }\n    return cp;\n  }\n  setStrict(strict) {\n    this.state.strict = strict;\n    if (strict) {\n      this.state.strictErrors.forEach(([toParseError, at]) => this.raise(toParseError, at));\n      this.state.strictErrors.clear();\n    }\n  }\n  curContext() {\n    return this.state.context[this.state.context.length - 1];\n  }\n  nextToken() {\n    this.skipSpace();\n    this.state.start = this.state.pos;\n    if (!this.isLookahead) this.state.startLoc = this.state.curPosition();\n    if (this.state.pos >= this.length) {\n      this.finishToken(139);\n      return;\n    }\n    this.getTokenFromCode(this.codePointAtPos(this.state.pos));\n  }\n  skipBlockComment(commentEnd) {\n    let startLoc;\n    if (!this.isLookahead) startLoc = this.state.curPosition();\n    const start = this.state.pos;\n    const end = this.input.indexOf(commentEnd, start + 2);\n    if (end === -1) {\n      throw this.raise(Errors.UnterminatedComment, this.state.curPosition());\n    }\n    this.state.pos = end + commentEnd.length;\n    lineBreakG.lastIndex = start + 2;\n    while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) {\n      ++this.state.curLine;\n      this.state.lineStart = lineBreakG.lastIndex;\n    }\n    if (this.isLookahead) return;\n    const comment = {\n      type: \"CommentBlock\",\n      value: this.input.slice(start + 2, end),\n      start,\n      end: end + commentEnd.length,\n      loc: new SourceLocation(startLoc, this.state.curPosition())\n    };\n    if (this.options.tokens) this.pushToken(comment);\n    return comment;\n  }\n  skipLineComment(startSkip) {\n    const start = this.state.pos;\n    let startLoc;\n    if (!this.isLookahead) startLoc = this.state.curPosition();\n    let ch = this.input.charCodeAt(this.state.pos += startSkip);\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    if (this.isLookahead) return;\n    const end = this.state.pos;\n    const value = this.input.slice(start + startSkip, end);\n    const comment = {\n      type: \"CommentLine\",\n      value,\n      start,\n      end,\n      loc: new SourceLocation(startLoc, this.state.curPosition())\n    };\n    if (this.options.tokens) this.pushToken(comment);\n    return comment;\n  }\n  skipSpace() {\n    const spaceStart = this.state.pos;\n    const comments = [];\n    loop: while (this.state.pos < this.length) {\n      const ch = this.input.charCodeAt(this.state.pos);\n      switch (ch) {\n        case 32:\n        case 160:\n        case 9:\n          ++this.state.pos;\n          break;\n        case 13:\n          if (this.input.charCodeAt(this.state.pos + 1) === 10) {\n            ++this.state.pos;\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        case 47:\n          switch (this.input.charCodeAt(this.state.pos + 1)) {\n            case 42:\n              {\n                const comment = this.skipBlockComment(\"*/\");\n                if (comment !== undefined) {\n                  this.addComment(comment);\n                  if (this.options.attachComment) comments.push(comment);\n                }\n                break;\n              }\n            case 47:\n              {\n                const comment = this.skipLineComment(2);\n                if (comment !== undefined) {\n                  this.addComment(comment);\n                  if (this.options.attachComment) comments.push(comment);\n                }\n                break;\n              }\n            default:\n              break loop;\n          }\n          break;\n        default:\n          if (isWhitespace(ch)) {\n            ++this.state.pos;\n          } else if (ch === 45 && !this.inModule && this.options.annexB) {\n            const pos = this.state.pos;\n            if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {\n              const comment = this.skipLineComment(3);\n              if (comment !== undefined) {\n                this.addComment(comment);\n                if (this.options.attachComment) comments.push(comment);\n              }\n            } else {\n              break loop;\n            }\n          } else if (ch === 60 && !this.inModule && this.options.annexB) {\n            const pos = this.state.pos;\n            if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) {\n              const comment = this.skipLineComment(4);\n              if (comment !== undefined) {\n                this.addComment(comment);\n                if (this.options.attachComment) comments.push(comment);\n              }\n            } else {\n              break loop;\n            }\n          } else {\n            break loop;\n          }\n      }\n    }\n    if (comments.length > 0) {\n      const end = this.state.pos;\n      const commentWhitespace = {\n        start: spaceStart,\n        end,\n        comments,\n        leadingNode: null,\n        trailingNode: null,\n        containingNode: null\n      };\n      this.state.commentStack.push(commentWhitespace);\n    }\n  }\n  finishToken(type, val) {\n    this.state.end = this.state.pos;\n    this.state.endLoc = this.state.curPosition();\n    const prevType = this.state.type;\n    this.state.type = type;\n    this.state.value = val;\n    if (!this.isLookahead) {\n      this.updateContext(prevType);\n    }\n  }\n  replaceToken(type) {\n    this.state.type = type;\n    this.updateContext();\n  }\n  readToken_numberSign() {\n    if (this.state.pos === 0 && this.readToken_interpreter()) {\n      return;\n    }\n    const nextPos = this.state.pos + 1;\n    const next = this.codePointAtPos(nextPos);\n    if (next >= 48 && next <= 57) {\n      throw this.raise(Errors.UnexpectedDigitAfterHash, this.state.curPosition());\n    }\n    if (next === 123 || next === 91 && this.hasPlugin(\"recordAndTuple\")) {\n      this.expectPlugin(\"recordAndTuple\");\n      if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") === \"bar\") {\n        throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, this.state.curPosition());\n      }\n      this.state.pos += 2;\n      if (next === 123) {\n        this.finishToken(7);\n      } else {\n        this.finishToken(1);\n      }\n    } else if (isIdentifierStart(next)) {\n      ++this.state.pos;\n      this.finishToken(138, this.readWord1(next));\n    } else if (next === 92) {\n      ++this.state.pos;\n      this.finishToken(138, this.readWord1());\n    } else {\n      this.finishOp(27, 1);\n    }\n  }\n  readToken_dot() {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next >= 48 && next <= 57) {\n      this.readNumber(true);\n      return;\n    }\n    if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {\n      this.state.pos += 3;\n      this.finishToken(21);\n    } else {\n      ++this.state.pos;\n      this.finishToken(16);\n    }\n  }\n  readToken_slash() {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === 61) {\n      this.finishOp(31, 2);\n    } else {\n      this.finishOp(56, 1);\n    }\n  }\n  readToken_interpreter() {\n    if (this.state.pos !== 0 || this.length < 2) return false;\n    let ch = this.input.charCodeAt(this.state.pos + 1);\n    if (ch !== 33) return false;\n    const start = this.state.pos;\n    this.state.pos += 1;\n    while (!isNewLine(ch) && ++this.state.pos < this.length) {\n      ch = this.input.charCodeAt(this.state.pos);\n    }\n    const value = this.input.slice(start + 2, this.state.pos);\n    this.finishToken(28, value);\n    return true;\n  }\n  readToken_mult_modulo(code) {\n    let type = code === 42 ? 55 : 54;\n    let width = 1;\n    let next = this.input.charCodeAt(this.state.pos + 1);\n    if (code === 42 && next === 42) {\n      width++;\n      next = this.input.charCodeAt(this.state.pos + 2);\n      type = 57;\n    }\n    if (next === 61 && !this.state.inType) {\n      width++;\n      type = code === 37 ? 33 : 30;\n    }\n    this.finishOp(type, width);\n  }\n  readToken_pipe_amp(code) {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === code) {\n      if (this.input.charCodeAt(this.state.pos + 2) === 61) {\n        this.finishOp(30, 3);\n      } else {\n        this.finishOp(code === 124 ? 41 : 42, 2);\n      }\n      return;\n    }\n    if (code === 124) {\n      if (next === 62) {\n        this.finishOp(39, 2);\n        return;\n      }\n      if (this.hasPlugin(\"recordAndTuple\") && next === 125) {\n        if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n          throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, this.state.curPosition());\n        }\n        this.state.pos += 2;\n        this.finishToken(9);\n        return;\n      }\n      if (this.hasPlugin(\"recordAndTuple\") && next === 93) {\n        if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n          throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, this.state.curPosition());\n        }\n        this.state.pos += 2;\n        this.finishToken(4);\n        return;\n      }\n    }\n    if (next === 61) {\n      this.finishOp(30, 2);\n      return;\n    }\n    this.finishOp(code === 124 ? 43 : 45, 1);\n  }\n  readToken_caret() {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === 61 && !this.state.inType) {\n      this.finishOp(32, 2);\n    } else if (next === 94 && this.hasPlugin([\"pipelineOperator\", {\n      proposal: \"hack\",\n      topicToken: \"^^\"\n    }])) {\n      this.finishOp(37, 2);\n      const lookaheadCh = this.input.codePointAt(this.state.pos);\n      if (lookaheadCh === 94) {\n        this.unexpected();\n      }\n    } else {\n      this.finishOp(44, 1);\n    }\n  }\n  readToken_atSign() {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === 64 && this.hasPlugin([\"pipelineOperator\", {\n      proposal: \"hack\",\n      topicToken: \"@@\"\n    }])) {\n      this.finishOp(38, 2);\n    } else {\n      this.finishOp(26, 1);\n    }\n  }\n  readToken_plus_min(code) {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === code) {\n      this.finishOp(34, 2);\n      return;\n    }\n    if (next === 61) {\n      this.finishOp(30, 2);\n    } else {\n      this.finishOp(53, 1);\n    }\n  }\n  readToken_lt() {\n    const {\n      pos\n    } = this.state;\n    const next = this.input.charCodeAt(pos + 1);\n    if (next === 60) {\n      if (this.input.charCodeAt(pos + 2) === 61) {\n        this.finishOp(30, 3);\n        return;\n      }\n      this.finishOp(51, 2);\n      return;\n    }\n    if (next === 61) {\n      this.finishOp(49, 2);\n      return;\n    }\n    this.finishOp(47, 1);\n  }\n  readToken_gt() {\n    const {\n      pos\n    } = this.state;\n    const next = this.input.charCodeAt(pos + 1);\n    if (next === 62) {\n      const size = this.input.charCodeAt(pos + 2) === 62 ? 3 : 2;\n      if (this.input.charCodeAt(pos + size) === 61) {\n        this.finishOp(30, size + 1);\n        return;\n      }\n      this.finishOp(52, size);\n      return;\n    }\n    if (next === 61) {\n      this.finishOp(49, 2);\n      return;\n    }\n    this.finishOp(48, 1);\n  }\n  readToken_eq_excl(code) {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === 61) {\n      this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);\n      return;\n    }\n    if (code === 61 && next === 62) {\n      this.state.pos += 2;\n      this.finishToken(19);\n      return;\n    }\n    this.finishOp(code === 61 ? 29 : 35, 1);\n  }\n  readToken_question() {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    const next2 = this.input.charCodeAt(this.state.pos + 2);\n    if (next === 63) {\n      if (next2 === 61) {\n        this.finishOp(30, 3);\n      } else {\n        this.finishOp(40, 2);\n      }\n    } else if (next === 46 && !(next2 >= 48 && next2 <= 57)) {\n      this.state.pos += 2;\n      this.finishToken(18);\n    } else {\n      ++this.state.pos;\n      this.finishToken(17);\n    }\n  }\n  getTokenFromCode(code) {\n    switch (code) {\n      case 46:\n        this.readToken_dot();\n        return;\n      case 40:\n        ++this.state.pos;\n        this.finishToken(10);\n        return;\n      case 41:\n        ++this.state.pos;\n        this.finishToken(11);\n        return;\n      case 59:\n        ++this.state.pos;\n        this.finishToken(13);\n        return;\n      case 44:\n        ++this.state.pos;\n        this.finishToken(12);\n        return;\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(Errors.TupleExpressionBarIncorrectStartSyntaxType, this.state.curPosition());\n          }\n          this.state.pos += 2;\n          this.finishToken(2);\n        } else {\n          ++this.state.pos;\n          this.finishToken(0);\n        }\n        return;\n      case 93:\n        ++this.state.pos;\n        this.finishToken(3);\n        return;\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(Errors.RecordExpressionBarIncorrectStartSyntaxType, this.state.curPosition());\n          }\n          this.state.pos += 2;\n          this.finishToken(6);\n        } else {\n          ++this.state.pos;\n          this.finishToken(5);\n        }\n        return;\n      case 125:\n        ++this.state.pos;\n        this.finishToken(8);\n        return;\n      case 58:\n        if (this.hasPlugin(\"functionBind\") && this.input.charCodeAt(this.state.pos + 1) === 58) {\n          this.finishOp(15, 2);\n        } else {\n          ++this.state.pos;\n          this.finishToken(14);\n        }\n        return;\n      case 63:\n        this.readToken_question();\n        return;\n      case 96:\n        this.readTemplateToken();\n        return;\n      case 48:\n        {\n          const next = this.input.charCodeAt(this.state.pos + 1);\n          if (next === 120 || next === 88) {\n            this.readRadixNumber(16);\n            return;\n          }\n          if (next === 111 || next === 79) {\n            this.readRadixNumber(8);\n            return;\n          }\n          if (next === 98 || next === 66) {\n            this.readRadixNumber(2);\n            return;\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      case 34:\n      case 39:\n        this.readString(code);\n        return;\n      case 47:\n        this.readToken_slash();\n        return;\n      case 37:\n      case 42:\n        this.readToken_mult_modulo(code);\n        return;\n      case 124:\n      case 38:\n        this.readToken_pipe_amp(code);\n        return;\n      case 94:\n        this.readToken_caret();\n        return;\n      case 43:\n      case 45:\n        this.readToken_plus_min(code);\n        return;\n      case 60:\n        this.readToken_lt();\n        return;\n      case 62:\n        this.readToken_gt();\n        return;\n      case 61:\n      case 33:\n        this.readToken_eq_excl(code);\n        return;\n      case 126:\n        this.finishOp(36, 1);\n        return;\n      case 64:\n        this.readToken_atSign();\n        return;\n      case 35:\n        this.readToken_numberSign();\n        return;\n      case 92:\n        this.readWord();\n        return;\n      default:\n        if (isIdentifierStart(code)) {\n          this.readWord(code);\n          return;\n        }\n    }\n    throw this.raise(Errors.InvalidOrUnexpectedToken, this.state.curPosition(), {\n      unexpected: String.fromCodePoint(code)\n    });\n  }\n  finishOp(type, size) {\n    const str = this.input.slice(this.state.pos, this.state.pos + size);\n    this.state.pos += size;\n    this.finishToken(type, str);\n  }\n  readRegexp() {\n    const startLoc = this.state.startLoc;\n    const start = this.state.start + 1;\n    let escaped, inClass;\n    let {\n      pos\n    } = this.state;\n    for (;; ++pos) {\n      if (pos >= this.length) {\n        throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));\n      }\n      const ch = this.input.charCodeAt(pos);\n      if (isNewLine(ch)) {\n        throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));\n      }\n      if (escaped) {\n        escaped = false;\n      } else {\n        if (ch === 91) {\n          inClass = true;\n        } else if (ch === 93 && inClass) {\n          inClass = false;\n        } else if (ch === 47 && !inClass) {\n          break;\n        }\n        escaped = ch === 92;\n      }\n    }\n    const content = this.input.slice(start, pos);\n    ++pos;\n    let mods = \"\";\n    const nextPos = () => createPositionWithColumnOffset(startLoc, pos + 2 - start);\n    while (pos < this.length) {\n      const cp = this.codePointAtPos(pos);\n      const char = String.fromCharCode(cp);\n      if (VALID_REGEX_FLAGS.has(cp)) {\n        if (cp === 118) {\n          if (mods.includes(\"u\")) {\n            this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());\n          }\n        } else if (cp === 117) {\n          if (mods.includes(\"v\")) {\n            this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());\n          }\n        }\n        if (mods.includes(char)) {\n          this.raise(Errors.DuplicateRegExpFlags, nextPos());\n        }\n      } else if (isIdentifierChar(cp) || cp === 92) {\n        this.raise(Errors.MalformedRegExpFlags, nextPos());\n      } else {\n        break;\n      }\n      ++pos;\n      mods += char;\n    }\n    this.state.pos = pos;\n    this.finishToken(137, {\n      pattern: content,\n      flags: mods\n    });\n  }\n  readInt(radix, len, forceLen = false, allowNumSeparator = true) {\n    const {\n      n,\n      pos\n    } = readInt(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);\n    this.state.pos = pos;\n    return n;\n  }\n  readRadixNumber(radix) {\n    const startLoc = this.state.curPosition();\n    let isBigInt = false;\n    this.state.pos += 2;\n    const val = this.readInt(radix);\n    if (val == null) {\n      this.raise(Errors.InvalidDigit, createPositionWithColumnOffset(startLoc, 2), {\n        radix\n      });\n    }\n    const next = this.input.charCodeAt(this.state.pos);\n    if (next === 110) {\n      ++this.state.pos;\n      isBigInt = true;\n    } else if (next === 109) {\n      throw this.raise(Errors.InvalidDecimal, startLoc);\n    }\n    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {\n      throw this.raise(Errors.NumberIdentifier, this.state.curPosition());\n    }\n    if (isBigInt) {\n      const str = this.input.slice(startLoc.index, this.state.pos).replace(/[_n]/g, \"\");\n      this.finishToken(135, str);\n      return;\n    }\n    this.finishToken(134, val);\n  }\n  readNumber(startsWithDot) {\n    const start = this.state.pos;\n    const startLoc = this.state.curPosition();\n    let isFloat = false;\n    let isBigInt = false;\n    let isDecimal = false;\n    let hasExponent = false;\n    let isOctal = false;\n    if (!startsWithDot && this.readInt(10) === null) {\n      this.raise(Errors.InvalidNumber, this.state.curPosition());\n    }\n    const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;\n    if (hasLeadingZero) {\n      const integer = this.input.slice(start, this.state.pos);\n      this.recordStrictModeErrors(Errors.StrictOctalLiteral, startLoc);\n      if (!this.state.strict) {\n        const underscorePos = integer.indexOf(\"_\");\n        if (underscorePos > 0) {\n          this.raise(Errors.ZeroDigitNumericSeparator, createPositionWithColumnOffset(startLoc, underscorePos));\n        }\n      }\n      isOctal = hasLeadingZero && !/[89]/.test(integer);\n    }\n    let next = this.input.charCodeAt(this.state.pos);\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    if ((next === 69 || next === 101) && !isOctal) {\n      next = this.input.charCodeAt(++this.state.pos);\n      if (next === 43 || next === 45) {\n        ++this.state.pos;\n      }\n      if (this.readInt(10) === null) {\n        this.raise(Errors.InvalidOrMissingExponent, startLoc);\n      }\n      isFloat = true;\n      hasExponent = true;\n      next = this.input.charCodeAt(this.state.pos);\n    }\n    if (next === 110) {\n      if (isFloat || hasLeadingZero) {\n        this.raise(Errors.InvalidBigIntLiteral, startLoc);\n      }\n      ++this.state.pos;\n      isBigInt = true;\n    }\n    if (next === 109) {\n      this.expectPlugin(\"decimal\", this.state.curPosition());\n      if (hasExponent || hasLeadingZero) {\n        this.raise(Errors.InvalidDecimal, startLoc);\n      }\n      ++this.state.pos;\n      isDecimal = true;\n    }\n    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {\n      throw this.raise(Errors.NumberIdentifier, this.state.curPosition());\n    }\n    const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, \"\");\n    if (isBigInt) {\n      this.finishToken(135, str);\n      return;\n    }\n    if (isDecimal) {\n      this.finishToken(136, str);\n      return;\n    }\n    const val = isOctal ? parseInt(str, 8) : parseFloat(str);\n    this.finishToken(134, val);\n  }\n  readCodePoint(throwOnInvalid) {\n    const {\n      code,\n      pos\n    } = readCodePoint(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);\n    this.state.pos = pos;\n    return code;\n  }\n  readString(quote) {\n    const {\n      str,\n      pos,\n      curLine,\n      lineStart\n    } = readStringContents(quote === 34 ? \"double\" : \"single\", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);\n    this.state.pos = pos + 1;\n    this.state.lineStart = lineStart;\n    this.state.curLine = curLine;\n    this.finishToken(133, str);\n  }\n  readTemplateContinuation() {\n    if (!this.match(8)) {\n      this.unexpected(null, 8);\n    }\n    this.state.pos--;\n    this.readTemplateToken();\n  }\n  readTemplateToken() {\n    const opening = this.input[this.state.pos];\n    const {\n      str,\n      firstInvalidLoc,\n      pos,\n      curLine,\n      lineStart\n    } = readStringContents(\"template\", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);\n    this.state.pos = pos + 1;\n    this.state.lineStart = lineStart;\n    this.state.curLine = curLine;\n    if (firstInvalidLoc) {\n      this.state.firstInvalidTemplateEscapePos = new Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, firstInvalidLoc.pos);\n    }\n    if (this.input.codePointAt(pos) === 96) {\n      this.finishToken(24, firstInvalidLoc ? null : opening + str + \"`\");\n    } else {\n      this.state.pos++;\n      this.finishToken(25, firstInvalidLoc ? null : opening + str + \"${\");\n    }\n  }\n  recordStrictModeErrors(toParseError, at) {\n    const index = at.index;\n    if (this.state.strict && !this.state.strictErrors.has(index)) {\n      this.raise(toParseError, at);\n    } else {\n      this.state.strictErrors.set(index, [toParseError, at]);\n    }\n  }\n  readWord1(firstCode) {\n    this.state.containsEsc = false;\n    let word = \"\";\n    const start = this.state.pos;\n    let chunkStart = this.state.pos;\n    if (firstCode !== undefined) {\n      this.state.pos += firstCode <= 0xffff ? 1 : 2;\n    }\n    while (this.state.pos < this.length) {\n      const ch = this.codePointAtPos(this.state.pos);\n      if (isIdentifierChar(ch)) {\n        this.state.pos += ch <= 0xffff ? 1 : 2;\n      } else if (ch === 92) {\n        this.state.containsEsc = true;\n        word += this.input.slice(chunkStart, this.state.pos);\n        const escStart = this.state.curPosition();\n        const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar;\n        if (this.input.charCodeAt(++this.state.pos) !== 117) {\n          this.raise(Errors.MissingUnicodeEscape, this.state.curPosition());\n          chunkStart = this.state.pos - 1;\n          continue;\n        }\n        ++this.state.pos;\n        const esc = this.readCodePoint(true);\n        if (esc !== null) {\n          if (!identifierCheck(esc)) {\n            this.raise(Errors.EscapedCharNotAnIdentifier, escStart);\n          }\n          word += String.fromCodePoint(esc);\n        }\n        chunkStart = this.state.pos;\n      } else {\n        break;\n      }\n    }\n    return word + this.input.slice(chunkStart, this.state.pos);\n  }\n  readWord(firstCode) {\n    const word = this.readWord1(firstCode);\n    const type = keywords$1.get(word);\n    if (type !== undefined) {\n      this.finishToken(type, tokenLabelName(type));\n    } else {\n      this.finishToken(132, word);\n    }\n  }\n  checkKeywordEscapes() {\n    const {\n      type\n    } = this.state;\n    if (tokenIsKeyword(type) && this.state.containsEsc) {\n      this.raise(Errors.InvalidEscapedReservedWord, this.state.startLoc, {\n        reservedWord: tokenLabelName(type)\n      });\n    }\n  }\n  raise(toParseError, at, details = {}) {\n    const loc = at instanceof Position ? at : at.loc.start;\n    const error = toParseError(loc, details);\n    if (!this.options.errorRecovery) throw error;\n    if (!this.isLookahead) this.state.errors.push(error);\n    return error;\n  }\n  raiseOverwrite(toParseError, at, details = {}) {\n    const loc = at instanceof Position ? at : at.loc.start;\n    const pos = loc.index;\n    const errors = this.state.errors;\n    for (let i = errors.length - 1; i >= 0; i--) {\n      const error = errors[i];\n      if (error.loc.index === pos) {\n        return errors[i] = toParseError(loc, details);\n      }\n      if (error.loc.index < pos) break;\n    }\n    return this.raise(toParseError, at, details);\n  }\n  updateContext(prevType) {}\n  unexpected(loc, type) {\n    throw this.raise(Errors.UnexpectedToken, loc != null ? loc : this.state.startLoc, {\n      expected: type ? tokenLabelName(type) : null\n    });\n  }\n  expectPlugin(pluginName, loc) {\n    if (this.hasPlugin(pluginName)) {\n      return true;\n    }\n    throw this.raise(Errors.MissingPlugin, loc != null ? loc : this.state.startLoc, {\n      missingPlugin: [pluginName]\n    });\n  }\n  expectOnePlugin(pluginNames) {\n    if (!pluginNames.some(name => this.hasPlugin(name))) {\n      throw this.raise(Errors.MissingOneOfPlugins, this.state.startLoc, {\n        missingPlugin: pluginNames\n      });\n    }\n  }\n  errorBuilder(error) {\n    return (pos, lineStart, curLine) => {\n      this.raise(error, buildPosition(pos, lineStart, curLine));\n    };\n  }\n}\nclass ClassScope {\n  constructor() {\n    this.privateNames = new Set();\n    this.loneAccessors = new Map();\n    this.undefinedPrivateNames = new Map();\n  }\n}\nclass ClassScopeHandler {\n  constructor(parser) {\n    this.parser = void 0;\n    this.stack = [];\n    this.undefinedPrivateNames = new Map();\n    this.parser = parser;\n  }\n  current() {\n    return this.stack[this.stack.length - 1];\n  }\n  enter() {\n    this.stack.push(new ClassScope());\n  }\n  exit() {\n    const oldClassScope = this.stack.pop();\n    const current = this.current();\n    for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {\n      if (current) {\n        if (!current.undefinedPrivateNames.has(name)) {\n          current.undefinedPrivateNames.set(name, loc);\n        }\n      } else {\n        this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {\n          identifierName: name\n        });\n      }\n    }\n  }\n  declarePrivateName(name, elementType, loc) {\n    const {\n      privateNames,\n      loneAccessors,\n      undefinedPrivateNames\n    } = this.current();\n    let redefined = privateNames.has(name);\n    if (elementType & 3) {\n      const accessor = redefined && loneAccessors.get(name);\n      if (accessor) {\n        const oldStatic = accessor & 4;\n        const newStatic = elementType & 4;\n        const oldKind = accessor & 3;\n        const newKind = elementType & 3;\n        redefined = oldKind === newKind || oldStatic !== newStatic;\n        if (!redefined) loneAccessors.delete(name);\n      } else if (!redefined) {\n        loneAccessors.set(name, elementType);\n      }\n    }\n    if (redefined) {\n      this.parser.raise(Errors.PrivateNameRedeclaration, loc, {\n        identifierName: name\n      });\n    }\n    privateNames.add(name);\n    undefinedPrivateNames.delete(name);\n  }\n  usePrivateName(name, loc) {\n    let classScope;\n    for (classScope of this.stack) {\n      if (classScope.privateNames.has(name)) return;\n    }\n    if (classScope) {\n      classScope.undefinedPrivateNames.set(name, loc);\n    } else {\n      this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {\n        identifierName: name\n      });\n    }\n  }\n}\nclass ExpressionScope {\n  constructor(type = 0) {\n    this.type = type;\n  }\n  canBeArrowParameterDeclaration() {\n    return this.type === 2 || this.type === 1;\n  }\n  isCertainlyParameterDeclaration() {\n    return this.type === 3;\n  }\n}\nclass ArrowHeadParsingScope extends ExpressionScope {\n  constructor(type) {\n    super(type);\n    this.declarationErrors = new Map();\n  }\n  recordDeclarationError(ParsingErrorClass, at) {\n    const index = at.index;\n    this.declarationErrors.set(index, [ParsingErrorClass, at]);\n  }\n  clearDeclarationError(index) {\n    this.declarationErrors.delete(index);\n  }\n  iterateErrors(iterator) {\n    this.declarationErrors.forEach(iterator);\n  }\n}\nclass ExpressionScopeHandler {\n  constructor(parser) {\n    this.parser = void 0;\n    this.stack = [new ExpressionScope()];\n    this.parser = parser;\n  }\n  enter(scope) {\n    this.stack.push(scope);\n  }\n  exit() {\n    this.stack.pop();\n  }\n  recordParameterInitializerError(toParseError, node) {\n    const origin = node.loc.start;\n    const {\n      stack\n    } = this;\n    let i = stack.length - 1;\n    let scope = stack[i];\n    while (!scope.isCertainlyParameterDeclaration()) {\n      if (scope.canBeArrowParameterDeclaration()) {\n        scope.recordDeclarationError(toParseError, origin);\n      } else {\n        return;\n      }\n      scope = stack[--i];\n    }\n    this.parser.raise(toParseError, origin);\n  }\n  recordArrowParameterBindingError(error, node) {\n    const {\n      stack\n    } = this;\n    const scope = stack[stack.length - 1];\n    const origin = node.loc.start;\n    if (scope.isCertainlyParameterDeclaration()) {\n      this.parser.raise(error, origin);\n    } else if (scope.canBeArrowParameterDeclaration()) {\n      scope.recordDeclarationError(error, origin);\n    } else {\n      return;\n    }\n  }\n  recordAsyncArrowParametersError(at) {\n    const {\n      stack\n    } = this;\n    let i = stack.length - 1;\n    let scope = stack[i];\n    while (scope.canBeArrowParameterDeclaration()) {\n      if (scope.type === 2) {\n        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at);\n      }\n      scope = stack[--i];\n    }\n  }\n  validateAsPattern() {\n    const {\n      stack\n    } = this;\n    const currentScope = stack[stack.length - 1];\n    if (!currentScope.canBeArrowParameterDeclaration()) return;\n    currentScope.iterateErrors(([toParseError, loc]) => {\n      this.parser.raise(toParseError, loc);\n      let i = stack.length - 2;\n      let scope = stack[i];\n      while (scope.canBeArrowParameterDeclaration()) {\n        scope.clearDeclarationError(loc.index);\n        scope = stack[--i];\n      }\n    });\n  }\n}\nfunction newParameterDeclarationScope() {\n  return new ExpressionScope(3);\n}\nfunction newArrowHeadScope() {\n  return new ArrowHeadParsingScope(1);\n}\nfunction newAsyncArrowScope() {\n  return new ArrowHeadParsingScope(2);\n}\nfunction newExpressionScope() {\n  return new ExpressionScope();\n}\nclass ProductionParameterHandler {\n  constructor() {\n    this.stacks = [];\n  }\n  enter(flags) {\n    this.stacks.push(flags);\n  }\n  exit() {\n    this.stacks.pop();\n  }\n  currentFlags() {\n    return this.stacks[this.stacks.length - 1];\n  }\n  get hasAwait() {\n    return (this.currentFlags() & 2) > 0;\n  }\n  get hasYield() {\n    return (this.currentFlags() & 1) > 0;\n  }\n  get hasReturn() {\n    return (this.currentFlags() & 4) > 0;\n  }\n  get hasIn() {\n    return (this.currentFlags() & 8) > 0;\n  }\n}\nfunction functionFlags(isAsync, isGenerator) {\n  return (isAsync ? 2 : 0) | (isGenerator ? 1 : 0);\n}\nclass UtilParser extends Tokenizer {\n  addExtra(node, key, value, enumerable = true) {\n    if (!node) return;\n    let {\n      extra\n    } = node;\n    if (extra == null) {\n      extra = {};\n      node.extra = extra;\n    }\n    if (enumerable) {\n      extra[key] = value;\n    } else {\n      Object.defineProperty(extra, key, {\n        enumerable,\n        value\n      });\n    }\n  }\n  isContextual(token) {\n    return this.state.type === token && !this.state.containsEsc;\n  }\n  isUnparsedContextual(nameStart, name) {\n    const nameEnd = nameStart + name.length;\n    if (this.input.slice(nameStart, nameEnd) === name) {\n      const nextCh = this.input.charCodeAt(nameEnd);\n      return !(isIdentifierChar(nextCh) || (nextCh & 0xfc00) === 0xd800);\n    }\n    return false;\n  }\n  isLookaheadContextual(name) {\n    const next = this.nextTokenStart();\n    return this.isUnparsedContextual(next, name);\n  }\n  eatContextual(token) {\n    if (this.isContextual(token)) {\n      this.next();\n      return true;\n    }\n    return false;\n  }\n  expectContextual(token, toParseError) {\n    if (!this.eatContextual(token)) {\n      if (toParseError != null) {\n        throw this.raise(toParseError, this.state.startLoc);\n      }\n      this.unexpected(null, token);\n    }\n  }\n  canInsertSemicolon() {\n    return this.match(139) || this.match(8) || this.hasPrecedingLineBreak();\n  }\n  hasPrecedingLineBreak() {\n    return hasNewLine(this.input, this.state.lastTokEndLoc.index, this.state.start);\n  }\n  hasFollowingLineBreak() {\n    return hasNewLine(this.input, this.state.end, this.nextTokenStart());\n  }\n  isLineTerminator() {\n    return this.eat(13) || this.canInsertSemicolon();\n  }\n  semicolon(allowAsi = true) {\n    if (allowAsi ? this.isLineTerminator() : this.eat(13)) return;\n    this.raise(Errors.MissingSemicolon, this.state.lastTokEndLoc);\n  }\n  expect(type, loc) {\n    if (!this.eat(type)) {\n      this.unexpected(loc, type);\n    }\n  }\n  tryParse(fn, oldState = this.state.clone()) {\n    const abortSignal = {\n      node: null\n    };\n    try {\n      const node = fn((node = null) => {\n        abortSignal.node = node;\n        throw abortSignal;\n      });\n      if (this.state.errors.length > oldState.errors.length) {\n        const failState = this.state;\n        this.state = oldState;\n        this.state.tokensLength = failState.tokensLength;\n        return {\n          node,\n          error: failState.errors[oldState.errors.length],\n          thrown: false,\n          aborted: false,\n          failState\n        };\n      }\n      return {\n        node,\n        error: null,\n        thrown: false,\n        aborted: false,\n        failState: null\n      };\n    } catch (error) {\n      const failState = this.state;\n      this.state = oldState;\n      if (error instanceof SyntaxError) {\n        return {\n          node: null,\n          error,\n          thrown: true,\n          aborted: false,\n          failState\n        };\n      }\n      if (error === abortSignal) {\n        return {\n          node: abortSignal.node,\n          error: null,\n          thrown: false,\n          aborted: true,\n          failState\n        };\n      }\n      throw error;\n    }\n  }\n  checkExpressionErrors(refExpressionErrors, andThrow) {\n    if (!refExpressionErrors) return false;\n    const {\n      shorthandAssignLoc,\n      doubleProtoLoc,\n      privateKeyLoc,\n      optionalParametersLoc\n    } = refExpressionErrors;\n    const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc;\n    if (!andThrow) {\n      return hasErrors;\n    }\n    if (shorthandAssignLoc != null) {\n      this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);\n    }\n    if (doubleProtoLoc != null) {\n      this.raise(Errors.DuplicateProto, doubleProtoLoc);\n    }\n    if (privateKeyLoc != null) {\n      this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);\n    }\n    if (optionalParametersLoc != null) {\n      this.unexpected(optionalParametersLoc);\n    }\n  }\n  isLiteralPropertyName() {\n    return tokenIsLiteralPropertyName(this.state.type);\n  }\n  isPrivateName(node) {\n    return node.type === \"PrivateName\";\n  }\n  getPrivateNameSV(node) {\n    return node.id.name;\n  }\n  hasPropertyAsPrivateName(node) {\n    return (node.type === \"MemberExpression\" || node.type === \"OptionalMemberExpression\") && this.isPrivateName(node.property);\n  }\n  isObjectProperty(node) {\n    return node.type === \"ObjectProperty\";\n  }\n  isObjectMethod(node) {\n    return node.type === \"ObjectMethod\";\n  }\n  initializeScopes(inModule = this.options.sourceType === \"module\") {\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n    const oldExportedIdentifiers = this.exportedIdentifiers;\n    this.exportedIdentifiers = new Set();\n    const oldInModule = this.inModule;\n    this.inModule = inModule;\n    const oldScope = this.scope;\n    const ScopeHandler = this.getScopeHandler();\n    this.scope = new ScopeHandler(this, inModule);\n    const oldProdParam = this.prodParam;\n    this.prodParam = new ProductionParameterHandler();\n    const oldClassScope = this.classScope;\n    this.classScope = new ClassScopeHandler(this);\n    const oldExpressionScope = this.expressionScope;\n    this.expressionScope = new ExpressionScopeHandler(this);\n    return () => {\n      this.state.labels = oldLabels;\n      this.exportedIdentifiers = oldExportedIdentifiers;\n      this.inModule = oldInModule;\n      this.scope = oldScope;\n      this.prodParam = oldProdParam;\n      this.classScope = oldClassScope;\n      this.expressionScope = oldExpressionScope;\n    };\n  }\n  enterInitialScopes() {\n    let paramFlags = 0;\n    if (this.inModule) {\n      paramFlags |= 2;\n    }\n    this.scope.enter(1);\n    this.prodParam.enter(paramFlags);\n  }\n  checkDestructuringPrivate(refExpressionErrors) {\n    const {\n      privateKeyLoc\n    } = refExpressionErrors;\n    if (privateKeyLoc !== null) {\n      this.expectPlugin(\"destructuringPrivate\", privateKeyLoc);\n    }\n  }\n}\nclass ExpressionErrors {\n  constructor() {\n    this.shorthandAssignLoc = null;\n    this.doubleProtoLoc = null;\n    this.privateKeyLoc = null;\n    this.optionalParametersLoc = null;\n  }\n}\nclass Node {\n  constructor(parser, pos, loc) {\n    this.type = \"\";\n    this.start = pos;\n    this.end = 0;\n    this.loc = new SourceLocation(loc);\n    if (parser != null && parser.options.ranges) this.range = [pos, 0];\n    if (parser != null && parser.filename) this.loc.filename = parser.filename;\n  }\n}\nconst NodePrototype = Node.prototype;\n{\n  NodePrototype.__clone = function () {\n    const newNode = new Node(undefined, this.start, this.loc.start);\n    const keys = Object.keys(this);\n    for (let i = 0, length = keys.length; i < length; i++) {\n      const key = keys[i];\n      if (key !== \"leadingComments\" && key !== \"trailingComments\" && key !== \"innerComments\") {\n        newNode[key] = this[key];\n      }\n    }\n    return newNode;\n  };\n}\nfunction clonePlaceholder(node) {\n  return cloneIdentifier(node);\n}\nfunction cloneIdentifier(node) {\n  const {\n    type,\n    start,\n    end,\n    loc,\n    range,\n    extra,\n    name\n  } = node;\n  const cloned = Object.create(NodePrototype);\n  cloned.type = type;\n  cloned.start = start;\n  cloned.end = end;\n  cloned.loc = loc;\n  cloned.range = range;\n  cloned.extra = extra;\n  cloned.name = name;\n  if (type === \"Placeholder\") {\n    cloned.expectedNode = node.expectedNode;\n  }\n  return cloned;\n}\nfunction cloneStringLiteral(node) {\n  const {\n    type,\n    start,\n    end,\n    loc,\n    range,\n    extra\n  } = node;\n  if (type === \"Placeholder\") {\n    return clonePlaceholder(node);\n  }\n  const cloned = Object.create(NodePrototype);\n  cloned.type = type;\n  cloned.start = start;\n  cloned.end = end;\n  cloned.loc = loc;\n  cloned.range = range;\n  if (node.raw !== undefined) {\n    cloned.raw = node.raw;\n  } else {\n    cloned.extra = extra;\n  }\n  cloned.value = node.value;\n  return cloned;\n}\nclass NodeUtils extends UtilParser {\n  startNode() {\n    const loc = this.state.startLoc;\n    return new Node(this, loc.index, loc);\n  }\n  startNodeAt(loc) {\n    return new Node(this, loc.index, loc);\n  }\n  startNodeAtNode(type) {\n    return this.startNodeAt(type.loc.start);\n  }\n  finishNode(node, type) {\n    return this.finishNodeAt(node, type, this.state.lastTokEndLoc);\n  }\n  finishNodeAt(node, type, endLoc) {\n    node.type = type;\n    node.end = endLoc.index;\n    node.loc.end = endLoc;\n    if (this.options.ranges) node.range[1] = endLoc.index;\n    if (this.options.attachComment) this.processComment(node);\n    return node;\n  }\n  resetStartLocation(node, startLoc) {\n    node.start = startLoc.index;\n    node.loc.start = startLoc;\n    if (this.options.ranges) node.range[0] = startLoc.index;\n  }\n  resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {\n    node.end = endLoc.index;\n    node.loc.end = endLoc;\n    if (this.options.ranges) node.range[1] = endLoc.index;\n  }\n  resetStartLocationFromNode(node, locationNode) {\n    this.resetStartLocation(node, locationNode.loc.start);\n  }\n}\nconst reservedTypes = new Set([\"_\", \"any\", \"bool\", \"boolean\", \"empty\", \"extends\", \"false\", \"interface\", \"mixed\", \"null\", \"number\", \"static\", \"string\", \"true\", \"typeof\", \"void\"]);\nconst FlowErrors = ParseErrorEnum`flow`({\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: ({\n    reservedType\n  }) => `Cannot overwrite reserved type ${reservedType}.`,\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: ({\n    memberName,\n    enumName\n  }) => `Boolean enum members need to be initialized. Use either \\`${memberName} = true,\\` or \\`${memberName} = false,\\` in enum \\`${enumName}\\`.`,\n  EnumDuplicateMemberName: ({\n    memberName,\n    enumName\n  }) => `Enum member names need to be unique, but the name \\`${memberName}\\` has already been used before in enum \\`${enumName}\\`.`,\n  EnumInconsistentMemberValues: ({\n    enumName\n  }) => `Enum \\`${enumName}\\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,\n  EnumInvalidExplicitType: ({\n    invalidEnumType,\n    enumName\n  }) => `Enum type \\`${invalidEnumType}\\` is not valid. Use one of \\`boolean\\`, \\`number\\`, \\`string\\`, or \\`symbol\\` in enum \\`${enumName}\\`.`,\n  EnumInvalidExplicitTypeUnknownSupplied: ({\n    enumName\n  }) => `Supplied enum type is not valid. Use one of \\`boolean\\`, \\`number\\`, \\`string\\`, or \\`symbol\\` in enum \\`${enumName}\\`.`,\n  EnumInvalidMemberInitializerPrimaryType: ({\n    enumName,\n    memberName,\n    explicitType\n  }) => `Enum \\`${enumName}\\` has type \\`${explicitType}\\`, so the initializer of \\`${memberName}\\` needs to be a ${explicitType} literal.`,\n  EnumInvalidMemberInitializerSymbolType: ({\n    enumName,\n    memberName\n  }) => `Symbol enum members cannot be initialized. Use \\`${memberName},\\` in enum \\`${enumName}\\`.`,\n  EnumInvalidMemberInitializerUnknownType: ({\n    enumName,\n    memberName\n  }) => `The enum member initializer for \\`${memberName}\\` needs to be a literal (either a boolean, number, or string) in enum \\`${enumName}\\`.`,\n  EnumInvalidMemberName: ({\n    enumName,\n    memberName,\n    suggestion\n  }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \\`${memberName}\\`, consider using \\`${suggestion}\\`, in enum \\`${enumName}\\`.`,\n  EnumNumberMemberNotInitialized: ({\n    enumName,\n    memberName\n  }) => `Number enum members need to be initialized, e.g. \\`${memberName} = 1\\` in enum \\`${enumName}\\`.`,\n  EnumStringMemberInconsistentlyInitialized: ({\n    enumName\n  }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \\`${enumName}\\`.`,\n  GetterMayNotHaveThisParam: \"A getter cannot have a `this` parameter.\",\n  ImportReflectionHasImportType: \"An `import module` declaration can not use `type` or `typeof` keyword.\",\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  PatternIsOptional: Object.assign({\n    message: \"A binding pattern parameter cannot be optional in an implementation signature.\"\n  }, {\n    reasonCode: \"OptionalBindingPattern\"\n  }),\n  SetterMayNotHaveThisParam: \"A setter cannot have a `this` parameter.\",\n  SpreadVariance: \"Spread properties cannot have variance.\",\n  ThisParamAnnotationRequired: \"A type annotation is required for the `this` parameter.\",\n  ThisParamBannedInConstructor: \"Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.\",\n  ThisParamMayNotBeOptional: \"The `this` parameter cannot be optional.\",\n  ThisParamMustBeFirst: \"The `this` parameter must be the first function parameter.\",\n  ThisParamNoDefault: \"The `this` parameter may not have a default value.\",\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: ({\n    reservedType\n  }) => `Unexpected reserved type ${reservedType}.`,\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: ({\n    unsupportedExportKind,\n    suggestion\n  }) => `\\`declare export ${unsupportedExportKind}\\` is not supported. Use \\`${suggestion}\\` instead.`,\n  UnsupportedStatementInDeclareModule: \"Only declares and type imports are allowed inside declare module.\",\n  UnterminatedFlowComment: \"Unterminated flow-comment.\"\n});\nfunction isEsModuleType(bodyElement) {\n  return bodyElement.type === \"DeclareExportAllDeclaration\" || bodyElement.type === \"DeclareExportDeclaration\" && (!bodyElement.declaration || bodyElement.declaration.type !== \"TypeAlias\" && bodyElement.declaration.type !== \"InterfaceDeclaration\");\n}\nfunction hasTypeImportKind(node) {\n  return node.importKind === \"type\" || node.importKind === \"typeof\";\n}\nconst exportSuggestions = {\n  const: \"declare export var\",\n  let: \"declare export var\",\n  type: \"export type\",\n  interface: \"export interface\"\n};\nfunction partition(list, test) {\n  const list1 = [];\n  const list2 = [];\n  for (let i = 0; i < list.length; i++) {\n    (test(list[i], i, list) ? list1 : list2).push(list[i]);\n  }\n  return [list1, list2];\n}\nconst FLOW_PRAGMA_REGEX = /\\*?\\s*@((?:no)?flow)\\b/;\nvar flow = superClass => class FlowParserMixin extends superClass {\n  constructor(...args) {\n    super(...args);\n    this.flowPragma = undefined;\n  }\n  getScopeHandler() {\n    return FlowScopeHandler;\n  }\n  shouldParseTypes() {\n    return this.getPluginOption(\"flow\", \"all\") || this.flowPragma === \"flow\";\n  }\n  shouldParseEnums() {\n    return !!this.getPluginOption(\"flow\", \"enums\");\n  }\n  finishToken(type, val) {\n    if (type !== 133 && type !== 13 && type !== 28) {\n      if (this.flowPragma === undefined) {\n        this.flowPragma = null;\n      }\n    }\n    super.finishToken(type, val);\n  }\n  addComment(comment) {\n    if (this.flowPragma === undefined) {\n      const 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    super.addComment(comment);\n  }\n  flowParseTypeInitialiser(tok) {\n    const oldInType = this.state.inType;\n    this.state.inType = true;\n    this.expect(tok || 14);\n    const type = this.flowParseType();\n    this.state.inType = oldInType;\n    return type;\n  }\n  flowParsePredicate() {\n    const node = this.startNode();\n    const moduloLoc = this.state.startLoc;\n    this.next();\n    this.expectContextual(110);\n    if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) {\n      this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc);\n    }\n    if (this.eat(10)) {\n      node.value = super.parseExpression();\n      this.expect(11);\n      return this.finishNode(node, \"DeclaredPredicate\");\n    } else {\n      return this.finishNode(node, \"InferredPredicate\");\n    }\n  }\n  flowParseTypeAndPredicateInitialiser() {\n    const oldInType = this.state.inType;\n    this.state.inType = true;\n    this.expect(14);\n    let type = null;\n    let predicate = null;\n    if (this.match(54)) {\n      this.state.inType = oldInType;\n      predicate = this.flowParsePredicate();\n    } else {\n      type = this.flowParseType();\n      this.state.inType = oldInType;\n      if (this.match(54)) {\n        predicate = this.flowParsePredicate();\n      }\n    }\n    return [type, predicate];\n  }\n  flowParseDeclareClass(node) {\n    this.next();\n    this.flowParseInterfaceish(node, true);\n    return this.finishNode(node, \"DeclareClass\");\n  }\n  flowParseDeclareFunction(node) {\n    this.next();\n    const id = node.id = this.parseIdentifier();\n    const typeNode = this.startNode();\n    const typeContainer = this.startNode();\n    if (this.match(47)) {\n      typeNode.typeParameters = this.flowParseTypeParameterDeclaration();\n    } else {\n      typeNode.typeParameters = null;\n    }\n    this.expect(10);\n    const tmp = this.flowParseFunctionTypeParams();\n    typeNode.params = tmp.params;\n    typeNode.rest = tmp.rest;\n    typeNode.this = tmp._this;\n    this.expect(11);\n    [typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser();\n    typeContainer.typeAnnotation = this.finishNode(typeNode, \"FunctionTypeAnnotation\");\n    id.typeAnnotation = this.finishNode(typeContainer, \"TypeAnnotation\");\n    this.resetEndLocation(id);\n    this.semicolon();\n    this.scope.declareName(node.id.name, 2048, node.id.loc.start);\n    return this.finishNode(node, \"DeclareFunction\");\n  }\n  flowParseDeclare(node, insideModule) {\n    if (this.match(80)) {\n      return this.flowParseDeclareClass(node);\n    } else if (this.match(68)) {\n      return this.flowParseDeclareFunction(node);\n    } else if (this.match(74)) {\n      return this.flowParseDeclareVariable(node);\n    } else if (this.eatContextual(127)) {\n      if (this.match(16)) {\n        return this.flowParseDeclareModuleExports(node);\n      } else {\n        if (insideModule) {\n          this.raise(FlowErrors.NestedDeclareModule, this.state.lastTokStartLoc);\n        }\n        return this.flowParseDeclareModule(node);\n      }\n    } else if (this.isContextual(130)) {\n      return this.flowParseDeclareTypeAlias(node);\n    } else if (this.isContextual(131)) {\n      return this.flowParseDeclareOpaqueType(node);\n    } else if (this.isContextual(129)) {\n      return this.flowParseDeclareInterface(node);\n    } else if (this.match(82)) {\n      return this.flowParseDeclareExportDeclaration(node, insideModule);\n    } else {\n      this.unexpected();\n    }\n  }\n  flowParseDeclareVariable(node) {\n    this.next();\n    node.id = this.flowParseTypeAnnotatableIdentifier(true);\n    this.scope.declareName(node.id.name, 5, node.id.loc.start);\n    this.semicolon();\n    return this.finishNode(node, \"DeclareVariable\");\n  }\n  flowParseDeclareModule(node) {\n    this.scope.enter(0);\n    if (this.match(133)) {\n      node.id = super.parseExprAtom();\n    } else {\n      node.id = this.parseIdentifier();\n    }\n    const bodyNode = node.body = this.startNode();\n    const body = bodyNode.body = [];\n    this.expect(5);\n    while (!this.match(8)) {\n      let bodyNode = this.startNode();\n      if (this.match(83)) {\n        this.next();\n        if (!this.isContextual(130) && !this.match(87)) {\n          this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc);\n        }\n        super.parseImport(bodyNode);\n      } else {\n        this.expectContextual(125, FlowErrors.UnsupportedStatementInDeclareModule);\n        bodyNode = this.flowParseDeclare(bodyNode, true);\n      }\n      body.push(bodyNode);\n    }\n    this.scope.exit();\n    this.expect(8);\n    this.finishNode(bodyNode, \"BlockStatement\");\n    let kind = null;\n    let hasModuleExport = false;\n    body.forEach(bodyElement => {\n      if (isEsModuleType(bodyElement)) {\n        if (kind === \"CommonJS\") {\n          this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);\n        }\n        kind = \"ES\";\n      } else if (bodyElement.type === \"DeclareModuleExports\") {\n        if (hasModuleExport) {\n          this.raise(FlowErrors.DuplicateDeclareModuleExports, bodyElement);\n        }\n        if (kind === \"ES\") {\n          this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);\n        }\n        kind = \"CommonJS\";\n        hasModuleExport = true;\n      }\n    });\n    node.kind = kind || \"CommonJS\";\n    return this.finishNode(node, \"DeclareModule\");\n  }\n  flowParseDeclareExportDeclaration(node, insideModule) {\n    this.expect(82);\n    if (this.eat(65)) {\n      if (this.match(68) || this.match(80)) {\n        node.declaration = this.flowParseDeclare(this.startNode());\n      } else {\n        node.declaration = this.flowParseType();\n        this.semicolon();\n      }\n      node.default = true;\n      return this.finishNode(node, \"DeclareExportDeclaration\");\n    } else {\n      if (this.match(75) || this.isLet() || (this.isContextual(130) || this.isContextual(129)) && !insideModule) {\n        const label = this.state.value;\n        throw this.raise(FlowErrors.UnsupportedDeclareExportKind, this.state.startLoc, {\n          unsupportedExportKind: label,\n          suggestion: exportSuggestions[label]\n        });\n      }\n      if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(131)) {\n        node.declaration = this.flowParseDeclare(this.startNode());\n        node.default = false;\n        return this.finishNode(node, \"DeclareExportDeclaration\");\n      } else if (this.match(55) || this.match(5) || this.isContextual(129) || this.isContextual(130) || this.isContextual(131)) {\n        node = this.parseExport(node, null);\n        if (node.type === \"ExportNamedDeclaration\") {\n          node.type = \"ExportDeclaration\";\n          node.default = false;\n          delete node.exportKind;\n        }\n        node.type = \"Declare\" + node.type;\n        return node;\n      }\n    }\n    this.unexpected();\n  }\n  flowParseDeclareModuleExports(node) {\n    this.next();\n    this.expectContextual(111);\n    node.typeAnnotation = this.flowParseTypeAnnotation();\n    this.semicolon();\n    return this.finishNode(node, \"DeclareModuleExports\");\n  }\n  flowParseDeclareTypeAlias(node) {\n    this.next();\n    const finished = this.flowParseTypeAlias(node);\n    finished.type = \"DeclareTypeAlias\";\n    return finished;\n  }\n  flowParseDeclareOpaqueType(node) {\n    this.next();\n    const finished = this.flowParseOpaqueType(node, true);\n    finished.type = \"DeclareOpaqueType\";\n    return finished;\n  }\n  flowParseDeclareInterface(node) {\n    this.next();\n    this.flowParseInterfaceish(node, false);\n    return this.finishNode(node, \"DeclareInterface\");\n  }\n  flowParseInterfaceish(node, isClass) {\n    node.id = this.flowParseRestrictedIdentifier(!isClass, true);\n    this.scope.declareName(node.id.name, isClass ? 17 : 8201, node.id.loc.start);\n    if (this.match(47)) {\n      node.typeParameters = this.flowParseTypeParameterDeclaration();\n    } else {\n      node.typeParameters = null;\n    }\n    node.extends = [];\n    if (this.eat(81)) {\n      do {\n        node.extends.push(this.flowParseInterfaceExtends());\n      } while (!isClass && this.eat(12));\n    }\n    if (isClass) {\n      node.implements = [];\n      node.mixins = [];\n      if (this.eatContextual(117)) {\n        do {\n          node.mixins.push(this.flowParseInterfaceExtends());\n        } while (this.eat(12));\n      }\n      if (this.eatContextual(113)) {\n        do {\n          node.implements.push(this.flowParseInterfaceExtends());\n        } while (this.eat(12));\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  flowParseInterfaceExtends() {\n    const node = this.startNode();\n    node.id = this.flowParseQualifiedTypeIdentifier();\n    if (this.match(47)) {\n      node.typeParameters = this.flowParseTypeParameterInstantiation();\n    } else {\n      node.typeParameters = null;\n    }\n    return this.finishNode(node, \"InterfaceExtends\");\n  }\n  flowParseInterface(node) {\n    this.flowParseInterfaceish(node, false);\n    return this.finishNode(node, \"InterfaceDeclaration\");\n  }\n  checkNotUnderscore(word) {\n    if (word === \"_\") {\n      this.raise(FlowErrors.UnexpectedReservedUnderscore, this.state.startLoc);\n    }\n  }\n  checkReservedType(word, startLoc, declaration) {\n    if (!reservedTypes.has(word)) return;\n    this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, startLoc, {\n      reservedType: word\n    });\n  }\n  flowParseRestrictedIdentifier(liberal, declaration) {\n    this.checkReservedType(this.state.value, this.state.startLoc, declaration);\n    return this.parseIdentifier(liberal);\n  }\n  flowParseTypeAlias(node) {\n    node.id = this.flowParseRestrictedIdentifier(false, true);\n    this.scope.declareName(node.id.name, 8201, node.id.loc.start);\n    if (this.match(47)) {\n      node.typeParameters = this.flowParseTypeParameterDeclaration();\n    } else {\n      node.typeParameters = null;\n    }\n    node.right = this.flowParseTypeInitialiser(29);\n    this.semicolon();\n    return this.finishNode(node, \"TypeAlias\");\n  }\n  flowParseOpaqueType(node, declare) {\n    this.expectContextual(130);\n    node.id = this.flowParseRestrictedIdentifier(true, true);\n    this.scope.declareName(node.id.name, 8201, node.id.loc.start);\n    if (this.match(47)) {\n      node.typeParameters = this.flowParseTypeParameterDeclaration();\n    } else {\n      node.typeParameters = null;\n    }\n    node.supertype = null;\n    if (this.match(14)) {\n      node.supertype = this.flowParseTypeInitialiser(14);\n    }\n    node.impltype = null;\n    if (!declare) {\n      node.impltype = this.flowParseTypeInitialiser(29);\n    }\n    this.semicolon();\n    return this.finishNode(node, \"OpaqueType\");\n  }\n  flowParseTypeParameter(requireDefault = false) {\n    const nodeStartLoc = this.state.startLoc;\n    const node = this.startNode();\n    const variance = this.flowParseVariance();\n    const ident = this.flowParseTypeAnnotatableIdentifier();\n    node.name = ident.name;\n    node.variance = variance;\n    node.bound = ident.typeAnnotation;\n    if (this.match(29)) {\n      this.eat(29);\n      node.default = this.flowParseType();\n    } else {\n      if (requireDefault) {\n        this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);\n      }\n    }\n    return this.finishNode(node, \"TypeParameter\");\n  }\n  flowParseTypeParameterDeclaration() {\n    const oldInType = this.state.inType;\n    const node = this.startNode();\n    node.params = [];\n    this.state.inType = true;\n    if (this.match(47) || this.match(142)) {\n      this.next();\n    } else {\n      this.unexpected();\n    }\n    let defaultRequired = false;\n    do {\n      const typeParameter = this.flowParseTypeParameter(defaultRequired);\n      node.params.push(typeParameter);\n      if (typeParameter.default) {\n        defaultRequired = true;\n      }\n      if (!this.match(48)) {\n        this.expect(12);\n      }\n    } while (!this.match(48));\n    this.expect(48);\n    this.state.inType = oldInType;\n    return this.finishNode(node, \"TypeParameterDeclaration\");\n  }\n  flowParseTypeParameterInstantiation() {\n    const node = this.startNode();\n    const oldInType = this.state.inType;\n    node.params = [];\n    this.state.inType = true;\n    this.expect(47);\n    const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n    this.state.noAnonFunctionType = false;\n    while (!this.match(48)) {\n      node.params.push(this.flowParseType());\n      if (!this.match(48)) {\n        this.expect(12);\n      }\n    }\n    this.state.noAnonFunctionType = oldNoAnonFunctionType;\n    this.expect(48);\n    this.state.inType = oldInType;\n    return this.finishNode(node, \"TypeParameterInstantiation\");\n  }\n  flowParseTypeParameterInstantiationCallOrNew() {\n    const node = this.startNode();\n    const oldInType = this.state.inType;\n    node.params = [];\n    this.state.inType = true;\n    this.expect(47);\n    while (!this.match(48)) {\n      node.params.push(this.flowParseTypeOrImplicitInstantiation());\n      if (!this.match(48)) {\n        this.expect(12);\n      }\n    }\n    this.expect(48);\n    this.state.inType = oldInType;\n    return this.finishNode(node, \"TypeParameterInstantiation\");\n  }\n  flowParseInterfaceType() {\n    const node = this.startNode();\n    this.expectContextual(129);\n    node.extends = [];\n    if (this.eat(81)) {\n      do {\n        node.extends.push(this.flowParseInterfaceExtends());\n      } while (this.eat(12));\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  flowParseObjectPropertyKey() {\n    return this.match(134) || this.match(133) ? super.parseExprAtom() : this.parseIdentifier(true);\n  }\n  flowParseObjectTypeIndexer(node, isStatic, variance) {\n    node.static = isStatic;\n    if (this.lookahead().type === 14) {\n      node.id = this.flowParseObjectPropertyKey();\n      node.key = this.flowParseTypeInitialiser();\n    } else {\n      node.id = null;\n      node.key = this.flowParseType();\n    }\n    this.expect(3);\n    node.value = this.flowParseTypeInitialiser();\n    node.variance = variance;\n    return this.finishNode(node, \"ObjectTypeIndexer\");\n  }\n  flowParseObjectTypeInternalSlot(node, isStatic) {\n    node.static = isStatic;\n    node.id = this.flowParseObjectPropertyKey();\n    this.expect(3);\n    this.expect(3);\n    if (this.match(47) || this.match(10)) {\n      node.method = true;\n      node.optional = false;\n      node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));\n    } else {\n      node.method = false;\n      if (this.eat(17)) {\n        node.optional = true;\n      }\n      node.value = this.flowParseTypeInitialiser();\n    }\n    return this.finishNode(node, \"ObjectTypeInternalSlot\");\n  }\n  flowParseObjectTypeMethodish(node) {\n    node.params = [];\n    node.rest = null;\n    node.typeParameters = null;\n    node.this = null;\n    if (this.match(47)) {\n      node.typeParameters = this.flowParseTypeParameterDeclaration();\n    }\n    this.expect(10);\n    if (this.match(78)) {\n      node.this = this.flowParseFunctionTypeParam(true);\n      node.this.name = null;\n      if (!this.match(11)) {\n        this.expect(12);\n      }\n    }\n    while (!this.match(11) && !this.match(21)) {\n      node.params.push(this.flowParseFunctionTypeParam(false));\n      if (!this.match(11)) {\n        this.expect(12);\n      }\n    }\n    if (this.eat(21)) {\n      node.rest = this.flowParseFunctionTypeParam(false);\n    }\n    this.expect(11);\n    node.returnType = this.flowParseTypeInitialiser();\n    return this.finishNode(node, \"FunctionTypeAnnotation\");\n  }\n  flowParseObjectTypeCallProperty(node, isStatic) {\n    const valueNode = this.startNode();\n    node.static = isStatic;\n    node.value = this.flowParseObjectTypeMethodish(valueNode);\n    return this.finishNode(node, \"ObjectTypeCallProperty\");\n  }\n  flowParseObjectType({\n    allowStatic,\n    allowExact,\n    allowSpread,\n    allowProto,\n    allowInexact\n  }) {\n    const oldInType = this.state.inType;\n    this.state.inType = true;\n    const nodeStart = this.startNode();\n    nodeStart.callProperties = [];\n    nodeStart.properties = [];\n    nodeStart.indexers = [];\n    nodeStart.internalSlots = [];\n    let endDelim;\n    let exact;\n    let inexact = false;\n    if (allowExact && this.match(6)) {\n      this.expect(6);\n      endDelim = 9;\n      exact = true;\n    } else {\n      this.expect(5);\n      endDelim = 8;\n      exact = false;\n    }\n    nodeStart.exact = exact;\n    while (!this.match(endDelim)) {\n      let isStatic = false;\n      let protoStartLoc = null;\n      let inexactStartLoc = null;\n      const node = this.startNode();\n      if (allowProto && this.isContextual(118)) {\n        const lookahead = this.lookahead();\n        if (lookahead.type !== 14 && lookahead.type !== 17) {\n          this.next();\n          protoStartLoc = this.state.startLoc;\n          allowStatic = false;\n        }\n      }\n      if (allowStatic && this.isContextual(106)) {\n        const lookahead = this.lookahead();\n        if (lookahead.type !== 14 && lookahead.type !== 17) {\n          this.next();\n          isStatic = true;\n        }\n      }\n      const variance = this.flowParseVariance();\n      if (this.eat(0)) {\n        if (protoStartLoc != null) {\n          this.unexpected(protoStartLoc);\n        }\n        if (this.eat(0)) {\n          if (variance) {\n            this.unexpected(variance.loc.start);\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(10) || this.match(47)) {\n        if (protoStartLoc != null) {\n          this.unexpected(protoStartLoc);\n        }\n        if (variance) {\n          this.unexpected(variance.loc.start);\n        }\n        nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic));\n      } else {\n        let kind = \"init\";\n        if (this.isContextual(99) || this.isContextual(104)) {\n          const lookahead = this.lookahead();\n          if (tokenIsLiteralPropertyName(lookahead.type)) {\n            kind = this.state.value;\n            this.next();\n          }\n        }\n        const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);\n        if (propOrInexact === null) {\n          inexact = true;\n          inexactStartLoc = this.state.lastTokStartLoc;\n        } else {\n          nodeStart.properties.push(propOrInexact);\n        }\n      }\n      this.flowObjectTypeSemicolon();\n      if (inexactStartLoc && !this.match(8) && !this.match(9)) {\n        this.raise(FlowErrors.UnexpectedExplicitInexactInObject, inexactStartLoc);\n      }\n    }\n    this.expect(endDelim);\n    if (allowSpread) {\n      nodeStart.inexact = inexact;\n    }\n    const out = this.finishNode(nodeStart, \"ObjectTypeAnnotation\");\n    this.state.inType = oldInType;\n    return out;\n  }\n  flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) {\n    if (this.eat(21)) {\n      const isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9);\n      if (isInexactToken) {\n        if (!allowSpread) {\n          this.raise(FlowErrors.InexactInsideNonObject, this.state.lastTokStartLoc);\n        } else if (!allowInexact) {\n          this.raise(FlowErrors.InexactInsideExact, this.state.lastTokStartLoc);\n        }\n        if (variance) {\n          this.raise(FlowErrors.InexactVariance, variance);\n        }\n        return null;\n      }\n      if (!allowSpread) {\n        this.raise(FlowErrors.UnexpectedSpreadType, this.state.lastTokStartLoc);\n      }\n      if (protoStartLoc != null) {\n        this.unexpected(protoStartLoc);\n      }\n      if (variance) {\n        this.raise(FlowErrors.SpreadVariance, variance);\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 = protoStartLoc != null;\n      node.kind = kind;\n      let optional = false;\n      if (this.match(47) || this.match(10)) {\n        node.method = true;\n        if (protoStartLoc != null) {\n          this.unexpected(protoStartLoc);\n        }\n        if (variance) {\n          this.unexpected(variance.loc.start);\n        }\n        node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));\n        if (kind === \"get\" || kind === \"set\") {\n          this.flowCheckGetterSetterParams(node);\n        }\n        if (!allowSpread && node.key.name === \"constructor\" && node.value.this) {\n          this.raise(FlowErrors.ThisParamBannedInConstructor, node.value.this);\n        }\n      } else {\n        if (kind !== \"init\") this.unexpected();\n        node.method = false;\n        if (this.eat(17)) {\n          optional = true;\n        }\n        node.value = this.flowParseTypeInitialiser();\n        node.variance = variance;\n      }\n      node.optional = optional;\n      return this.finishNode(node, \"ObjectTypeProperty\");\n    }\n  }\n  flowCheckGetterSetterParams(property) {\n    const paramCount = property.kind === \"get\" ? 0 : 1;\n    const length = property.value.params.length + (property.value.rest ? 1 : 0);\n    if (property.value.this) {\n      this.raise(property.kind === \"get\" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, property.value.this);\n    }\n    if (length !== paramCount) {\n      this.raise(property.kind === \"get\" ? Errors.BadGetterArity : Errors.BadSetterArity, property);\n    }\n    if (property.kind === \"set\" && property.value.rest) {\n      this.raise(Errors.BadSetterRestParameter, property);\n    }\n  }\n  flowObjectTypeSemicolon() {\n    if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {\n      this.unexpected();\n    }\n  }\n  flowParseQualifiedTypeIdentifier(startLoc, id) {\n    var _startLoc;\n    (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;\n    let node = id || this.flowParseRestrictedIdentifier(true);\n    while (this.eat(16)) {\n      const node2 = this.startNodeAt(startLoc);\n      node2.qualification = node;\n      node2.id = this.flowParseRestrictedIdentifier(true);\n      node = this.finishNode(node2, \"QualifiedTypeIdentifier\");\n    }\n    return node;\n  }\n  flowParseGenericType(startLoc, id) {\n    const node = this.startNodeAt(startLoc);\n    node.typeParameters = null;\n    node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);\n    if (this.match(47)) {\n      node.typeParameters = this.flowParseTypeParameterInstantiation();\n    }\n    return this.finishNode(node, \"GenericTypeAnnotation\");\n  }\n  flowParseTypeofType() {\n    const node = this.startNode();\n    this.expect(87);\n    node.argument = this.flowParsePrimaryType();\n    return this.finishNode(node, \"TypeofTypeAnnotation\");\n  }\n  flowParseTupleType() {\n    const node = this.startNode();\n    node.types = [];\n    this.expect(0);\n    while (this.state.pos < this.length && !this.match(3)) {\n      node.types.push(this.flowParseType());\n      if (this.match(3)) break;\n      this.expect(12);\n    }\n    this.expect(3);\n    return this.finishNode(node, \"TupleTypeAnnotation\");\n  }\n  flowParseFunctionTypeParam(first) {\n    let name = null;\n    let optional = false;\n    let typeAnnotation = null;\n    const node = this.startNode();\n    const lh = this.lookahead();\n    const isThis = this.state.type === 78;\n    if (lh.type === 14 || lh.type === 17) {\n      if (isThis && !first) {\n        this.raise(FlowErrors.ThisParamMustBeFirst, node);\n      }\n      name = this.parseIdentifier(isThis);\n      if (this.eat(17)) {\n        optional = true;\n        if (isThis) {\n          this.raise(FlowErrors.ThisParamMayNotBeOptional, node);\n        }\n      }\n      typeAnnotation = this.flowParseTypeInitialiser();\n    } else {\n      typeAnnotation = this.flowParseType();\n    }\n    node.name = name;\n    node.optional = optional;\n    node.typeAnnotation = typeAnnotation;\n    return this.finishNode(node, \"FunctionTypeParam\");\n  }\n  reinterpretTypeAsFunctionTypeParam(type) {\n    const node = this.startNodeAt(type.loc.start);\n    node.name = null;\n    node.optional = false;\n    node.typeAnnotation = type;\n    return this.finishNode(node, \"FunctionTypeParam\");\n  }\n  flowParseFunctionTypeParams(params = []) {\n    let rest = null;\n    let _this = null;\n    if (this.match(78)) {\n      _this = this.flowParseFunctionTypeParam(true);\n      _this.name = null;\n      if (!this.match(11)) {\n        this.expect(12);\n      }\n    }\n    while (!this.match(11) && !this.match(21)) {\n      params.push(this.flowParseFunctionTypeParam(false));\n      if (!this.match(11)) {\n        this.expect(12);\n      }\n    }\n    if (this.eat(21)) {\n      rest = this.flowParseFunctionTypeParam(false);\n    }\n    return {\n      params,\n      rest,\n      _this\n    };\n  }\n  flowIdentToTypeAnnotation(startLoc, node, id) {\n    switch (id.name) {\n      case \"any\":\n        return this.finishNode(node, \"AnyTypeAnnotation\");\n      case \"bool\":\n      case \"boolean\":\n        return this.finishNode(node, \"BooleanTypeAnnotation\");\n      case \"mixed\":\n        return this.finishNode(node, \"MixedTypeAnnotation\");\n      case \"empty\":\n        return this.finishNode(node, \"EmptyTypeAnnotation\");\n      case \"number\":\n        return this.finishNode(node, \"NumberTypeAnnotation\");\n      case \"string\":\n        return this.finishNode(node, \"StringTypeAnnotation\");\n      case \"symbol\":\n        return this.finishNode(node, \"SymbolTypeAnnotation\");\n      default:\n        this.checkNotUnderscore(id.name);\n        return this.flowParseGenericType(startLoc, id);\n    }\n  }\n  flowParsePrimaryType() {\n    const startLoc = this.state.startLoc;\n    const node = this.startNode();\n    let tmp;\n    let type;\n    let isGroupedType = false;\n    const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n    switch (this.state.type) {\n      case 5:\n        return this.flowParseObjectType({\n          allowStatic: false,\n          allowExact: false,\n          allowSpread: true,\n          allowProto: false,\n          allowInexact: true\n        });\n      case 6:\n        return this.flowParseObjectType({\n          allowStatic: false,\n          allowExact: true,\n          allowSpread: true,\n          allowProto: false,\n          allowInexact: false\n        });\n      case 0:\n        this.state.noAnonFunctionType = false;\n        type = this.flowParseTupleType();\n        this.state.noAnonFunctionType = oldNoAnonFunctionType;\n        return type;\n      case 47:\n        {\n          const node = this.startNode();\n          node.typeParameters = this.flowParseTypeParameterDeclaration();\n          this.expect(10);\n          tmp = this.flowParseFunctionTypeParams();\n          node.params = tmp.params;\n          node.rest = tmp.rest;\n          node.this = tmp._this;\n          this.expect(11);\n          this.expect(19);\n          node.returnType = this.flowParseType();\n          return this.finishNode(node, \"FunctionTypeAnnotation\");\n        }\n      case 10:\n        {\n          const node = this.startNode();\n          this.next();\n          if (!this.match(11) && !this.match(21)) {\n            if (tokenIsIdentifier(this.state.type) || this.match(78)) {\n              const token = this.lookahead().type;\n              isGroupedType = token !== 17 && token !== 14;\n            } else {\n              isGroupedType = true;\n            }\n          }\n          if (isGroupedType) {\n            this.state.noAnonFunctionType = false;\n            type = this.flowParseType();\n            this.state.noAnonFunctionType = oldNoAnonFunctionType;\n            if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {\n              this.expect(11);\n              return type;\n            } else {\n              this.eat(12);\n            }\n          }\n          if (type) {\n            tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);\n          } else {\n            tmp = this.flowParseFunctionTypeParams();\n          }\n          node.params = tmp.params;\n          node.rest = tmp.rest;\n          node.this = tmp._this;\n          this.expect(11);\n          this.expect(19);\n          node.returnType = this.flowParseType();\n          node.typeParameters = null;\n          return this.finishNode(node, \"FunctionTypeAnnotation\");\n        }\n      case 133:\n        return this.parseLiteral(this.state.value, \"StringLiteralTypeAnnotation\");\n      case 85:\n      case 86:\n        node.value = this.match(85);\n        this.next();\n        return this.finishNode(node, \"BooleanLiteralTypeAnnotation\");\n      case 53:\n        if (this.state.value === \"-\") {\n          this.next();\n          if (this.match(134)) {\n            return this.parseLiteralAtNode(-this.state.value, \"NumberLiteralTypeAnnotation\", node);\n          }\n          if (this.match(135)) {\n            return this.parseLiteralAtNode(-this.state.value, \"BigIntLiteralTypeAnnotation\", node);\n          }\n          throw this.raise(FlowErrors.UnexpectedSubtractionOperand, this.state.startLoc);\n        }\n        this.unexpected();\n        return;\n      case 134:\n        return this.parseLiteral(this.state.value, \"NumberLiteralTypeAnnotation\");\n      case 135:\n        return this.parseLiteral(this.state.value, \"BigIntLiteralTypeAnnotation\");\n      case 88:\n        this.next();\n        return this.finishNode(node, \"VoidTypeAnnotation\");\n      case 84:\n        this.next();\n        return this.finishNode(node, \"NullLiteralTypeAnnotation\");\n      case 78:\n        this.next();\n        return this.finishNode(node, \"ThisTypeAnnotation\");\n      case 55:\n        this.next();\n        return this.finishNode(node, \"ExistsTypeAnnotation\");\n      case 87:\n        return this.flowParseTypeofType();\n      default:\n        if (tokenIsKeyword(this.state.type)) {\n          const label = tokenLabelName(this.state.type);\n          this.next();\n          return super.createIdentifier(node, label);\n        } else if (tokenIsIdentifier(this.state.type)) {\n          if (this.isContextual(129)) {\n            return this.flowParseInterfaceType();\n          }\n          return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());\n        }\n    }\n    this.unexpected();\n  }\n  flowParsePostfixType() {\n    const startLoc = this.state.startLoc;\n    let type = this.flowParsePrimaryType();\n    let seenOptionalIndexedAccess = false;\n    while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) {\n      const node = this.startNodeAt(startLoc);\n      const optional = this.eat(18);\n      seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;\n      this.expect(0);\n      if (!optional && this.match(3)) {\n        node.elementType = type;\n        this.next();\n        type = this.finishNode(node, \"ArrayTypeAnnotation\");\n      } else {\n        node.objectType = type;\n        node.indexType = this.flowParseType();\n        this.expect(3);\n        if (seenOptionalIndexedAccess) {\n          node.optional = optional;\n          type = this.finishNode(node, \"OptionalIndexedAccessType\");\n        } else {\n          type = this.finishNode(node, \"IndexedAccessType\");\n        }\n      }\n    }\n    return type;\n  }\n  flowParsePrefixType() {\n    const node = this.startNode();\n    if (this.eat(17)) {\n      node.typeAnnotation = this.flowParsePrefixType();\n      return this.finishNode(node, \"NullableTypeAnnotation\");\n    } else {\n      return this.flowParsePostfixType();\n    }\n  }\n  flowParseAnonFunctionWithoutParens() {\n    const param = this.flowParsePrefixType();\n    if (!this.state.noAnonFunctionType && this.eat(19)) {\n      const node = this.startNodeAt(param.loc.start);\n      node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];\n      node.rest = null;\n      node.this = null;\n      node.returnType = this.flowParseType();\n      node.typeParameters = null;\n      return this.finishNode(node, \"FunctionTypeAnnotation\");\n    }\n    return param;\n  }\n  flowParseIntersectionType() {\n    const node = this.startNode();\n    this.eat(45);\n    const type = this.flowParseAnonFunctionWithoutParens();\n    node.types = [type];\n    while (this.eat(45)) {\n      node.types.push(this.flowParseAnonFunctionWithoutParens());\n    }\n    return node.types.length === 1 ? type : this.finishNode(node, \"IntersectionTypeAnnotation\");\n  }\n  flowParseUnionType() {\n    const node = this.startNode();\n    this.eat(43);\n    const type = this.flowParseIntersectionType();\n    node.types = [type];\n    while (this.eat(43)) {\n      node.types.push(this.flowParseIntersectionType());\n    }\n    return node.types.length === 1 ? type : this.finishNode(node, \"UnionTypeAnnotation\");\n  }\n  flowParseType() {\n    const oldInType = this.state.inType;\n    this.state.inType = true;\n    const type = this.flowParseUnionType();\n    this.state.inType = oldInType;\n    return type;\n  }\n  flowParseTypeOrImplicitInstantiation() {\n    if (this.state.type === 132 && this.state.value === \"_\") {\n      const startLoc = this.state.startLoc;\n      const node = this.parseIdentifier();\n      return this.flowParseGenericType(startLoc, node);\n    } else {\n      return this.flowParseType();\n    }\n  }\n  flowParseTypeAnnotation() {\n    const node = this.startNode();\n    node.typeAnnotation = this.flowParseTypeInitialiser();\n    return this.finishNode(node, \"TypeAnnotation\");\n  }\n  flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {\n    const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();\n    if (this.match(14)) {\n      ident.typeAnnotation = this.flowParseTypeAnnotation();\n      this.resetEndLocation(ident);\n    }\n    return ident;\n  }\n  typeCastToParameter(node) {\n    node.expression.typeAnnotation = node.typeAnnotation;\n    this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);\n    return node.expression;\n  }\n  flowParseVariance() {\n    let variance = null;\n    if (this.match(53)) {\n      variance = this.startNode();\n      if (this.state.value === \"+\") {\n        variance.kind = \"plus\";\n      } else {\n        variance.kind = \"minus\";\n      }\n      this.next();\n      return this.finishNode(variance, \"Variance\");\n    }\n    return variance;\n  }\n  parseFunctionBody(node, allowExpressionBody, isMethod = false) {\n    if (allowExpressionBody) {\n      this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod));\n      return;\n    }\n    super.parseFunctionBody(node, false, isMethod);\n  }\n  parseFunctionBodyAndFinish(node, type, isMethod = false) {\n    if (this.match(14)) {\n      const typeNode = this.startNode();\n      [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();\n      node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, \"TypeAnnotation\") : null;\n    }\n    return super.parseFunctionBodyAndFinish(node, type, isMethod);\n  }\n  parseStatementLike(flags) {\n    if (this.state.strict && this.isContextual(129)) {\n      const lookahead = this.lookahead();\n      if (tokenIsKeywordOrIdentifier(lookahead.type)) {\n        const node = this.startNode();\n        this.next();\n        return this.flowParseInterface(node);\n      }\n    } else if (this.shouldParseEnums() && this.isContextual(126)) {\n      const node = this.startNode();\n      this.next();\n      return this.flowParseEnumDeclaration(node);\n    }\n    const stmt = super.parseStatementLike(flags);\n    if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {\n      this.flowPragma = null;\n    }\n    return stmt;\n  }\n  parseExpressionStatement(node, expr, decorators) {\n    if (expr.type === \"Identifier\") {\n      if (expr.name === \"declare\") {\n        if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) {\n          return this.flowParseDeclare(node);\n        }\n      } else if (tokenIsIdentifier(this.state.type)) {\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    return super.parseExpressionStatement(node, expr, decorators);\n  }\n  shouldParseExportDeclaration() {\n    const {\n      type\n    } = this.state;\n    if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 126) {\n      return !this.state.containsEsc;\n    }\n    return super.shouldParseExportDeclaration();\n  }\n  isExportDefaultSpecifier() {\n    const {\n      type\n    } = this.state;\n    if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 126) {\n      return this.state.containsEsc;\n    }\n    return super.isExportDefaultSpecifier();\n  }\n  parseExportDefaultExpression() {\n    if (this.shouldParseEnums() && this.isContextual(126)) {\n      const node = this.startNode();\n      this.next();\n      return this.flowParseEnumDeclaration(node);\n    }\n    return super.parseExportDefaultExpression();\n  }\n  parseConditional(expr, startLoc, refExpressionErrors) {\n    if (!this.match(17)) return expr;\n    if (this.state.maybeInArrowParameters) {\n      const nextCh = this.lookaheadCharCode();\n      if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {\n        this.setOptionalParametersError(refExpressionErrors);\n        return expr;\n      }\n    }\n    this.expect(17);\n    const state = this.state.clone();\n    const originalNoArrowAt = this.state.noArrowAt;\n    const node = this.startNodeAt(startLoc);\n    let {\n      consequent,\n      failed\n    } = this.tryParseConditionalConsequent();\n    let [valid, invalid] = this.getArrowLikeExpressions(consequent);\n    if (failed || invalid.length > 0) {\n      const noArrowAt = [...originalNoArrowAt];\n      if (invalid.length > 0) {\n        this.state = state;\n        this.state.noArrowAt = noArrowAt;\n        for (let i = 0; i < invalid.length; i++) {\n          noArrowAt.push(invalid[i].start);\n        }\n        ({\n          consequent,\n          failed\n        } = this.tryParseConditionalConsequent());\n        [valid, invalid] = this.getArrowLikeExpressions(consequent);\n      }\n      if (failed && valid.length > 1) {\n        this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc);\n      }\n      if (failed && valid.length === 1) {\n        this.state = state;\n        noArrowAt.push(valid[0].start);\n        this.state.noArrowAt = noArrowAt;\n        ({\n          consequent,\n          failed\n        } = this.tryParseConditionalConsequent());\n      }\n    }\n    this.getArrowLikeExpressions(consequent, true);\n    this.state.noArrowAt = originalNoArrowAt;\n    this.expect(14);\n    node.test = expr;\n    node.consequent = consequent;\n    node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(undefined, undefined));\n    return this.finishNode(node, \"ConditionalExpression\");\n  }\n  tryParseConditionalConsequent() {\n    this.state.noArrowParamsConversionAt.push(this.state.start);\n    const consequent = this.parseMaybeAssignAllowIn();\n    const failed = !this.match(14);\n    this.state.noArrowParamsConversionAt.pop();\n    return {\n      consequent,\n      failed\n    };\n  }\n  getArrowLikeExpressions(node, disallowInvalid) {\n    const stack = [node];\n    const arrows = [];\n    while (stack.length !== 0) {\n      const node = stack.pop();\n      if (node.type === \"ArrowFunctionExpression\" && node.body.type !== \"BlockStatement\") {\n        if (node.typeParameters || !node.returnType) {\n          this.finishArrowValidation(node);\n        } else {\n          arrows.push(node);\n        }\n        stack.push(node.body);\n      } else if (node.type === \"ConditionalExpression\") {\n        stack.push(node.consequent);\n        stack.push(node.alternate);\n      }\n    }\n    if (disallowInvalid) {\n      arrows.forEach(node => this.finishArrowValidation(node));\n      return [arrows, []];\n    }\n    return partition(arrows, node => node.params.every(param => this.isAssignable(param, true)));\n  }\n  finishArrowValidation(node) {\n    var _node$extra;\n    this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false);\n    this.scope.enter(2 | 4);\n    super.checkParams(node, false, true);\n    this.scope.exit();\n  }\n  forwardNoArrowParamsConversionAt(node, parse) {\n    let result;\n    if (this.state.noArrowParamsConversionAt.includes(node.start)) {\n      this.state.noArrowParamsConversionAt.push(this.state.start);\n      result = parse();\n      this.state.noArrowParamsConversionAt.pop();\n    } else {\n      result = parse();\n    }\n    return result;\n  }\n  parseParenItem(node, startLoc) {\n    const newNode = super.parseParenItem(node, startLoc);\n    if (this.eat(17)) {\n      newNode.optional = true;\n      this.resetEndLocation(node);\n    }\n    if (this.match(14)) {\n      const typeCastNode = this.startNodeAt(startLoc);\n      typeCastNode.expression = newNode;\n      typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();\n      return this.finishNode(typeCastNode, \"TypeCastExpression\");\n    }\n    return newNode;\n  }\n  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    super.assertModuleNodeAllowed(node);\n  }\n  parseExportDeclaration(node) {\n    if (this.isContextual(130)) {\n      node.exportKind = \"type\";\n      const declarationNode = this.startNode();\n      this.next();\n      if (this.match(5)) {\n        node.specifiers = this.parseExportSpecifiers(true);\n        super.parseExportFrom(node);\n        return null;\n      } else {\n        return this.flowParseTypeAlias(declarationNode);\n      }\n    } else if (this.isContextual(131)) {\n      node.exportKind = \"type\";\n      const declarationNode = this.startNode();\n      this.next();\n      return this.flowParseOpaqueType(declarationNode, false);\n    } else if (this.isContextual(129)) {\n      node.exportKind = \"type\";\n      const declarationNode = this.startNode();\n      this.next();\n      return this.flowParseInterface(declarationNode);\n    } else if (this.shouldParseEnums() && this.isContextual(126)) {\n      node.exportKind = \"value\";\n      const declarationNode = this.startNode();\n      this.next();\n      return this.flowParseEnumDeclaration(declarationNode);\n    } else {\n      return super.parseExportDeclaration(node);\n    }\n  }\n  eatExportStar(node) {\n    if (super.eatExportStar(node)) return true;\n    if (this.isContextual(130) && this.lookahead().type === 55) {\n      node.exportKind = \"type\";\n      this.next();\n      this.next();\n      return true;\n    }\n    return false;\n  }\n  maybeParseExportNamespaceSpecifier(node) {\n    const {\n      startLoc\n    } = this.state;\n    const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);\n    if (hasNamespace && node.exportKind === \"type\") {\n      this.unexpected(startLoc);\n    }\n    return hasNamespace;\n  }\n  parseClassId(node, isStatement, optionalId) {\n    super.parseClassId(node, isStatement, optionalId);\n    if (this.match(47)) {\n      node.typeParameters = this.flowParseTypeParameterDeclaration();\n    }\n  }\n  parseClassMember(classBody, member, state) {\n    const {\n      startLoc\n    } = this.state;\n    if (this.isContextual(125)) {\n      if (super.parseClassMemberFromModifier(classBody, member)) {\n        return;\n      }\n      member.declare = true;\n    }\n    super.parseClassMember(classBody, member, state);\n    if (member.declare) {\n      if (member.type !== \"ClassProperty\" && member.type !== \"ClassPrivateProperty\" && member.type !== \"PropertyDefinition\") {\n        this.raise(FlowErrors.DeclareClassElement, startLoc);\n      } else if (member.value) {\n        this.raise(FlowErrors.DeclareClassFieldInitializer, member.value);\n      }\n    }\n  }\n  isIterator(word) {\n    return word === \"iterator\" || word === \"asyncIterator\";\n  }\n  readIterator() {\n    const word = super.readWord1();\n    const fullWord = \"@@\" + word;\n    if (!this.isIterator(word) || !this.state.inType) {\n      this.raise(Errors.InvalidIdentifier, this.state.curPosition(), {\n        identifierName: fullWord\n      });\n    }\n    this.finishToken(132, fullWord);\n  }\n  getTokenFromCode(code) {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (code === 123 && next === 124) {\n      this.finishOp(6, 2);\n    } else if (this.state.inType && (code === 62 || code === 60)) {\n      this.finishOp(code === 62 ? 48 : 47, 1);\n    } else if (this.state.inType && code === 63) {\n      if (next === 46) {\n        this.finishOp(18, 2);\n      } else {\n        this.finishOp(17, 1);\n      }\n    } else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) {\n      this.state.pos += 2;\n      this.readIterator();\n    } else {\n      super.getTokenFromCode(code);\n    }\n  }\n  isAssignable(node, isBinding) {\n    if (node.type === \"TypeCastExpression\") {\n      return this.isAssignable(node.expression, isBinding);\n    } else {\n      return super.isAssignable(node, isBinding);\n    }\n  }\n  toAssignable(node, isLHS = false) {\n    if (!isLHS && node.type === \"AssignmentExpression\" && node.left.type === \"TypeCastExpression\") {\n      node.left = this.typeCastToParameter(node.left);\n    }\n    super.toAssignable(node, isLHS);\n  }\n  toAssignableList(exprList, trailingCommaLoc, isLHS) {\n    for (let i = 0; i < exprList.length; i++) {\n      const expr = exprList[i];\n      if ((expr == null ? void 0 : expr.type) === \"TypeCastExpression\") {\n        exprList[i] = this.typeCastToParameter(expr);\n      }\n    }\n    super.toAssignableList(exprList, trailingCommaLoc, isLHS);\n  }\n  toReferencedList(exprList, isParenthesizedExpr) {\n    for (let i = 0; i < exprList.length; i++) {\n      var _expr$extra;\n      const expr = exprList[i];\n      if (expr && expr.type === \"TypeCastExpression\" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) {\n        this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);\n      }\n    }\n    return exprList;\n  }\n  parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {\n    const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);\n    if (canBePattern && !this.state.maybeInArrowParameters) {\n      this.toReferencedList(node.elements);\n    }\n    return node;\n  }\n  isValidLVal(type, isParenthesized, binding) {\n    return type === \"TypeCastExpression\" || super.isValidLVal(type, isParenthesized, binding);\n  }\n  parseClassProperty(node) {\n    if (this.match(14)) {\n      node.typeAnnotation = this.flowParseTypeAnnotation();\n    }\n    return super.parseClassProperty(node);\n  }\n  parseClassPrivateProperty(node) {\n    if (this.match(14)) {\n      node.typeAnnotation = this.flowParseTypeAnnotation();\n    }\n    return super.parseClassPrivateProperty(node);\n  }\n  isClassMethod() {\n    return this.match(47) || super.isClassMethod();\n  }\n  isClassProperty() {\n    return this.match(14) || super.isClassProperty();\n  }\n  isNonstaticConstructor(method) {\n    return !this.match(14) && super.isNonstaticConstructor(method);\n  }\n  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n    if (method.variance) {\n      this.unexpected(method.variance.loc.start);\n    }\n    delete method.variance;\n    if (this.match(47)) {\n      method.typeParameters = this.flowParseTypeParameterDeclaration();\n    }\n    super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);\n    if (method.params && isConstructor) {\n      const params = method.params;\n      if (params.length > 0 && this.isThisParam(params[0])) {\n        this.raise(FlowErrors.ThisParamBannedInConstructor, method);\n      }\n    } else if (method.type === \"MethodDefinition\" && isConstructor && method.value.params) {\n      const params = method.value.params;\n      if (params.length > 0 && this.isThisParam(params[0])) {\n        this.raise(FlowErrors.ThisParamBannedInConstructor, method);\n      }\n    }\n  }\n  pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {\n    if (method.variance) {\n      this.unexpected(method.variance.loc.start);\n    }\n    delete method.variance;\n    if (this.match(47)) {\n      method.typeParameters = this.flowParseTypeParameterDeclaration();\n    }\n    super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);\n  }\n  parseClassSuper(node) {\n    super.parseClassSuper(node);\n    if (node.superClass && this.match(47)) {\n      node.superTypeParameters = this.flowParseTypeParameterInstantiation();\n    }\n    if (this.isContextual(113)) {\n      this.next();\n      const implemented = node.implements = [];\n      do {\n        const node = this.startNode();\n        node.id = this.flowParseRestrictedIdentifier(true);\n        if (this.match(47)) {\n          node.typeParameters = this.flowParseTypeParameterInstantiation();\n        } else {\n          node.typeParameters = null;\n        }\n        implemented.push(this.finishNode(node, \"ClassImplements\"));\n      } while (this.eat(12));\n    }\n  }\n  checkGetterSetterParams(method) {\n    super.checkGetterSetterParams(method);\n    const params = this.getObjectOrClassMethodParams(method);\n    if (params.length > 0) {\n      const param = params[0];\n      if (this.isThisParam(param) && method.kind === \"get\") {\n        this.raise(FlowErrors.GetterMayNotHaveThisParam, param);\n      } else if (this.isThisParam(param)) {\n        this.raise(FlowErrors.SetterMayNotHaveThisParam, param);\n      }\n    }\n  }\n  parsePropertyNamePrefixOperator(node) {\n    node.variance = this.flowParseVariance();\n  }\n  parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {\n    if (prop.variance) {\n      this.unexpected(prop.variance.loc.start);\n    }\n    delete prop.variance;\n    let typeParameters;\n    if (this.match(47) && !isAccessor) {\n      typeParameters = this.flowParseTypeParameterDeclaration();\n      if (!this.match(10)) this.unexpected();\n    }\n    const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);\n    if (typeParameters) {\n      (result.value || result).typeParameters = typeParameters;\n    }\n    return result;\n  }\n  parseAssignableListItemTypes(param) {\n    if (this.eat(17)) {\n      if (param.type !== \"Identifier\") {\n        this.raise(FlowErrors.PatternIsOptional, param);\n      }\n      if (this.isThisParam(param)) {\n        this.raise(FlowErrors.ThisParamMayNotBeOptional, param);\n      }\n      param.optional = true;\n    }\n    if (this.match(14)) {\n      param.typeAnnotation = this.flowParseTypeAnnotation();\n    } else if (this.isThisParam(param)) {\n      this.raise(FlowErrors.ThisParamAnnotationRequired, param);\n    }\n    if (this.match(29) && this.isThisParam(param)) {\n      this.raise(FlowErrors.ThisParamNoDefault, param);\n    }\n    this.resetEndLocation(param);\n    return param;\n  }\n  parseMaybeDefault(startLoc, left) {\n    const node = super.parseMaybeDefault(startLoc, left);\n    if (node.type === \"AssignmentPattern\" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {\n      this.raise(FlowErrors.TypeBeforeInitializer, node.typeAnnotation);\n    }\n    return node;\n  }\n  checkImportReflection(node) {\n    super.checkImportReflection(node);\n    if (node.module && node.importKind !== \"value\") {\n      this.raise(FlowErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);\n    }\n  }\n  parseImportSpecifierLocal(node, specifier, type) {\n    specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();\n    node.specifiers.push(this.finishImportSpecifier(specifier, type));\n  }\n  isPotentialImportPhase(isExport) {\n    if (super.isPotentialImportPhase(isExport)) return true;\n    if (this.isContextual(130)) {\n      if (!isExport) return true;\n      const ch = this.lookaheadCharCode();\n      return ch === 123 || ch === 42;\n    }\n    return !isExport && this.isContextual(87);\n  }\n  applyImportPhase(node, isExport, phase, loc) {\n    super.applyImportPhase(node, isExport, phase, loc);\n    if (isExport) {\n      if (!phase && this.match(65)) {\n        return;\n      }\n      node.exportKind = phase === \"type\" ? phase : \"value\";\n    } else {\n      if (phase === \"type\" && this.match(55)) this.unexpected();\n      node.importKind = phase === \"type\" || phase === \"typeof\" ? phase : \"value\";\n    }\n  }\n  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {\n    const firstIdent = specifier.imported;\n    let specifierTypeKind = null;\n    if (firstIdent.type === \"Identifier\") {\n      if (firstIdent.name === \"type\") {\n        specifierTypeKind = \"type\";\n      } else if (firstIdent.name === \"typeof\") {\n        specifierTypeKind = \"typeof\";\n      }\n    }\n    let isBinding = false;\n    if (this.isContextual(93) && !this.isLookaheadContextual(\"as\")) {\n      const as_ident = this.parseIdentifier(true);\n      if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) {\n        specifier.imported = as_ident;\n        specifier.importKind = specifierTypeKind;\n        specifier.local = cloneIdentifier(as_ident);\n      } else {\n        specifier.imported = firstIdent;\n        specifier.importKind = null;\n        specifier.local = this.parseIdentifier();\n      }\n    } else {\n      if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) {\n        specifier.imported = this.parseIdentifier(true);\n        specifier.importKind = specifierTypeKind;\n      } else {\n        if (importedIsString) {\n          throw this.raise(Errors.ImportBindingIsString, specifier, {\n            importName: firstIdent.value\n          });\n        }\n        specifier.imported = firstIdent;\n        specifier.importKind = null;\n      }\n      if (this.eatContextual(93)) {\n        specifier.local = this.parseIdentifier();\n      } else {\n        isBinding = true;\n        specifier.local = cloneIdentifier(specifier.imported);\n      }\n    }\n    const specifierIsTypeImport = hasTypeImportKind(specifier);\n    if (isInTypeOnlyImport && specifierIsTypeImport) {\n      this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);\n    }\n    if (isInTypeOnlyImport || specifierIsTypeImport) {\n      this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);\n    }\n    if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {\n      this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);\n    }\n    return this.finishImportSpecifier(specifier, \"ImportSpecifier\");\n  }\n  parseBindingAtom() {\n    switch (this.state.type) {\n      case 78:\n        return this.parseIdentifier(true);\n      default:\n        return super.parseBindingAtom();\n    }\n  }\n  parseFunctionParams(node, isConstructor) {\n    const kind = node.kind;\n    if (kind !== \"get\" && kind !== \"set\" && this.match(47)) {\n      node.typeParameters = this.flowParseTypeParameterDeclaration();\n    }\n    super.parseFunctionParams(node, isConstructor);\n  }\n  parseVarId(decl, kind) {\n    super.parseVarId(decl, kind);\n    if (this.match(14)) {\n      decl.id.typeAnnotation = this.flowParseTypeAnnotation();\n      this.resetEndLocation(decl.id);\n    }\n  }\n  parseAsyncArrowFromCallExpression(node, call) {\n    if (this.match(14)) {\n      const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n      this.state.noAnonFunctionType = true;\n      node.returnType = this.flowParseTypeAnnotation();\n      this.state.noAnonFunctionType = oldNoAnonFunctionType;\n    }\n    return super.parseAsyncArrowFromCallExpression(node, call);\n  }\n  shouldParseAsyncArrow() {\n    return this.match(14) || super.shouldParseAsyncArrow();\n  }\n  parseMaybeAssign(refExpressionErrors, afterLeftParse) {\n    var _jsx;\n    let state = null;\n    let jsx;\n    if (this.hasPlugin(\"jsx\") && (this.match(142) || this.match(47))) {\n      state = this.state.clone();\n      jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);\n      if (!jsx.error) return jsx.node;\n      const {\n        context\n      } = this.state;\n      const currentContext = context[context.length - 1];\n      if (currentContext === types.j_oTag || currentContext === types.j_expr) {\n        context.pop();\n      }\n    }\n    if ((_jsx = jsx) != null && _jsx.error || this.match(47)) {\n      var _jsx2, _jsx3;\n      state = state || this.state.clone();\n      let typeParameters;\n      const arrow = this.tryParse(abort => {\n        var _arrowExpression$extr;\n        typeParameters = this.flowParseTypeParameterDeclaration();\n        const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => {\n          const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n          this.resetStartLocationFromNode(result, typeParameters);\n          return result;\n        });\n        if ((_arrowExpression$extr = arrowExpression.extra) != null && _arrowExpression$extr.parenthesized) abort();\n        const expr = this.maybeUnwrapTypeCastExpression(arrowExpression);\n        if (expr.type !== \"ArrowFunctionExpression\") abort();\n        expr.typeParameters = typeParameters;\n        this.resetStartLocationFromNode(expr, typeParameters);\n        return arrowExpression;\n      }, state);\n      let arrowExpression = null;\n      if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === \"ArrowFunctionExpression\") {\n        if (!arrow.error && !arrow.aborted) {\n          if (arrow.node.async) {\n            this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, typeParameters);\n          }\n          return arrow.node;\n        }\n        arrowExpression = arrow.node;\n      }\n      if ((_jsx2 = jsx) != null && _jsx2.node) {\n        this.state = jsx.failState;\n        return jsx.node;\n      }\n      if (arrowExpression) {\n        this.state = arrow.failState;\n        return arrowExpression;\n      }\n      if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;\n      if (arrow.thrown) throw arrow.error;\n      throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, typeParameters);\n    }\n    return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n  }\n  parseArrow(node) {\n    if (this.match(14)) {\n      const result = this.tryParse(() => {\n        const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n        this.state.noAnonFunctionType = true;\n        const typeNode = this.startNode();\n        [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();\n        this.state.noAnonFunctionType = oldNoAnonFunctionType;\n        if (this.canInsertSemicolon()) this.unexpected();\n        if (!this.match(19)) this.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    return super.parseArrow(node);\n  }\n  shouldParseArrow(params) {\n    return this.match(14) || super.shouldParseArrow(params);\n  }\n  setArrowFunctionParameters(node, params) {\n    if (this.state.noArrowParamsConversionAt.includes(node.start)) {\n      node.params = params;\n    } else {\n      super.setArrowFunctionParameters(node, params);\n    }\n  }\n  checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {\n    if (isArrowFunction && this.state.noArrowParamsConversionAt.includes(node.start)) {\n      return;\n    }\n    for (let i = 0; i < node.params.length; i++) {\n      if (this.isThisParam(node.params[i]) && i > 0) {\n        this.raise(FlowErrors.ThisParamMustBeFirst, node.params[i]);\n      }\n    }\n    super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);\n  }\n  parseParenAndDistinguishExpression(canBeArrow) {\n    return super.parseParenAndDistinguishExpression(canBeArrow && !this.state.noArrowAt.includes(this.state.start));\n  }\n  parseSubscripts(base, startLoc, noCalls) {\n    if (base.type === \"Identifier\" && base.name === \"async\" && this.state.noArrowAt.includes(startLoc.index)) {\n      this.next();\n      const node = this.startNodeAt(startLoc);\n      node.callee = base;\n      node.arguments = super.parseCallExpressionArguments(11, false);\n      base = this.finishNode(node, \"CallExpression\");\n    } else if (base.type === \"Identifier\" && base.name === \"async\" && this.match(47)) {\n      const state = this.state.clone();\n      const arrow = this.tryParse(abort => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(), state);\n      if (!arrow.error && !arrow.aborted) return arrow.node;\n      const result = this.tryParse(() => super.parseSubscripts(base, startLoc, noCalls), state);\n      if (result.node && !result.error) return result.node;\n      if (arrow.node) {\n        this.state = arrow.failState;\n        return arrow.node;\n      }\n      if (result.node) {\n        this.state = result.failState;\n        return result.node;\n      }\n      throw arrow.error || result.error;\n    }\n    return super.parseSubscripts(base, startLoc, noCalls);\n  }\n  parseSubscript(base, startLoc, noCalls, subscriptState) {\n    if (this.match(18) && this.isLookaheadToken_lt()) {\n      subscriptState.optionalChainMember = true;\n      if (noCalls) {\n        subscriptState.stop = true;\n        return base;\n      }\n      this.next();\n      const node = this.startNodeAt(startLoc);\n      node.callee = base;\n      node.typeArguments = this.flowParseTypeParameterInstantiation();\n      this.expect(10);\n      node.arguments = this.parseCallExpressionArguments(11, false);\n      node.optional = true;\n      return this.finishCallExpression(node, true);\n    } else if (!noCalls && this.shouldParseTypes() && this.match(47)) {\n      const node = this.startNodeAt(startLoc);\n      node.callee = base;\n      const result = this.tryParse(() => {\n        node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();\n        this.expect(10);\n        node.arguments = super.parseCallExpressionArguments(11, false);\n        if (subscriptState.optionalChainMember) {\n          node.optional = false;\n        }\n        return this.finishCallExpression(node, subscriptState.optionalChainMember);\n      });\n      if (result.node) {\n        if (result.error) this.state = result.failState;\n        return result.node;\n      }\n    }\n    return super.parseSubscript(base, startLoc, noCalls, subscriptState);\n  }\n  parseNewCallee(node) {\n    super.parseNewCallee(node);\n    let targs = null;\n    if (this.shouldParseTypes() && this.match(47)) {\n      targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;\n    }\n    node.typeArguments = targs;\n  }\n  parseAsyncArrowWithTypeParameters(startLoc) {\n    const node = this.startNodeAt(startLoc);\n    this.parseFunctionParams(node, false);\n    if (!this.parseArrow(node)) return;\n    return super.parseArrowExpression(node, undefined, true);\n  }\n  readToken_mult_modulo(code) {\n    const next = this.input.charCodeAt(this.state.pos + 1);\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    super.readToken_mult_modulo(code);\n  }\n  readToken_pipe_amp(code) {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (code === 124 && next === 125) {\n      this.finishOp(9, 2);\n      return;\n    }\n    super.readToken_pipe_amp(code);\n  }\n  parseTopLevel(file, program) {\n    const fileNode = super.parseTopLevel(file, program);\n    if (this.state.hasFlowComment) {\n      this.raise(FlowErrors.UnterminatedFlowComment, this.state.curPosition());\n    }\n    return fileNode;\n  }\n  skipBlockComment() {\n    if (this.hasPlugin(\"flowComments\") && this.skipFlowComment()) {\n      if (this.state.hasFlowComment) {\n        throw this.raise(FlowErrors.NestedFlowComment, this.state.startLoc);\n      }\n      this.hasFlowCommentCompletion();\n      const commentSkip = this.skipFlowComment();\n      if (commentSkip) {\n        this.state.pos += commentSkip;\n        this.state.hasFlowComment = true;\n      }\n      return;\n    }\n    return super.skipBlockComment(this.state.hasFlowComment ? \"*-/\" : \"*/\");\n  }\n  skipFlowComment() {\n    const {\n      pos\n    } = this.state;\n    let shiftToFirstNonWhiteSpace = 2;\n    while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {\n      shiftToFirstNonWhiteSpace++;\n    }\n    const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);\n    const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);\n    if (ch2 === 58 && ch3 === 58) {\n      return shiftToFirstNonWhiteSpace + 2;\n    }\n    if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === \"flow-include\") {\n      return shiftToFirstNonWhiteSpace + 12;\n    }\n    if (ch2 === 58 && ch3 !== 58) {\n      return shiftToFirstNonWhiteSpace;\n    }\n    return false;\n  }\n  hasFlowCommentCompletion() {\n    const end = this.input.indexOf(\"*/\", this.state.pos);\n    if (end === -1) {\n      throw this.raise(Errors.UnterminatedComment, this.state.curPosition());\n    }\n  }\n  flowEnumErrorBooleanMemberNotInitialized(loc, {\n    enumName,\n    memberName\n  }) {\n    this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, {\n      memberName,\n      enumName\n    });\n  }\n  flowEnumErrorInvalidMemberInitializer(loc, enumContext) {\n    return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === \"symbol\" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, loc, enumContext);\n  }\n  flowEnumErrorNumberMemberNotInitialized(loc, details) {\n    this.raise(FlowErrors.EnumNumberMemberNotInitialized, loc, details);\n  }\n  flowEnumErrorStringMemberInconsistentlyInitialized(node, details) {\n    this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, node, details);\n  }\n  flowEnumMemberInit() {\n    const startLoc = this.state.startLoc;\n    const endOfInit = () => this.match(12) || this.match(8);\n    switch (this.state.type) {\n      case 134:\n        {\n          const literal = this.parseNumericLiteral(this.state.value);\n          if (endOfInit()) {\n            return {\n              type: \"number\",\n              loc: literal.loc.start,\n              value: literal\n            };\n          }\n          return {\n            type: \"invalid\",\n            loc: startLoc\n          };\n        }\n      case 133:\n        {\n          const literal = this.parseStringLiteral(this.state.value);\n          if (endOfInit()) {\n            return {\n              type: \"string\",\n              loc: literal.loc.start,\n              value: literal\n            };\n          }\n          return {\n            type: \"invalid\",\n            loc: startLoc\n          };\n        }\n      case 85:\n      case 86:\n        {\n          const literal = this.parseBooleanLiteral(this.match(85));\n          if (endOfInit()) {\n            return {\n              type: \"boolean\",\n              loc: literal.loc.start,\n              value: literal\n            };\n          }\n          return {\n            type: \"invalid\",\n            loc: startLoc\n          };\n        }\n      default:\n        return {\n          type: \"invalid\",\n          loc: startLoc\n        };\n    }\n  }\n  flowEnumMemberRaw() {\n    const loc = this.state.startLoc;\n    const id = this.parseIdentifier(true);\n    const init = this.eat(29) ? this.flowEnumMemberInit() : {\n      type: \"none\",\n      loc\n    };\n    return {\n      id,\n      init\n    };\n  }\n  flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {\n    const {\n      explicitType\n    } = context;\n    if (explicitType === null) {\n      return;\n    }\n    if (explicitType !== expectedType) {\n      this.flowEnumErrorInvalidMemberInitializer(loc, context);\n    }\n  }\n  flowEnumMembers({\n    enumName,\n    explicitType\n  }) {\n    const seenNames = new Set();\n    const members = {\n      booleanMembers: [],\n      numberMembers: [],\n      stringMembers: [],\n      defaultedMembers: []\n    };\n    let hasUnknownMembers = false;\n    while (!this.match(8)) {\n      if (this.eat(21)) {\n        hasUnknownMembers = true;\n        break;\n      }\n      const memberNode = this.startNode();\n      const {\n        id,\n        init\n      } = this.flowEnumMemberRaw();\n      const memberName = id.name;\n      if (memberName === \"\") {\n        continue;\n      }\n      if (/^[a-z]/.test(memberName)) {\n        this.raise(FlowErrors.EnumInvalidMemberName, id, {\n          memberName,\n          suggestion: memberName[0].toUpperCase() + memberName.slice(1),\n          enumName\n        });\n      }\n      if (seenNames.has(memberName)) {\n        this.raise(FlowErrors.EnumDuplicateMemberName, id, {\n          memberName,\n          enumName\n        });\n      }\n      seenNames.add(memberName);\n      const context = {\n        enumName,\n        explicitType,\n        memberName\n      };\n      memberNode.id = id;\n      switch (init.type) {\n        case \"boolean\":\n          {\n            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"boolean\");\n            memberNode.init = init.value;\n            members.booleanMembers.push(this.finishNode(memberNode, \"EnumBooleanMember\"));\n            break;\n          }\n        case \"number\":\n          {\n            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"number\");\n            memberNode.init = init.value;\n            members.numberMembers.push(this.finishNode(memberNode, \"EnumNumberMember\"));\n            break;\n          }\n        case \"string\":\n          {\n            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"string\");\n            memberNode.init = init.value;\n            members.stringMembers.push(this.finishNode(memberNode, \"EnumStringMember\"));\n            break;\n          }\n        case \"invalid\":\n          {\n            throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);\n          }\n        case \"none\":\n          {\n            switch (explicitType) {\n              case \"boolean\":\n                this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);\n                break;\n              case \"number\":\n                this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);\n                break;\n              default:\n                members.defaultedMembers.push(this.finishNode(memberNode, \"EnumDefaultedMember\"));\n            }\n          }\n      }\n      if (!this.match(8)) {\n        this.expect(12);\n      }\n    }\n    return {\n      members,\n      hasUnknownMembers\n    };\n  }\n  flowEnumStringMembers(initializedMembers, defaultedMembers, {\n    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 (const member of initializedMembers) {\n        this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {\n          enumName\n        });\n      }\n      return defaultedMembers;\n    } else {\n      for (const member of defaultedMembers) {\n        this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {\n          enumName\n        });\n      }\n      return initializedMembers;\n    }\n  }\n  flowEnumParseExplicitType({\n    enumName\n  }) {\n    if (!this.eatContextual(102)) return null;\n    if (!tokenIsIdentifier(this.state.type)) {\n      throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, {\n        enumName\n      });\n    }\n    const {\n      value\n    } = this.state;\n    this.next();\n    if (value !== \"boolean\" && value !== \"number\" && value !== \"string\" && value !== \"symbol\") {\n      this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, {\n        enumName,\n        invalidEnumType: value\n      });\n    }\n    return value;\n  }\n  flowEnumBody(node, id) {\n    const enumName = id.name;\n    const nameLoc = id.loc.start;\n    const explicitType = this.flowEnumParseExplicitType({\n      enumName\n    });\n    this.expect(5);\n    const {\n      members,\n      hasUnknownMembers\n    } = this.flowEnumMembers({\n      enumName,\n      explicitType\n    });\n    node.hasUnknownMembers = hasUnknownMembers;\n    switch (explicitType) {\n      case \"boolean\":\n        node.explicitType = true;\n        node.members = members.booleanMembers;\n        this.expect(8);\n        return this.finishNode(node, \"EnumBooleanBody\");\n      case \"number\":\n        node.explicitType = true;\n        node.members = members.numberMembers;\n        this.expect(8);\n        return this.finishNode(node, \"EnumNumberBody\");\n      case \"string\":\n        node.explicitType = true;\n        node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {\n          enumName\n        });\n        this.expect(8);\n        return this.finishNode(node, \"EnumStringBody\");\n      case \"symbol\":\n        node.members = members.defaultedMembers;\n        this.expect(8);\n        return this.finishNode(node, \"EnumSymbolBody\");\n      default:\n        {\n          const empty = () => {\n            node.members = [];\n            this.expect(8);\n            return this.finishNode(node, \"EnumStringBody\");\n          };\n          node.explicitType = false;\n          const boolsLen = members.booleanMembers.length;\n          const numsLen = members.numberMembers.length;\n          const strsLen = members.stringMembers.length;\n          const defaultedLen = members.defaultedMembers.length;\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\n            });\n            this.expect(8);\n            return this.finishNode(node, \"EnumStringBody\");\n          } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {\n            for (const member of members.defaultedMembers) {\n              this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {\n                enumName,\n                memberName: member.id.name\n              });\n            }\n            node.members = members.booleanMembers;\n            this.expect(8);\n            return this.finishNode(node, \"EnumBooleanBody\");\n          } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {\n            for (const member of members.defaultedMembers) {\n              this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {\n                enumName,\n                memberName: member.id.name\n              });\n            }\n            node.members = members.numberMembers;\n            this.expect(8);\n            return this.finishNode(node, \"EnumNumberBody\");\n          } else {\n            this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, {\n              enumName\n            });\n            return empty();\n          }\n        }\n    }\n  }\n  flowParseEnumDeclaration(node) {\n    const id = this.parseIdentifier();\n    node.id = id;\n    node.body = this.flowEnumBody(this.startNode(), id);\n    return this.finishNode(node, \"EnumDeclaration\");\n  }\n  isLookaheadToken_lt() {\n    const next = this.nextTokenStart();\n    if (this.input.charCodeAt(next) === 60) {\n      const afterNext = this.input.charCodeAt(next + 1);\n      return afterNext !== 60 && afterNext !== 61;\n    }\n    return false;\n  }\n  maybeUnwrapTypeCastExpression(node) {\n    return node.type === \"TypeCastExpression\" ? node.expression : node;\n  }\n};\nconst entities = {\n  __proto__: null,\n  quot: \"\\u0022\",\n  amp: \"&\",\n  apos: \"\\u0027\",\n  lt: \"<\",\n  gt: \">\",\n  nbsp: \"\\u00A0\",\n  iexcl: \"\\u00A1\",\n  cent: \"\\u00A2\",\n  pound: \"\\u00A3\",\n  curren: \"\\u00A4\",\n  yen: \"\\u00A5\",\n  brvbar: \"\\u00A6\",\n  sect: \"\\u00A7\",\n  uml: \"\\u00A8\",\n  copy: \"\\u00A9\",\n  ordf: \"\\u00AA\",\n  laquo: \"\\u00AB\",\n  not: \"\\u00AC\",\n  shy: \"\\u00AD\",\n  reg: \"\\u00AE\",\n  macr: \"\\u00AF\",\n  deg: \"\\u00B0\",\n  plusmn: \"\\u00B1\",\n  sup2: \"\\u00B2\",\n  sup3: \"\\u00B3\",\n  acute: \"\\u00B4\",\n  micro: \"\\u00B5\",\n  para: \"\\u00B6\",\n  middot: \"\\u00B7\",\n  cedil: \"\\u00B8\",\n  sup1: \"\\u00B9\",\n  ordm: \"\\u00BA\",\n  raquo: \"\\u00BB\",\n  frac14: \"\\u00BC\",\n  frac12: \"\\u00BD\",\n  frac34: \"\\u00BE\",\n  iquest: \"\\u00BF\",\n  Agrave: \"\\u00C0\",\n  Aacute: \"\\u00C1\",\n  Acirc: \"\\u00C2\",\n  Atilde: \"\\u00C3\",\n  Auml: \"\\u00C4\",\n  Aring: \"\\u00C5\",\n  AElig: \"\\u00C6\",\n  Ccedil: \"\\u00C7\",\n  Egrave: \"\\u00C8\",\n  Eacute: \"\\u00C9\",\n  Ecirc: \"\\u00CA\",\n  Euml: \"\\u00CB\",\n  Igrave: \"\\u00CC\",\n  Iacute: \"\\u00CD\",\n  Icirc: \"\\u00CE\",\n  Iuml: \"\\u00CF\",\n  ETH: \"\\u00D0\",\n  Ntilde: \"\\u00D1\",\n  Ograve: \"\\u00D2\",\n  Oacute: \"\\u00D3\",\n  Ocirc: \"\\u00D4\",\n  Otilde: \"\\u00D5\",\n  Ouml: \"\\u00D6\",\n  times: \"\\u00D7\",\n  Oslash: \"\\u00D8\",\n  Ugrave: \"\\u00D9\",\n  Uacute: \"\\u00DA\",\n  Ucirc: \"\\u00DB\",\n  Uuml: \"\\u00DC\",\n  Yacute: \"\\u00DD\",\n  THORN: \"\\u00DE\",\n  szlig: \"\\u00DF\",\n  agrave: \"\\u00E0\",\n  aacute: \"\\u00E1\",\n  acirc: \"\\u00E2\",\n  atilde: \"\\u00E3\",\n  auml: \"\\u00E4\",\n  aring: \"\\u00E5\",\n  aelig: \"\\u00E6\",\n  ccedil: \"\\u00E7\",\n  egrave: \"\\u00E8\",\n  eacute: \"\\u00E9\",\n  ecirc: \"\\u00EA\",\n  euml: \"\\u00EB\",\n  igrave: \"\\u00EC\",\n  iacute: \"\\u00ED\",\n  icirc: \"\\u00EE\",\n  iuml: \"\\u00EF\",\n  eth: \"\\u00F0\",\n  ntilde: \"\\u00F1\",\n  ograve: \"\\u00F2\",\n  oacute: \"\\u00F3\",\n  ocirc: \"\\u00F4\",\n  otilde: \"\\u00F5\",\n  ouml: \"\\u00F6\",\n  divide: \"\\u00F7\",\n  oslash: \"\\u00F8\",\n  ugrave: \"\\u00F9\",\n  uacute: \"\\u00FA\",\n  ucirc: \"\\u00FB\",\n  uuml: \"\\u00FC\",\n  yacute: \"\\u00FD\",\n  thorn: \"\\u00FE\",\n  yuml: \"\\u00FF\",\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};\nconst JsxErrors = ParseErrorEnum`jsx`({\n  AttributeIsEmpty: \"JSX attributes must only be assigned a non-empty expression.\",\n  MissingClosingTagElement: ({\n    openingTagName\n  }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,\n  MissingClosingTagFragment: \"Expected corresponding JSX closing tag for <>.\",\n  UnexpectedSequenceExpression: \"Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?\",\n  UnexpectedToken: ({\n    unexpected,\n    HTMLEntity\n  }) => `Unexpected token \\`${unexpected}\\`. Did you mean \\`${HTMLEntity}\\` or \\`{'${unexpected}'}\\`?`,\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});\nfunction isFragment(object) {\n  return object ? object.type === \"JSXOpeningFragment\" || object.type === \"JSXClosingFragment\" : false;\n}\nfunction getQualifiedJSXName(object) {\n  if (object.type === \"JSXIdentifier\") {\n    return object.name;\n  }\n  if (object.type === \"JSXNamespacedName\") {\n    return object.namespace.name + \":\" + object.name.name;\n  }\n  if (object.type === \"JSXMemberExpression\") {\n    return getQualifiedJSXName(object.object) + \".\" + getQualifiedJSXName(object.property);\n  }\n  throw new Error(\"Node had unexpected type: \" + object.type);\n}\nvar jsx = superClass => class JSXParserMixin extends superClass {\n  jsxReadToken() {\n    let out = \"\";\n    let chunkStart = this.state.pos;\n    for (;;) {\n      if (this.state.pos >= this.length) {\n        throw this.raise(JsxErrors.UnterminatedJsxContent, this.state.startLoc);\n      }\n      const ch = this.input.charCodeAt(this.state.pos);\n      switch (ch) {\n        case 60:\n        case 123:\n          if (this.state.pos === this.state.start) {\n            if (ch === 60 && this.state.canStartJSXElement) {\n              ++this.state.pos;\n              this.finishToken(142);\n            } else {\n              super.getTokenFromCode(ch);\n            }\n            return;\n          }\n          out += this.input.slice(chunkStart, this.state.pos);\n          this.finishToken(141, out);\n          return;\n        case 38:\n          out += this.input.slice(chunkStart, this.state.pos);\n          out += this.jsxReadEntity();\n          chunkStart = this.state.pos;\n          break;\n        case 62:\n        case 125:\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  jsxReadNewLine(normalizeCRLF) {\n    const ch = this.input.charCodeAt(this.state.pos);\n    let out;\n    ++this.state.pos;\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    ++this.state.curLine;\n    this.state.lineStart = this.state.pos;\n    return out;\n  }\n  jsxReadString(quote) {\n    let out = \"\";\n    let chunkStart = ++this.state.pos;\n    for (;;) {\n      if (this.state.pos >= this.length) {\n        throw this.raise(Errors.UnterminatedString, this.state.startLoc);\n      }\n      const ch = this.input.charCodeAt(this.state.pos);\n      if (ch === quote) break;\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    out += this.input.slice(chunkStart, this.state.pos++);\n    this.finishToken(133, out);\n  }\n  jsxReadEntity() {\n    const startPos = ++this.state.pos;\n    if (this.codePointAtPos(this.state.pos) === 35) {\n      ++this.state.pos;\n      let radix = 10;\n      if (this.codePointAtPos(this.state.pos) === 120) {\n        radix = 16;\n        ++this.state.pos;\n      }\n      const codePoint = this.readInt(radix, undefined, false, \"bail\");\n      if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) {\n        ++this.state.pos;\n        return String.fromCodePoint(codePoint);\n      }\n    } else {\n      let count = 0;\n      let semi = false;\n      while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) === 59)) {\n        ++this.state.pos;\n      }\n      if (semi) {\n        const desc = this.input.slice(startPos, this.state.pos);\n        const entity = entities[desc];\n        ++this.state.pos;\n        if (entity) {\n          return entity;\n        }\n      }\n    }\n    this.state.pos = startPos;\n    return \"&\";\n  }\n  jsxReadWord() {\n    let ch;\n    const start = this.state.pos;\n    do {\n      ch = this.input.charCodeAt(++this.state.pos);\n    } while (isIdentifierChar(ch) || ch === 45);\n    this.finishToken(140, this.input.slice(start, this.state.pos));\n  }\n  jsxParseIdentifier() {\n    const node = this.startNode();\n    if (this.match(140)) {\n      node.name = this.state.value;\n    } else if (tokenIsKeyword(this.state.type)) {\n      node.name = tokenLabelName(this.state.type);\n    } else {\n      this.unexpected();\n    }\n    this.next();\n    return this.finishNode(node, \"JSXIdentifier\");\n  }\n  jsxParseNamespacedName() {\n    const startLoc = this.state.startLoc;\n    const name = this.jsxParseIdentifier();\n    if (!this.eat(14)) return name;\n    const node = this.startNodeAt(startLoc);\n    node.namespace = name;\n    node.name = this.jsxParseIdentifier();\n    return this.finishNode(node, \"JSXNamespacedName\");\n  }\n  jsxParseElementName() {\n    const startLoc = this.state.startLoc;\n    let node = this.jsxParseNamespacedName();\n    if (node.type === \"JSXNamespacedName\") {\n      return node;\n    }\n    while (this.eat(16)) {\n      const newNode = this.startNodeAt(startLoc);\n      newNode.object = node;\n      newNode.property = this.jsxParseIdentifier();\n      node = this.finishNode(newNode, \"JSXMemberExpression\");\n    }\n    return node;\n  }\n  jsxParseAttributeValue() {\n    let node;\n    switch (this.state.type) {\n      case 5:\n        node = this.startNode();\n        this.setContext(types.brace);\n        this.next();\n        node = this.jsxParseExpressionContainer(node, types.j_oTag);\n        if (node.expression.type === \"JSXEmptyExpression\") {\n          this.raise(JsxErrors.AttributeIsEmpty, node);\n        }\n        return node;\n      case 142:\n      case 133:\n        return this.parseExprAtom();\n      default:\n        throw this.raise(JsxErrors.UnsupportedJsxValue, this.state.startLoc);\n    }\n  }\n  jsxParseEmptyExpression() {\n    const node = this.startNodeAt(this.state.lastTokEndLoc);\n    return this.finishNodeAt(node, \"JSXEmptyExpression\", this.state.startLoc);\n  }\n  jsxParseSpreadChild(node) {\n    this.next();\n    node.expression = this.parseExpression();\n    this.setContext(types.j_expr);\n    this.state.canStartJSXElement = true;\n    this.expect(8);\n    return this.finishNode(node, \"JSXSpreadChild\");\n  }\n  jsxParseExpressionContainer(node, previousContext) {\n    if (this.match(8)) {\n      node.expression = this.jsxParseEmptyExpression();\n    } else {\n      const expression = this.parseExpression();\n      node.expression = expression;\n    }\n    this.setContext(previousContext);\n    this.state.canStartJSXElement = true;\n    this.expect(8);\n    return this.finishNode(node, \"JSXExpressionContainer\");\n  }\n  jsxParseAttribute() {\n    const node = this.startNode();\n    if (this.match(5)) {\n      this.setContext(types.brace);\n      this.next();\n      this.expect(21);\n      node.argument = this.parseMaybeAssignAllowIn();\n      this.setContext(types.j_oTag);\n      this.state.canStartJSXElement = true;\n      this.expect(8);\n      return this.finishNode(node, \"JSXSpreadAttribute\");\n    }\n    node.name = this.jsxParseNamespacedName();\n    node.value = this.eat(29) ? this.jsxParseAttributeValue() : null;\n    return this.finishNode(node, \"JSXAttribute\");\n  }\n  jsxParseOpeningElementAt(startLoc) {\n    const node = this.startNodeAt(startLoc);\n    if (this.eat(143)) {\n      return this.finishNode(node, \"JSXOpeningFragment\");\n    }\n    node.name = this.jsxParseElementName();\n    return this.jsxParseOpeningElementAfterName(node);\n  }\n  jsxParseOpeningElementAfterName(node) {\n    const attributes = [];\n    while (!this.match(56) && !this.match(143)) {\n      attributes.push(this.jsxParseAttribute());\n    }\n    node.attributes = attributes;\n    node.selfClosing = this.eat(56);\n    this.expect(143);\n    return this.finishNode(node, \"JSXOpeningElement\");\n  }\n  jsxParseClosingElementAt(startLoc) {\n    const node = this.startNodeAt(startLoc);\n    if (this.eat(143)) {\n      return this.finishNode(node, \"JSXClosingFragment\");\n    }\n    node.name = this.jsxParseElementName();\n    this.expect(143);\n    return this.finishNode(node, \"JSXClosingElement\");\n  }\n  jsxParseElementAt(startLoc) {\n    const node = this.startNodeAt(startLoc);\n    const children = [];\n    const openingElement = this.jsxParseOpeningElementAt(startLoc);\n    let closingElement = null;\n    if (!openingElement.selfClosing) {\n      contents: for (;;) {\n        switch (this.state.type) {\n          case 142:\n            startLoc = this.state.startLoc;\n            this.next();\n            if (this.eat(56)) {\n              closingElement = this.jsxParseClosingElementAt(startLoc);\n              break contents;\n            }\n            children.push(this.jsxParseElementAt(startLoc));\n            break;\n          case 141:\n            children.push(this.parseLiteral(this.state.value, \"JSXText\"));\n            break;\n          case 5:\n            {\n              const node = this.startNode();\n              this.setContext(types.brace);\n              this.next();\n              if (this.match(21)) {\n                children.push(this.jsxParseSpreadChild(node));\n              } else {\n                children.push(this.jsxParseExpressionContainer(node, types.j_expr));\n              }\n              break;\n            }\n          default:\n            this.unexpected();\n        }\n      }\n      if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {\n        this.raise(JsxErrors.MissingClosingTagFragment, closingElement);\n      } else if (!isFragment(openingElement) && isFragment(closingElement)) {\n        this.raise(JsxErrors.MissingClosingTagElement, closingElement, {\n          openingTagName: getQualifiedJSXName(openingElement.name)\n        });\n      } else if (!isFragment(openingElement) && !isFragment(closingElement)) {\n        if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {\n          this.raise(JsxErrors.MissingClosingTagElement, closingElement, {\n            openingTagName: 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    node.children = children;\n    if (this.match(47)) {\n      throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, this.state.startLoc);\n    }\n    return isFragment(openingElement) ? this.finishNode(node, \"JSXFragment\") : this.finishNode(node, \"JSXElement\");\n  }\n  jsxParseElement() {\n    const startLoc = this.state.startLoc;\n    this.next();\n    return this.jsxParseElementAt(startLoc);\n  }\n  setContext(newContext) {\n    const {\n      context\n    } = this.state;\n    context[context.length - 1] = newContext;\n  }\n  parseExprAtom(refExpressionErrors) {\n    if (this.match(142)) {\n      return this.jsxParseElement();\n    } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {\n      this.replaceToken(142);\n      return this.jsxParseElement();\n    } else {\n      return super.parseExprAtom(refExpressionErrors);\n    }\n  }\n  skipSpace() {\n    const curContext = this.curContext();\n    if (!curContext.preserveSpace) super.skipSpace();\n  }\n  getTokenFromCode(code) {\n    const context = this.curContext();\n    if (context === types.j_expr) {\n      this.jsxReadToken();\n      return;\n    }\n    if (context === types.j_oTag || context === types.j_cTag) {\n      if (isIdentifierStart(code)) {\n        this.jsxReadWord();\n        return;\n      }\n      if (code === 62) {\n        ++this.state.pos;\n        this.finishToken(143);\n        return;\n      }\n      if ((code === 34 || code === 39) && context === types.j_oTag) {\n        this.jsxReadString(code);\n        return;\n      }\n    }\n    if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {\n      ++this.state.pos;\n      this.finishToken(142);\n      return;\n    }\n    super.getTokenFromCode(code);\n  }\n  updateContext(prevType) {\n    const {\n      context,\n      type\n    } = this.state;\n    if (type === 56 && prevType === 142) {\n      context.splice(-2, 2, types.j_cTag);\n      this.state.canStartJSXElement = false;\n    } else if (type === 142) {\n      context.push(types.j_oTag);\n    } else if (type === 143) {\n      const out = context[context.length - 1];\n      if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) {\n        context.pop();\n        this.state.canStartJSXElement = context[context.length - 1] === types.j_expr;\n      } else {\n        this.setContext(types.j_expr);\n        this.state.canStartJSXElement = true;\n      }\n    } else {\n      this.state.canStartJSXElement = tokenComesBeforeExpression(type);\n    }\n  }\n};\nclass TypeScriptScope extends Scope {\n  constructor(...args) {\n    super(...args);\n    this.tsNames = new Map();\n  }\n}\nclass TypeScriptScopeHandler extends ScopeHandler {\n  constructor(...args) {\n    super(...args);\n    this.importsStack = [];\n  }\n  createScope(flags) {\n    this.importsStack.push(new Set());\n    return new TypeScriptScope(flags);\n  }\n  enter(flags) {\n    if (flags === 256) {\n      this.importsStack.push(new Set());\n    }\n    super.enter(flags);\n  }\n  exit() {\n    const flags = super.exit();\n    if (flags === 256) {\n      this.importsStack.pop();\n    }\n    return flags;\n  }\n  hasImport(name, allowShadow) {\n    const len = this.importsStack.length;\n    if (this.importsStack[len - 1].has(name)) {\n      return true;\n    }\n    if (!allowShadow && len > 1) {\n      for (let i = 0; i < len - 1; i++) {\n        if (this.importsStack[i].has(name)) return true;\n      }\n    }\n    return false;\n  }\n  declareName(name, bindingType, loc) {\n    if (bindingType & 4096) {\n      if (this.hasImport(name, true)) {\n        this.parser.raise(Errors.VarRedeclaration, loc, {\n          identifierName: name\n        });\n      }\n      this.importsStack[this.importsStack.length - 1].add(name);\n      return;\n    }\n    const scope = this.currentScope();\n    let type = scope.tsNames.get(name) || 0;\n    if (bindingType & 1024) {\n      this.maybeExportDefined(scope, name);\n      scope.tsNames.set(name, type | 16);\n      return;\n    }\n    super.declareName(name, bindingType, loc);\n    if (bindingType & 2) {\n      if (!(bindingType & 1)) {\n        this.checkRedeclarationInScope(scope, name, bindingType, loc);\n        this.maybeExportDefined(scope, name);\n      }\n      type = type | 1;\n    }\n    if (bindingType & 256) {\n      type = type | 2;\n    }\n    if (bindingType & 512) {\n      type = type | 4;\n    }\n    if (bindingType & 128) {\n      type = type | 8;\n    }\n    if (type) scope.tsNames.set(name, type);\n  }\n  isRedeclaredInScope(scope, name, bindingType) {\n    const type = scope.tsNames.get(name);\n    if ((type & 2) > 0) {\n      if (bindingType & 256) {\n        const isConst = !!(bindingType & 512);\n        const wasConst = (type & 4) > 0;\n        return isConst !== wasConst;\n      }\n      return true;\n    }\n    if (bindingType & 128 && (type & 8) > 0) {\n      if (scope.names.get(name) & 2) {\n        return !!(bindingType & 1);\n      } else {\n        return false;\n      }\n    }\n    if (bindingType & 2 && (type & 1) > 0) {\n      return true;\n    }\n    return super.isRedeclaredInScope(scope, name, bindingType);\n  }\n  checkLocalExport(id) {\n    const {\n      name\n    } = id;\n    if (this.hasImport(name)) return;\n    const len = this.scopeStack.length;\n    for (let i = len - 1; i >= 0; i--) {\n      const scope = this.scopeStack[i];\n      const type = scope.tsNames.get(name);\n      if ((type & 1) > 0 || (type & 16) > 0) {\n        return;\n      }\n    }\n    super.checkLocalExport(id);\n  }\n}\nconst unwrapParenthesizedExpression = node => {\n  return node.type === \"ParenthesizedExpression\" ? unwrapParenthesizedExpression(node.expression) : node;\n};\nclass LValParser extends NodeUtils {\n  toAssignable(node, isLHS = false) {\n    var _node$extra, _node$extra3;\n    let parenthesized = undefined;\n    if (node.type === \"ParenthesizedExpression\" || (_node$extra = node.extra) != null && _node$extra.parenthesized) {\n      parenthesized = unwrapParenthesizedExpression(node);\n      if (isLHS) {\n        if (parenthesized.type === \"Identifier\") {\n          this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, node);\n        } else if (parenthesized.type !== \"MemberExpression\" && !this.isOptionalMemberExpression(parenthesized)) {\n          this.raise(Errors.InvalidParenthesizedAssignment, node);\n        }\n      } else {\n        this.raise(Errors.InvalidParenthesizedAssignment, node);\n      }\n    }\n    switch (node.type) {\n      case \"Identifier\":\n      case \"ObjectPattern\":\n      case \"ArrayPattern\":\n      case \"AssignmentPattern\":\n      case \"RestElement\":\n        break;\n      case \"ObjectExpression\":\n        node.type = \"ObjectPattern\";\n        for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) {\n          var _node$extra2;\n          const prop = node.properties[i];\n          const isLast = i === last;\n          this.toAssignableObjectExpressionProp(prop, isLast, isLHS);\n          if (isLast && prop.type === \"RestElement\" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) {\n            this.raise(Errors.RestTrailingComma, node.extra.trailingCommaLoc);\n          }\n        }\n        break;\n      case \"ObjectProperty\":\n        {\n          const {\n            key,\n            value\n          } = node;\n          if (this.isPrivateName(key)) {\n            this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);\n          }\n          this.toAssignable(value, isLHS);\n          break;\n        }\n      case \"SpreadElement\":\n        {\n          throw new Error(\"Internal @babel/parser error (this is a bug, please report it).\" + \" SpreadElement should be converted by .toAssignable's caller.\");\n        }\n      case \"ArrayExpression\":\n        node.type = \"ArrayPattern\";\n        this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS);\n        break;\n      case \"AssignmentExpression\":\n        if (node.operator !== \"=\") {\n          this.raise(Errors.MissingEqInAssignment, node.left.loc.end);\n        }\n        node.type = \"AssignmentPattern\";\n        delete node.operator;\n        this.toAssignable(node.left, isLHS);\n        break;\n      case \"ParenthesizedExpression\":\n        this.toAssignable(parenthesized, isLHS);\n        break;\n    }\n  }\n  toAssignableObjectExpressionProp(prop, isLast, isLHS) {\n    if (prop.type === \"ObjectMethod\") {\n      this.raise(prop.kind === \"get\" || prop.kind === \"set\" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, prop.key);\n    } else if (prop.type === \"SpreadElement\") {\n      prop.type = \"RestElement\";\n      const arg = prop.argument;\n      this.checkToRestConversion(arg, false);\n      this.toAssignable(arg, isLHS);\n      if (!isLast) {\n        this.raise(Errors.RestTrailingComma, prop);\n      }\n    } else {\n      this.toAssignable(prop, isLHS);\n    }\n  }\n  toAssignableList(exprList, trailingCommaLoc, isLHS) {\n    const end = exprList.length - 1;\n    for (let i = 0; i <= end; i++) {\n      const elt = exprList[i];\n      if (!elt) continue;\n      if (elt.type === \"SpreadElement\") {\n        elt.type = \"RestElement\";\n        const arg = elt.argument;\n        this.checkToRestConversion(arg, true);\n        this.toAssignable(arg, isLHS);\n      } else {\n        this.toAssignable(elt, isLHS);\n      }\n      if (elt.type === \"RestElement\") {\n        if (i < end) {\n          this.raise(Errors.RestTrailingComma, elt);\n        } else if (trailingCommaLoc) {\n          this.raise(Errors.RestTrailingComma, trailingCommaLoc);\n        }\n      }\n    }\n  }\n  isAssignable(node, isBinding) {\n    switch (node.type) {\n      case \"Identifier\":\n      case \"ObjectPattern\":\n      case \"ArrayPattern\":\n      case \"AssignmentPattern\":\n      case \"RestElement\":\n        return true;\n      case \"ObjectExpression\":\n        {\n          const last = node.properties.length - 1;\n          return node.properties.every((prop, i) => {\n            return prop.type !== \"ObjectMethod\" && (i === last || prop.type !== \"SpreadElement\") && this.isAssignable(prop);\n          });\n        }\n      case \"ObjectProperty\":\n        return this.isAssignable(node.value);\n      case \"SpreadElement\":\n        return this.isAssignable(node.argument);\n      case \"ArrayExpression\":\n        return node.elements.every(element => element === null || this.isAssignable(element));\n      case \"AssignmentExpression\":\n        return node.operator === \"=\";\n      case \"ParenthesizedExpression\":\n        return this.isAssignable(node.expression);\n      case \"MemberExpression\":\n      case \"OptionalMemberExpression\":\n        return !isBinding;\n      default:\n        return false;\n    }\n  }\n  toReferencedList(exprList, isParenthesizedExpr) {\n    return exprList;\n  }\n  toReferencedListDeep(exprList, isParenthesizedExpr) {\n    this.toReferencedList(exprList, isParenthesizedExpr);\n    for (const expr of exprList) {\n      if ((expr == null ? void 0 : expr.type) === \"ArrayExpression\") {\n        this.toReferencedListDeep(expr.elements);\n      }\n    }\n  }\n  parseSpread(refExpressionErrors) {\n    const node = this.startNode();\n    this.next();\n    node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined);\n    return this.finishNode(node, \"SpreadElement\");\n  }\n  parseRestBinding() {\n    const node = this.startNode();\n    this.next();\n    node.argument = this.parseBindingAtom();\n    return this.finishNode(node, \"RestElement\");\n  }\n  parseBindingAtom() {\n    switch (this.state.type) {\n      case 0:\n        {\n          const node = this.startNode();\n          this.next();\n          node.elements = this.parseBindingList(3, 93, 1);\n          return this.finishNode(node, \"ArrayPattern\");\n        }\n      case 5:\n        return this.parseObjectLike(8, true);\n    }\n    return this.parseIdentifier();\n  }\n  parseBindingList(close, closeCharCode, flags) {\n    const allowEmpty = flags & 1;\n    const elts = [];\n    let first = true;\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(12);\n      }\n      if (allowEmpty && this.match(12)) {\n        elts.push(null);\n      } else if (this.eat(close)) {\n        break;\n      } else if (this.match(21)) {\n        elts.push(this.parseAssignableListItemTypes(this.parseRestBinding(), flags));\n        if (!this.checkCommaAfterRest(closeCharCode)) {\n          this.expect(close);\n          break;\n        }\n      } else {\n        const decorators = [];\n        if (this.match(26) && this.hasPlugin(\"decorators\")) {\n          this.raise(Errors.UnsupportedParameterDecorator, this.state.startLoc);\n        }\n        while (this.match(26)) {\n          decorators.push(this.parseDecorator());\n        }\n        elts.push(this.parseAssignableListItem(flags, decorators));\n      }\n    }\n    return elts;\n  }\n  parseBindingRestProperty(prop) {\n    this.next();\n    prop.argument = this.parseIdentifier();\n    this.checkCommaAfterRest(125);\n    return this.finishNode(prop, \"RestElement\");\n  }\n  parseBindingProperty() {\n    const {\n      type,\n      startLoc\n    } = this.state;\n    if (type === 21) {\n      return this.parseBindingRestProperty(this.startNode());\n    }\n    const prop = this.startNode();\n    if (type === 138) {\n      this.expectPlugin(\"destructuringPrivate\", startLoc);\n      this.classScope.usePrivateName(this.state.value, startLoc);\n      prop.key = this.parsePrivateName();\n    } else {\n      this.parsePropertyName(prop);\n    }\n    prop.method = false;\n    return this.parseObjPropValue(prop, startLoc, false, false, true, false);\n  }\n  parseAssignableListItem(flags, decorators) {\n    const left = this.parseMaybeDefault();\n    this.parseAssignableListItemTypes(left, flags);\n    const elt = this.parseMaybeDefault(left.loc.start, left);\n    if (decorators.length) {\n      left.decorators = decorators;\n    }\n    return elt;\n  }\n  parseAssignableListItemTypes(param, flags) {\n    return param;\n  }\n  parseMaybeDefault(startLoc, left) {\n    var _startLoc, _left;\n    (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;\n    left = (_left = left) != null ? _left : this.parseBindingAtom();\n    if (!this.eat(29)) return left;\n    const node = this.startNodeAt(startLoc);\n    node.left = left;\n    node.right = this.parseMaybeAssignAllowIn();\n    return this.finishNode(node, \"AssignmentPattern\");\n  }\n  isValidLVal(type, isUnparenthesizedInAssign, binding) {\n    switch (type) {\n      case \"AssignmentPattern\":\n        return \"left\";\n      case \"RestElement\":\n        return \"argument\";\n      case \"ObjectProperty\":\n        return \"value\";\n      case \"ParenthesizedExpression\":\n        return \"expression\";\n      case \"ArrayPattern\":\n        return \"elements\";\n      case \"ObjectPattern\":\n        return \"properties\";\n    }\n    return false;\n  }\n  isOptionalMemberExpression(expression) {\n    return expression.type === \"OptionalMemberExpression\";\n  }\n  checkLVal(expression, ancestor, binding = 64, checkClashes = false, strictModeChanged = false, hasParenthesizedAncestor = false) {\n    var _expression$extra;\n    const type = expression.type;\n    if (this.isObjectMethod(expression)) return;\n    const isOptionalMemberExpression = this.isOptionalMemberExpression(expression);\n    if (isOptionalMemberExpression || type === \"MemberExpression\") {\n      if (isOptionalMemberExpression) {\n        this.expectPlugin(\"optionalChainingAssign\", expression.loc.start);\n        if (ancestor.type !== \"AssignmentExpression\") {\n          this.raise(Errors.InvalidLhsOptionalChaining, expression, {\n            ancestor\n          });\n        }\n      }\n      if (binding !== 64) {\n        this.raise(Errors.InvalidPropertyBindingPattern, expression);\n      }\n      return;\n    }\n    if (type === \"Identifier\") {\n      this.checkIdentifier(expression, binding, strictModeChanged);\n      const {\n        name\n      } = expression;\n      if (checkClashes) {\n        if (checkClashes.has(name)) {\n          this.raise(Errors.ParamDupe, expression);\n        } else {\n          checkClashes.add(name);\n        }\n      }\n      return;\n    }\n    const validity = this.isValidLVal(type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === \"AssignmentExpression\", binding);\n    if (validity === true) return;\n    if (validity === false) {\n      const ParseErrorClass = binding === 64 ? Errors.InvalidLhs : Errors.InvalidLhsBinding;\n      this.raise(ParseErrorClass, expression, {\n        ancestor\n      });\n      return;\n    }\n    let key, isParenthesizedExpression;\n    if (typeof validity === \"string\") {\n      key = validity;\n      isParenthesizedExpression = type === \"ParenthesizedExpression\";\n    } else {\n      [key, isParenthesizedExpression] = validity;\n    }\n    const nextAncestor = type === \"ArrayPattern\" || type === \"ObjectPattern\" ? {\n      type\n    } : ancestor;\n    const val = expression[key];\n    if (Array.isArray(val)) {\n      for (const child of val) {\n        if (child) {\n          this.checkLVal(child, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression);\n        }\n      }\n    } else if (val) {\n      this.checkLVal(val, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression);\n    }\n  }\n  checkIdentifier(at, bindingType, strictModeChanged = false) {\n    if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) {\n      if (bindingType === 64) {\n        this.raise(Errors.StrictEvalArguments, at, {\n          referenceName: at.name\n        });\n      } else {\n        this.raise(Errors.StrictEvalArgumentsBinding, at, {\n          bindingName: at.name\n        });\n      }\n    }\n    if (bindingType & 8192 && at.name === \"let\") {\n      this.raise(Errors.LetInLexicalBinding, at);\n    }\n    if (!(bindingType & 64)) {\n      this.declareNameFromIdentifier(at, bindingType);\n    }\n  }\n  declareNameFromIdentifier(identifier, binding) {\n    this.scope.declareName(identifier.name, binding, identifier.loc.start);\n  }\n  checkToRestConversion(node, allowPattern) {\n    switch (node.type) {\n      case \"ParenthesizedExpression\":\n        this.checkToRestConversion(node.expression, allowPattern);\n        break;\n      case \"Identifier\":\n      case \"MemberExpression\":\n        break;\n      case \"ArrayExpression\":\n      case \"ObjectExpression\":\n        if (allowPattern) break;\n      default:\n        this.raise(Errors.InvalidRestAssignmentPattern, node);\n    }\n  }\n  checkCommaAfterRest(close) {\n    if (!this.match(12)) {\n      return false;\n    }\n    this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, this.state.startLoc);\n    return true;\n  }\n}\nfunction nonNull(x) {\n  if (x == null) {\n    throw new Error(`Unexpected ${x} value.`);\n  }\n  return x;\n}\nfunction assert(x) {\n  if (!x) {\n    throw new Error(\"Assert fail\");\n  }\n}\nconst TSErrors = ParseErrorEnum`typescript`({\n  AbstractMethodHasImplementation: ({\n    methodName\n  }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,\n  AbstractPropertyHasInitializer: ({\n    propertyName\n  }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,\n  AccessorCannotBeOptional: \"An 'accessor' property cannot be declared optional.\",\n  AccessorCannotDeclareThisParameter: \"'get' and 'set' accessors cannot declare 'this' parameters.\",\n  AccessorCannotHaveTypeParameters: \"An accessor cannot have type parameters.\",\n  ClassMethodHasDeclare: \"Class methods cannot have the 'declare' modifier.\",\n  ClassMethodHasReadonly: \"Class methods cannot have the 'readonly' modifier.\",\n  ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: \"A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.\",\n  ConstructorHasTypeParameters: \"Type parameters cannot appear on a constructor declaration.\",\n  DeclareAccessor: ({\n    kind\n  }) => `'declare' is not allowed in ${kind}ters.`,\n  DeclareClassFieldHasInitializer: \"Initializers are not allowed in ambient contexts.\",\n  DeclareFunctionHasImplementation: \"An implementation cannot be declared in ambient contexts.\",\n  DuplicateAccessibilityModifier: ({\n    modifier\n  }) => `Accessibility modifier already seen.`,\n  DuplicateModifier: ({\n    modifier\n  }) => `Duplicate modifier: '${modifier}'.`,\n  EmptyHeritageClauseType: ({\n    token\n  }) => `'${token}' list cannot be empty.`,\n  EmptyTypeArguments: \"Type argument list cannot be empty.\",\n  EmptyTypeParameters: \"Type parameter list cannot be empty.\",\n  ExpectedAmbientAfterExportDeclare: \"'export declare' must be followed by an ambient declaration.\",\n  ImportAliasHasImportType: \"An import alias can not use 'import type'.\",\n  ImportReflectionHasImportType: \"An `import module` declaration can not use `type` modifier\",\n  IncompatibleModifiers: ({\n    modifiers\n  }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,\n  IndexSignatureHasAbstract: \"Index signatures cannot have the 'abstract' modifier.\",\n  IndexSignatureHasAccessibility: ({\n    modifier\n  }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,\n  IndexSignatureHasDeclare: \"Index signatures cannot have the 'declare' modifier.\",\n  IndexSignatureHasOverride: \"'override' modifier cannot appear on an index signature.\",\n  IndexSignatureHasStatic: \"Index signatures cannot have the 'static' modifier.\",\n  InitializerNotAllowedInAmbientContext: \"Initializers are not allowed in ambient contexts.\",\n  InvalidModifierOnTypeMember: ({\n    modifier\n  }) => `'${modifier}' modifier cannot appear on a type member.`,\n  InvalidModifierOnTypeParameter: ({\n    modifier\n  }) => `'${modifier}' modifier cannot appear on a type parameter.`,\n  InvalidModifierOnTypeParameterPositions: ({\n    modifier\n  }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,\n  InvalidModifiersOrder: ({\n    orderedModifiers\n  }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,\n  InvalidPropertyAccessAfterInstantiationExpression: \"Invalid property access after an instantiation expression. \" + \"You can either wrap the instantiation expression in parentheses, or delete the type arguments.\",\n  InvalidTupleMemberLabel: \"Tuple members must be labeled with a simple identifier.\",\n  MissingInterfaceName: \"'interface' declarations must be followed by an identifier.\",\n  NonAbstractClassHasAbstractMethod: \"Abstract methods can only appear within an abstract class.\",\n  NonClassMethodPropertyHasAbstractModifer: \"'abstract' modifier can only appear on a class, method, or property declaration.\",\n  OptionalTypeBeforeRequired: \"A required element cannot follow an optional element.\",\n  OverrideNotInSubClass: \"This member cannot have an 'override' modifier because its containing class does not extend another class.\",\n  PatternIsOptional: \"A binding pattern parameter cannot be optional in an implementation signature.\",\n  PrivateElementHasAbstract: \"Private elements cannot have the 'abstract' modifier.\",\n  PrivateElementHasAccessibility: ({\n    modifier\n  }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,\n  ReadonlyForMethodSignature: \"'readonly' modifier can only appear on a property declaration or index signature.\",\n  ReservedArrowTypeParam: \"This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.\",\n  ReservedTypeAssertion: \"This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.\",\n  SetAccessorCannotHaveOptionalParameter: \"A 'set' accessor cannot have an optional parameter.\",\n  SetAccessorCannotHaveRestParameter: \"A 'set' accessor cannot have rest parameter.\",\n  SetAccessorCannotHaveReturnType: \"A 'set' accessor cannot have a return type annotation.\",\n  SingleTypeParameterWithoutTrailingComma: ({\n    typeParameterName\n  }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,\n  StaticBlockCannotHaveModifier: \"Static class blocks cannot have any modifier.\",\n  TupleOptionalAfterType: \"A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).\",\n  TypeAnnotationAfterAssign: \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.\",\n  TypeImportCannotSpecifyDefaultAndNamed: \"A type-only import can specify a default import or named bindings, but not both.\",\n  TypeModifierIsUsedInTypeExports: \"The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.\",\n  TypeModifierIsUsedInTypeImports: \"The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.\",\n  UnexpectedParameterModifier: \"A parameter property is only allowed in a constructor implementation.\",\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: ({\n    type\n  }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`\n});\nfunction keywordTypeFromName(value) {\n  switch (value) {\n    case \"any\":\n      return \"TSAnyKeyword\";\n    case \"boolean\":\n      return \"TSBooleanKeyword\";\n    case \"bigint\":\n      return \"TSBigIntKeyword\";\n    case \"never\":\n      return \"TSNeverKeyword\";\n    case \"number\":\n      return \"TSNumberKeyword\";\n    case \"object\":\n      return \"TSObjectKeyword\";\n    case \"string\":\n      return \"TSStringKeyword\";\n    case \"symbol\":\n      return \"TSSymbolKeyword\";\n    case \"undefined\":\n      return \"TSUndefinedKeyword\";\n    case \"unknown\":\n      return \"TSUnknownKeyword\";\n    default:\n      return undefined;\n  }\n}\nfunction tsIsAccessModifier(modifier) {\n  return modifier === \"private\" || modifier === \"public\" || modifier === \"protected\";\n}\nfunction tsIsVarianceAnnotations(modifier) {\n  return modifier === \"in\" || modifier === \"out\";\n}\nvar typescript = superClass => class TypeScriptParserMixin extends superClass {\n  constructor(...args) {\n    super(...args);\n    this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"in\", \"out\"],\n      disallowedModifiers: [\"const\", \"public\", \"private\", \"protected\", \"readonly\", \"declare\", \"abstract\", \"override\"],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameter\n    });\n    this.tsParseConstModifier = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"const\"],\n      disallowedModifiers: [\"in\", \"out\"],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions\n    });\n    this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"in\", \"out\", \"const\"],\n      disallowedModifiers: [\"public\", \"private\", \"protected\", \"readonly\", \"declare\", \"abstract\", \"override\"],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameter\n    });\n  }\n  getScopeHandler() {\n    return TypeScriptScopeHandler;\n  }\n  tsIsIdentifier() {\n    return tokenIsIdentifier(this.state.type);\n  }\n  tsTokenCanFollowModifier() {\n    return this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(138) || this.isLiteralPropertyName();\n  }\n  tsNextTokenOnSameLineAndCanFollowModifier() {\n    this.next();\n    if (this.hasPrecedingLineBreak()) {\n      return false;\n    }\n    return this.tsTokenCanFollowModifier();\n  }\n  tsNextTokenCanFollowModifier() {\n    if (this.match(106)) {\n      this.next();\n      return this.tsTokenCanFollowModifier();\n    }\n    return this.tsNextTokenOnSameLineAndCanFollowModifier();\n  }\n  tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {\n    if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {\n      return undefined;\n    }\n    const modifier = this.state.value;\n    if (allowedModifiers.includes(modifier)) {\n      if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {\n        return undefined;\n      }\n      if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {\n        return modifier;\n      }\n    }\n    return undefined;\n  }\n  tsParseModifiers({\n    allowedModifiers,\n    disallowedModifiers,\n    stopOnStartOfClassStaticBlock,\n    errorTemplate = TSErrors.InvalidModifierOnTypeMember\n  }, modified) {\n    const enforceOrder = (loc, modifier, before, after) => {\n      if (modifier === before && modified[after]) {\n        this.raise(TSErrors.InvalidModifiersOrder, loc, {\n          orderedModifiers: [before, after]\n        });\n      }\n    };\n    const incompatible = (loc, modifier, mod1, mod2) => {\n      if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {\n        this.raise(TSErrors.IncompatibleModifiers, loc, {\n          modifiers: [mod1, mod2]\n        });\n      }\n    };\n    for (;;) {\n      const {\n        startLoc\n      } = this.state;\n      const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock);\n      if (!modifier) break;\n      if (tsIsAccessModifier(modifier)) {\n        if (modified.accessibility) {\n          this.raise(TSErrors.DuplicateAccessibilityModifier, startLoc, {\n            modifier\n          });\n        } else {\n          enforceOrder(startLoc, modifier, modifier, \"override\");\n          enforceOrder(startLoc, modifier, modifier, \"static\");\n          enforceOrder(startLoc, modifier, modifier, \"readonly\");\n          modified.accessibility = modifier;\n        }\n      } else if (tsIsVarianceAnnotations(modifier)) {\n        if (modified[modifier]) {\n          this.raise(TSErrors.DuplicateModifier, startLoc, {\n            modifier\n          });\n        }\n        modified[modifier] = true;\n        enforceOrder(startLoc, modifier, \"in\", \"out\");\n      } else {\n        if (hasOwnProperty.call(modified, modifier)) {\n          this.raise(TSErrors.DuplicateModifier, startLoc, {\n            modifier\n          });\n        } else {\n          enforceOrder(startLoc, modifier, \"static\", \"readonly\");\n          enforceOrder(startLoc, modifier, \"static\", \"override\");\n          enforceOrder(startLoc, modifier, \"override\", \"readonly\");\n          enforceOrder(startLoc, modifier, \"abstract\", \"override\");\n          incompatible(startLoc, modifier, \"declare\", \"override\");\n          incompatible(startLoc, modifier, \"static\", \"abstract\");\n        }\n        modified[modifier] = true;\n      }\n      if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {\n        this.raise(errorTemplate, startLoc, {\n          modifier\n        });\n      }\n    }\n  }\n  tsIsListTerminator(kind) {\n    switch (kind) {\n      case \"EnumMembers\":\n      case \"TypeMembers\":\n        return this.match(8);\n      case \"HeritageClauseElement\":\n        return this.match(5);\n      case \"TupleElementTypes\":\n        return this.match(3);\n      case \"TypeParametersOrArguments\":\n        return this.match(48);\n    }\n  }\n  tsParseList(kind, parseElement) {\n    const result = [];\n    while (!this.tsIsListTerminator(kind)) {\n      result.push(parseElement());\n    }\n    return result;\n  }\n  tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) {\n    return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos));\n  }\n  tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) {\n    const result = [];\n    let trailingCommaPos = -1;\n    for (;;) {\n      if (this.tsIsListTerminator(kind)) {\n        break;\n      }\n      trailingCommaPos = -1;\n      const element = parseElement();\n      if (element == null) {\n        return undefined;\n      }\n      result.push(element);\n      if (this.eat(12)) {\n        trailingCommaPos = this.state.lastTokStartLoc.index;\n        continue;\n      }\n      if (this.tsIsListTerminator(kind)) {\n        break;\n      }\n      if (expectSuccess) {\n        this.expect(12);\n      }\n      return undefined;\n    }\n    if (refTrailingCommaPos) {\n      refTrailingCommaPos.value = trailingCommaPos;\n    }\n    return result;\n  }\n  tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) {\n    if (!skipFirstToken) {\n      if (bracket) {\n        this.expect(0);\n      } else {\n        this.expect(47);\n      }\n    }\n    const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);\n    if (bracket) {\n      this.expect(3);\n    } else {\n      this.expect(48);\n    }\n    return result;\n  }\n  tsParseImportType() {\n    const node = this.startNode();\n    this.expect(83);\n    this.expect(10);\n    if (!this.match(133)) {\n      this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);\n    }\n    node.argument = super.parseExprAtom();\n    if (this.hasPlugin(\"importAttributes\") || this.hasPlugin(\"importAssertions\")) {\n      node.options = null;\n    }\n    if (this.eat(12)) {\n      this.expectImportAttributesPlugin();\n      if (!this.match(11)) {\n        node.options = super.parseMaybeAssignAllowIn();\n        this.eat(12);\n      }\n    }\n    this.expect(11);\n    if (this.eat(16)) {\n      node.qualifier = this.tsParseEntityName();\n    }\n    if (this.match(47)) {\n      node.typeParameters = this.tsParseTypeArguments();\n    }\n    return this.finishNode(node, \"TSImportType\");\n  }\n  tsParseEntityName(allowReservedWords = true) {\n    let entity = this.parseIdentifier(allowReservedWords);\n    while (this.eat(16)) {\n      const node = this.startNodeAtNode(entity);\n      node.left = entity;\n      node.right = this.parseIdentifier(allowReservedWords);\n      entity = this.finishNode(node, \"TSQualifiedName\");\n    }\n    return entity;\n  }\n  tsParseTypeReference() {\n    const node = this.startNode();\n    node.typeName = this.tsParseEntityName();\n    if (!this.hasPrecedingLineBreak() && this.match(47)) {\n      node.typeParameters = this.tsParseTypeArguments();\n    }\n    return this.finishNode(node, \"TSTypeReference\");\n  }\n  tsParseThisTypePredicate(lhs) {\n    this.next();\n    const node = this.startNodeAtNode(lhs);\n    node.parameterName = lhs;\n    node.typeAnnotation = this.tsParseTypeAnnotation(false);\n    node.asserts = false;\n    return this.finishNode(node, \"TSTypePredicate\");\n  }\n  tsParseThisTypeNode() {\n    const node = this.startNode();\n    this.next();\n    return this.finishNode(node, \"TSThisType\");\n  }\n  tsParseTypeQuery() {\n    const node = this.startNode();\n    this.expect(87);\n    if (this.match(83)) {\n      node.exprName = this.tsParseImportType();\n    } else {\n      node.exprName = this.tsParseEntityName();\n    }\n    if (!this.hasPrecedingLineBreak() && this.match(47)) {\n      node.typeParameters = this.tsParseTypeArguments();\n    }\n    return this.finishNode(node, \"TSTypeQuery\");\n  }\n  tsParseTypeParameter(parseModifiers) {\n    const node = this.startNode();\n    parseModifiers(node);\n    node.name = this.tsParseTypeParameterName();\n    node.constraint = this.tsEatThenParseType(81);\n    node.default = this.tsEatThenParseType(29);\n    return this.finishNode(node, \"TSTypeParameter\");\n  }\n  tsTryParseTypeParameters(parseModifiers) {\n    if (this.match(47)) {\n      return this.tsParseTypeParameters(parseModifiers);\n    }\n  }\n  tsParseTypeParameters(parseModifiers) {\n    const node = this.startNode();\n    if (this.match(47) || this.match(142)) {\n      this.next();\n    } else {\n      this.unexpected();\n    }\n    const refTrailingCommaPos = {\n      value: -1\n    };\n    node.params = this.tsParseBracketedList(\"TypeParametersOrArguments\", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);\n    if (node.params.length === 0) {\n      this.raise(TSErrors.EmptyTypeParameters, node);\n    }\n    if (refTrailingCommaPos.value !== -1) {\n      this.addExtra(node, \"trailingComma\", refTrailingCommaPos.value);\n    }\n    return this.finishNode(node, \"TSTypeParameterDeclaration\");\n  }\n  tsFillSignature(returnToken, signature) {\n    const returnTokenRequired = returnToken === 19;\n    const paramsKey = \"parameters\";\n    const returnTypeKey = \"typeAnnotation\";\n    signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);\n    this.expect(10);\n    signature[paramsKey] = this.tsParseBindingListForSignature();\n    if (returnTokenRequired) {\n      signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n    } else if (this.match(returnToken)) {\n      signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n    }\n  }\n  tsParseBindingListForSignature() {\n    const list = super.parseBindingList(11, 41, 2);\n    for (const pattern of list) {\n      const {\n        type\n      } = pattern;\n      if (type === \"AssignmentPattern\" || type === \"TSParameterProperty\") {\n        this.raise(TSErrors.UnsupportedSignatureParameterKind, pattern, {\n          type\n        });\n      }\n    }\n    return list;\n  }\n  tsParseTypeMemberSemicolon() {\n    if (!this.eat(12) && !this.isLineTerminator()) {\n      this.expect(13);\n    }\n  }\n  tsParseSignatureMember(kind, node) {\n    this.tsFillSignature(14, node);\n    this.tsParseTypeMemberSemicolon();\n    return this.finishNode(node, kind);\n  }\n  tsIsUnambiguouslyIndexSignature() {\n    this.next();\n    if (tokenIsIdentifier(this.state.type)) {\n      this.next();\n      return this.match(14);\n    }\n    return false;\n  }\n  tsTryParseIndexSignature(node) {\n    if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {\n      return;\n    }\n    this.expect(0);\n    const id = this.parseIdentifier();\n    id.typeAnnotation = this.tsParseTypeAnnotation();\n    this.resetEndLocation(id);\n    this.expect(3);\n    node.parameters = [id];\n    const type = this.tsTryParseTypeAnnotation();\n    if (type) node.typeAnnotation = type;\n    this.tsParseTypeMemberSemicolon();\n    return this.finishNode(node, \"TSIndexSignature\");\n  }\n  tsParsePropertyOrMethodSignature(node, readonly) {\n    if (this.eat(17)) node.optional = true;\n    const nodeAny = node;\n    if (this.match(10) || this.match(47)) {\n      if (readonly) {\n        this.raise(TSErrors.ReadonlyForMethodSignature, node);\n      }\n      const method = nodeAny;\n      if (method.kind && this.match(47)) {\n        this.raise(TSErrors.AccessorCannotHaveTypeParameters, this.state.curPosition());\n      }\n      this.tsFillSignature(14, method);\n      this.tsParseTypeMemberSemicolon();\n      const paramsKey = \"parameters\";\n      const returnTypeKey = \"typeAnnotation\";\n      if (method.kind === \"get\") {\n        if (method[paramsKey].length > 0) {\n          this.raise(Errors.BadGetterArity, this.state.curPosition());\n          if (this.isThisParam(method[paramsKey][0])) {\n            this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());\n          }\n        }\n      } else if (method.kind === \"set\") {\n        if (method[paramsKey].length !== 1) {\n          this.raise(Errors.BadSetterArity, this.state.curPosition());\n        } else {\n          const firstParameter = method[paramsKey][0];\n          if (this.isThisParam(firstParameter)) {\n            this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());\n          }\n          if (firstParameter.type === \"Identifier\" && firstParameter.optional) {\n            this.raise(TSErrors.SetAccessorCannotHaveOptionalParameter, this.state.curPosition());\n          }\n          if (firstParameter.type === \"RestElement\") {\n            this.raise(TSErrors.SetAccessorCannotHaveRestParameter, this.state.curPosition());\n          }\n        }\n        if (method[returnTypeKey]) {\n          this.raise(TSErrors.SetAccessorCannotHaveReturnType, method[returnTypeKey]);\n        }\n      } else {\n        method.kind = \"method\";\n      }\n      return this.finishNode(method, \"TSMethodSignature\");\n    } else {\n      const property = nodeAny;\n      if (readonly) property.readonly = true;\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) property.typeAnnotation = type;\n      this.tsParseTypeMemberSemicolon();\n      return this.finishNode(property, \"TSPropertySignature\");\n    }\n  }\n  tsParseTypeMember() {\n    const node = this.startNode();\n    if (this.match(10) || this.match(47)) {\n      return this.tsParseSignatureMember(\"TSCallSignatureDeclaration\", node);\n    }\n    if (this.match(77)) {\n      const id = this.startNode();\n      this.next();\n      if (this.match(10) || this.match(47)) {\n        return this.tsParseSignatureMember(\"TSConstructSignatureDeclaration\", node);\n      } else {\n        node.key = this.createIdentifier(id, \"new\");\n        return this.tsParsePropertyOrMethodSignature(node, false);\n      }\n    }\n    this.tsParseModifiers({\n      allowedModifiers: [\"readonly\"],\n      disallowedModifiers: [\"declare\", \"abstract\", \"private\", \"protected\", \"public\", \"static\", \"override\"]\n    }, node);\n    const idx = this.tsTryParseIndexSignature(node);\n    if (idx) {\n      return idx;\n    }\n    super.parsePropertyName(node);\n    if (!node.computed && node.key.type === \"Identifier\" && (node.key.name === \"get\" || node.key.name === \"set\") && this.tsTokenCanFollowModifier()) {\n      node.kind = node.key.name;\n      super.parsePropertyName(node);\n    }\n    return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);\n  }\n  tsParseTypeLiteral() {\n    const node = this.startNode();\n    node.members = this.tsParseObjectTypeMembers();\n    return this.finishNode(node, \"TSTypeLiteral\");\n  }\n  tsParseObjectTypeMembers() {\n    this.expect(5);\n    const members = this.tsParseList(\"TypeMembers\", this.tsParseTypeMember.bind(this));\n    this.expect(8);\n    return members;\n  }\n  tsIsStartOfMappedType() {\n    this.next();\n    if (this.eat(53)) {\n      return this.isContextual(122);\n    }\n    if (this.isContextual(122)) {\n      this.next();\n    }\n    if (!this.match(0)) {\n      return false;\n    }\n    this.next();\n    if (!this.tsIsIdentifier()) {\n      return false;\n    }\n    this.next();\n    return this.match(58);\n  }\n  tsParseMappedType() {\n    const node = this.startNode();\n    this.expect(5);\n    if (this.match(53)) {\n      node.readonly = this.state.value;\n      this.next();\n      this.expectContextual(122);\n    } else if (this.eatContextual(122)) {\n      node.readonly = true;\n    }\n    this.expect(0);\n    {\n      const typeParameter = this.startNode();\n      typeParameter.name = this.tsParseTypeParameterName();\n      typeParameter.constraint = this.tsExpectThenParseType(58);\n      node.typeParameter = this.finishNode(typeParameter, \"TSTypeParameter\");\n    }\n    node.nameType = this.eatContextual(93) ? this.tsParseType() : null;\n    this.expect(3);\n    if (this.match(53)) {\n      node.optional = this.state.value;\n      this.next();\n      this.expect(17);\n    } else if (this.eat(17)) {\n      node.optional = true;\n    }\n    node.typeAnnotation = this.tsTryParseType();\n    this.semicolon();\n    this.expect(8);\n    return this.finishNode(node, \"TSMappedType\");\n  }\n  tsParseTupleType() {\n    const node = this.startNode();\n    node.elementTypes = this.tsParseBracketedList(\"TupleElementTypes\", this.tsParseTupleElementType.bind(this), true, false);\n    let seenOptionalElement = false;\n    node.elementTypes.forEach(elementNode => {\n      const {\n        type\n      } = elementNode;\n      if (seenOptionalElement && type !== \"TSRestType\" && type !== \"TSOptionalType\" && !(type === \"TSNamedTupleMember\" && elementNode.optional)) {\n        this.raise(TSErrors.OptionalTypeBeforeRequired, elementNode);\n      }\n      seenOptionalElement || (seenOptionalElement = type === \"TSNamedTupleMember\" && elementNode.optional || type === \"TSOptionalType\");\n    });\n    return this.finishNode(node, \"TSTupleType\");\n  }\n  tsParseTupleElementType() {\n    const {\n      startLoc\n    } = this.state;\n    const rest = this.eat(21);\n    let labeled;\n    let label;\n    let optional;\n    let type;\n    const isWord = tokenIsKeywordOrIdentifier(this.state.type);\n    const chAfterWord = isWord ? this.lookaheadCharCode() : null;\n    if (chAfterWord === 58) {\n      labeled = true;\n      optional = false;\n      label = this.parseIdentifier(true);\n      this.expect(14);\n      type = this.tsParseType();\n    } else if (chAfterWord === 63) {\n      optional = true;\n      const startLoc = this.state.startLoc;\n      const wordName = this.state.value;\n      const typeOrLabel = this.tsParseNonArrayType();\n      if (this.lookaheadCharCode() === 58) {\n        labeled = true;\n        label = this.createIdentifier(this.startNodeAt(startLoc), wordName);\n        this.expect(17);\n        this.expect(14);\n        type = this.tsParseType();\n      } else {\n        labeled = false;\n        type = typeOrLabel;\n        this.expect(17);\n      }\n    } else {\n      type = this.tsParseType();\n      optional = this.eat(17);\n      labeled = this.eat(14);\n    }\n    if (labeled) {\n      let labeledNode;\n      if (label) {\n        labeledNode = this.startNodeAtNode(label);\n        labeledNode.optional = optional;\n        labeledNode.label = label;\n        labeledNode.elementType = type;\n        if (this.eat(17)) {\n          labeledNode.optional = true;\n          this.raise(TSErrors.TupleOptionalAfterType, this.state.lastTokStartLoc);\n        }\n      } else {\n        labeledNode = this.startNodeAtNode(type);\n        labeledNode.optional = optional;\n        this.raise(TSErrors.InvalidTupleMemberLabel, type);\n        labeledNode.label = type;\n        labeledNode.elementType = this.tsParseType();\n      }\n      type = this.finishNode(labeledNode, \"TSNamedTupleMember\");\n    } else if (optional) {\n      const optionalTypeNode = this.startNodeAtNode(type);\n      optionalTypeNode.typeAnnotation = type;\n      type = this.finishNode(optionalTypeNode, \"TSOptionalType\");\n    }\n    if (rest) {\n      const restNode = this.startNodeAt(startLoc);\n      restNode.typeAnnotation = type;\n      type = this.finishNode(restNode, \"TSRestType\");\n    }\n    return type;\n  }\n  tsParseParenthesizedType() {\n    const node = this.startNode();\n    this.expect(10);\n    node.typeAnnotation = this.tsParseType();\n    this.expect(11);\n    return this.finishNode(node, \"TSParenthesizedType\");\n  }\n  tsParseFunctionOrConstructorType(type, abstract) {\n    const node = this.startNode();\n    if (type === \"TSConstructorType\") {\n      node.abstract = !!abstract;\n      if (abstract) this.next();\n      this.next();\n    }\n    this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));\n    return this.finishNode(node, type);\n  }\n  tsParseLiteralTypeNode() {\n    const node = this.startNode();\n    switch (this.state.type) {\n      case 134:\n      case 135:\n      case 133:\n      case 85:\n      case 86:\n        node.literal = super.parseExprAtom();\n        break;\n      default:\n        this.unexpected();\n    }\n    return this.finishNode(node, \"TSLiteralType\");\n  }\n  tsParseTemplateLiteralType() {\n    const node = this.startNode();\n    node.literal = super.parseTemplate(false);\n    return this.finishNode(node, \"TSLiteralType\");\n  }\n  parseTemplateSubstitution() {\n    if (this.state.inType) return this.tsParseType();\n    return super.parseTemplateSubstitution();\n  }\n  tsParseThisTypeOrThisTypePredicate() {\n    const thisKeyword = this.tsParseThisTypeNode();\n    if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {\n      return this.tsParseThisTypePredicate(thisKeyword);\n    } else {\n      return thisKeyword;\n    }\n  }\n  tsParseNonArrayType() {\n    switch (this.state.type) {\n      case 133:\n      case 134:\n      case 135:\n      case 85:\n      case 86:\n        return this.tsParseLiteralTypeNode();\n      case 53:\n        if (this.state.value === \"-\") {\n          const node = this.startNode();\n          const nextToken = this.lookahead();\n          if (nextToken.type !== 134 && nextToken.type !== 135) {\n            this.unexpected();\n          }\n          node.literal = this.parseMaybeUnary();\n          return this.finishNode(node, \"TSLiteralType\");\n        }\n        break;\n      case 78:\n        return this.tsParseThisTypeOrThisTypePredicate();\n      case 87:\n        return this.tsParseTypeQuery();\n      case 83:\n        return this.tsParseImportType();\n      case 5:\n        return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();\n      case 0:\n        return this.tsParseTupleType();\n      case 10:\n        return this.tsParseParenthesizedType();\n      case 25:\n      case 24:\n        return this.tsParseTemplateLiteralType();\n      default:\n        {\n          const {\n            type\n          } = this.state;\n          if (tokenIsIdentifier(type) || type === 88 || type === 84) {\n            const nodeType = type === 88 ? \"TSVoidKeyword\" : type === 84 ? \"TSNullKeyword\" : keywordTypeFromName(this.state.value);\n            if (nodeType !== undefined && this.lookaheadCharCode() !== 46) {\n              const node = this.startNode();\n              this.next();\n              return this.finishNode(node, nodeType);\n            }\n            return this.tsParseTypeReference();\n          }\n        }\n    }\n    this.unexpected();\n  }\n  tsParseArrayTypeOrHigher() {\n    let type = this.tsParseNonArrayType();\n    while (!this.hasPrecedingLineBreak() && this.eat(0)) {\n      if (this.match(3)) {\n        const node = this.startNodeAtNode(type);\n        node.elementType = type;\n        this.expect(3);\n        type = this.finishNode(node, \"TSArrayType\");\n      } else {\n        const node = this.startNodeAtNode(type);\n        node.objectType = type;\n        node.indexType = this.tsParseType();\n        this.expect(3);\n        type = this.finishNode(node, \"TSIndexedAccessType\");\n      }\n    }\n    return type;\n  }\n  tsParseTypeOperator() {\n    const node = this.startNode();\n    const operator = this.state.value;\n    this.next();\n    node.operator = operator;\n    node.typeAnnotation = this.tsParseTypeOperatorOrHigher();\n    if (operator === \"readonly\") {\n      this.tsCheckTypeAnnotationForReadOnly(node);\n    }\n    return this.finishNode(node, \"TSTypeOperator\");\n  }\n  tsCheckTypeAnnotationForReadOnly(node) {\n    switch (node.typeAnnotation.type) {\n      case \"TSTupleType\":\n      case \"TSArrayType\":\n        return;\n      default:\n        this.raise(TSErrors.UnexpectedReadonly, node);\n    }\n  }\n  tsParseInferType() {\n    const node = this.startNode();\n    this.expectContextual(115);\n    const typeParameter = this.startNode();\n    typeParameter.name = this.tsParseTypeParameterName();\n    typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());\n    node.typeParameter = this.finishNode(typeParameter, \"TSTypeParameter\");\n    return this.finishNode(node, \"TSInferType\");\n  }\n  tsParseConstraintForInferType() {\n    if (this.eat(81)) {\n      const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());\n      if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {\n        return constraint;\n      }\n    }\n  }\n  tsParseTypeOperatorOrHigher() {\n    const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;\n    return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(115) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());\n  }\n  tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {\n    const node = this.startNode();\n    const hasLeadingOperator = this.eat(operator);\n    const types = [];\n    do {\n      types.push(parseConstituentType());\n    } while (this.eat(operator));\n    if (types.length === 1 && !hasLeadingOperator) {\n      return types[0];\n    }\n    node.types = types;\n    return this.finishNode(node, kind);\n  }\n  tsParseIntersectionTypeOrHigher() {\n    return this.tsParseUnionOrIntersectionType(\"TSIntersectionType\", this.tsParseTypeOperatorOrHigher.bind(this), 45);\n  }\n  tsParseUnionTypeOrHigher() {\n    return this.tsParseUnionOrIntersectionType(\"TSUnionType\", this.tsParseIntersectionTypeOrHigher.bind(this), 43);\n  }\n  tsIsStartOfFunctionType() {\n    if (this.match(47)) {\n      return true;\n    }\n    return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));\n  }\n  tsSkipParameterStart() {\n    if (tokenIsIdentifier(this.state.type) || this.match(78)) {\n      this.next();\n      return true;\n    }\n    if (this.match(5)) {\n      const {\n        errors\n      } = this.state;\n      const previousErrorCount = errors.length;\n      try {\n        this.parseObjectLike(8, true);\n        return errors.length === previousErrorCount;\n      } catch (_unused) {\n        return false;\n      }\n    }\n    if (this.match(0)) {\n      this.next();\n      const {\n        errors\n      } = this.state;\n      const previousErrorCount = errors.length;\n      try {\n        super.parseBindingList(3, 93, 1);\n        return errors.length === previousErrorCount;\n      } catch (_unused2) {\n        return false;\n      }\n    }\n    return false;\n  }\n  tsIsUnambiguouslyStartOfFunctionType() {\n    this.next();\n    if (this.match(11) || this.match(21)) {\n      return true;\n    }\n    if (this.tsSkipParameterStart()) {\n      if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) {\n        return true;\n      }\n      if (this.match(11)) {\n        this.next();\n        if (this.match(19)) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n  tsParseTypeOrTypePredicateAnnotation(returnToken) {\n    return this.tsInType(() => {\n      const t = this.startNode();\n      this.expect(returnToken);\n      const node = this.startNode();\n      const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));\n      if (asserts && this.match(78)) {\n        let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();\n        if (thisTypePredicate.type === \"TSThisType\") {\n          node.parameterName = thisTypePredicate;\n          node.asserts = true;\n          node.typeAnnotation = null;\n          thisTypePredicate = this.finishNode(node, \"TSTypePredicate\");\n        } else {\n          this.resetStartLocationFromNode(thisTypePredicate, node);\n          thisTypePredicate.asserts = true;\n        }\n        t.typeAnnotation = thisTypePredicate;\n        return this.finishNode(t, \"TSTypeAnnotation\");\n      }\n      const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));\n      if (!typePredicateVariable) {\n        if (!asserts) {\n          return this.tsParseTypeAnnotation(false, t);\n        }\n        node.parameterName = this.parseIdentifier();\n        node.asserts = asserts;\n        node.typeAnnotation = null;\n        t.typeAnnotation = this.finishNode(node, \"TSTypePredicate\");\n        return this.finishNode(t, \"TSTypeAnnotation\");\n      }\n      const type = this.tsParseTypeAnnotation(false);\n      node.parameterName = typePredicateVariable;\n      node.typeAnnotation = type;\n      node.asserts = asserts;\n      t.typeAnnotation = this.finishNode(node, \"TSTypePredicate\");\n      return this.finishNode(t, \"TSTypeAnnotation\");\n    });\n  }\n  tsTryParseTypeOrTypePredicateAnnotation() {\n    if (this.match(14)) {\n      return this.tsParseTypeOrTypePredicateAnnotation(14);\n    }\n  }\n  tsTryParseTypeAnnotation() {\n    if (this.match(14)) {\n      return this.tsParseTypeAnnotation();\n    }\n  }\n  tsTryParseType() {\n    return this.tsEatThenParseType(14);\n  }\n  tsParseTypePredicatePrefix() {\n    const id = this.parseIdentifier();\n    if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {\n      this.next();\n      return id;\n    }\n  }\n  tsParseTypePredicateAsserts() {\n    if (this.state.type !== 109) {\n      return false;\n    }\n    const containsEsc = this.state.containsEsc;\n    this.next();\n    if (!tokenIsIdentifier(this.state.type) && !this.match(78)) {\n      return false;\n    }\n    if (containsEsc) {\n      this.raise(Errors.InvalidEscapedReservedWord, this.state.lastTokStartLoc, {\n        reservedWord: \"asserts\"\n      });\n    }\n    return true;\n  }\n  tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {\n    this.tsInType(() => {\n      if (eatColon) this.expect(14);\n      t.typeAnnotation = this.tsParseType();\n    });\n    return this.finishNode(t, \"TSTypeAnnotation\");\n  }\n  tsParseType() {\n    assert(this.state.inType);\n    const type = this.tsParseNonConditionalType();\n    if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {\n      return type;\n    }\n    const node = this.startNodeAtNode(type);\n    node.checkType = type;\n    node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());\n    this.expect(17);\n    node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());\n    this.expect(14);\n    node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());\n    return this.finishNode(node, \"TSConditionalType\");\n  }\n  isAbstractConstructorSignature() {\n    return this.isContextual(124) && this.lookahead().type === 77;\n  }\n  tsParseNonConditionalType() {\n    if (this.tsIsStartOfFunctionType()) {\n      return this.tsParseFunctionOrConstructorType(\"TSFunctionType\");\n    }\n    if (this.match(77)) {\n      return this.tsParseFunctionOrConstructorType(\"TSConstructorType\");\n    } else if (this.isAbstractConstructorSignature()) {\n      return this.tsParseFunctionOrConstructorType(\"TSConstructorType\", true);\n    }\n    return this.tsParseUnionTypeOrHigher();\n  }\n  tsParseTypeAssertion() {\n    if (this.getPluginOption(\"typescript\", \"disallowAmbiguousJSXLike\")) {\n      this.raise(TSErrors.ReservedTypeAssertion, this.state.startLoc);\n    }\n    const node = this.startNode();\n    node.typeAnnotation = this.tsInType(() => {\n      this.next();\n      return this.match(75) ? this.tsParseTypeReference() : this.tsParseType();\n    });\n    this.expect(48);\n    node.expression = this.parseMaybeUnary();\n    return this.finishNode(node, \"TSTypeAssertion\");\n  }\n  tsParseHeritageClause(token) {\n    const originalStartLoc = this.state.startLoc;\n    const delimitedList = this.tsParseDelimitedList(\"HeritageClauseElement\", () => {\n      const node = this.startNode();\n      node.expression = this.tsParseEntityName();\n      if (this.match(47)) {\n        node.typeParameters = this.tsParseTypeArguments();\n      }\n      return this.finishNode(node, \"TSExpressionWithTypeArguments\");\n    });\n    if (!delimitedList.length) {\n      this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, {\n        token\n      });\n    }\n    return delimitedList;\n  }\n  tsParseInterfaceDeclaration(node, properties = {}) {\n    if (this.hasFollowingLineBreak()) return null;\n    this.expectContextual(129);\n    if (properties.declare) node.declare = true;\n    if (tokenIsIdentifier(this.state.type)) {\n      node.id = this.parseIdentifier();\n      this.checkIdentifier(node.id, 130);\n    } else {\n      node.id = null;\n      this.raise(TSErrors.MissingInterfaceName, this.state.startLoc);\n    }\n    node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);\n    if (this.eat(81)) {\n      node.extends = this.tsParseHeritageClause(\"extends\");\n    }\n    const 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  tsParseTypeAliasDeclaration(node) {\n    node.id = this.parseIdentifier();\n    this.checkIdentifier(node.id, 2);\n    node.typeAnnotation = this.tsInType(() => {\n      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);\n      this.expect(29);\n      if (this.isContextual(114) && this.lookahead().type !== 16) {\n        const node = this.startNode();\n        this.next();\n        return this.finishNode(node, \"TSIntrinsicKeyword\");\n      }\n      return this.tsParseType();\n    });\n    this.semicolon();\n    return this.finishNode(node, \"TSTypeAliasDeclaration\");\n  }\n  tsInNoContext(cb) {\n    const oldContext = this.state.context;\n    this.state.context = [oldContext[0]];\n    try {\n      return cb();\n    } finally {\n      this.state.context = oldContext;\n    }\n  }\n  tsInType(cb) {\n    const oldInType = this.state.inType;\n    this.state.inType = true;\n    try {\n      return cb();\n    } finally {\n      this.state.inType = oldInType;\n    }\n  }\n  tsInDisallowConditionalTypesContext(cb) {\n    const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;\n    this.state.inDisallowConditionalTypesContext = true;\n    try {\n      return cb();\n    } finally {\n      this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;\n    }\n  }\n  tsInAllowConditionalTypesContext(cb) {\n    const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;\n    this.state.inDisallowConditionalTypesContext = false;\n    try {\n      return cb();\n    } finally {\n      this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;\n    }\n  }\n  tsEatThenParseType(token) {\n    if (this.match(token)) {\n      return this.tsNextThenParseType();\n    }\n  }\n  tsExpectThenParseType(token) {\n    return this.tsInType(() => {\n      this.expect(token);\n      return this.tsParseType();\n    });\n  }\n  tsNextThenParseType() {\n    return this.tsInType(() => {\n      this.next();\n      return this.tsParseType();\n    });\n  }\n  tsParseEnumMember() {\n    const node = this.startNode();\n    node.id = this.match(133) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);\n    if (this.eat(29)) {\n      node.initializer = super.parseMaybeAssignAllowIn();\n    }\n    return this.finishNode(node, \"TSEnumMember\");\n  }\n  tsParseEnumDeclaration(node, properties = {}) {\n    if (properties.const) node.const = true;\n    if (properties.declare) node.declare = true;\n    this.expectContextual(126);\n    node.id = this.parseIdentifier();\n    this.checkIdentifier(node.id, node.const ? 8971 : 8459);\n    this.expect(5);\n    node.members = this.tsParseDelimitedList(\"EnumMembers\", this.tsParseEnumMember.bind(this));\n    this.expect(8);\n    return this.finishNode(node, \"TSEnumDeclaration\");\n  }\n  tsParseModuleBlock() {\n    const node = this.startNode();\n    this.scope.enter(0);\n    this.expect(5);\n    super.parseBlockOrModuleBlockBody(node.body = [], undefined, true, 8);\n    this.scope.exit();\n    return this.finishNode(node, \"TSModuleBlock\");\n  }\n  tsParseModuleOrNamespaceDeclaration(node, nested = false) {\n    node.id = this.parseIdentifier();\n    if (!nested) {\n      this.checkIdentifier(node.id, 1024);\n    }\n    if (this.eat(16)) {\n      const inner = this.startNode();\n      this.tsParseModuleOrNamespaceDeclaration(inner, true);\n      node.body = inner;\n    } else {\n      this.scope.enter(256);\n      this.prodParam.enter(0);\n      node.body = this.tsParseModuleBlock();\n      this.prodParam.exit();\n      this.scope.exit();\n    }\n    return this.finishNode(node, \"TSModuleDeclaration\");\n  }\n  tsParseAmbientExternalModuleDeclaration(node) {\n    if (this.isContextual(112)) {\n      node.global = true;\n      node.id = this.parseIdentifier();\n    } else if (this.match(133)) {\n      node.id = super.parseStringLiteral(this.state.value);\n    } else {\n      this.unexpected();\n    }\n    if (this.match(5)) {\n      this.scope.enter(256);\n      this.prodParam.enter(0);\n      node.body = this.tsParseModuleBlock();\n      this.prodParam.exit();\n      this.scope.exit();\n    } else {\n      this.semicolon();\n    }\n    return this.finishNode(node, \"TSModuleDeclaration\");\n  }\n  tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {\n    node.isExport = isExport || false;\n    node.id = maybeDefaultIdentifier || this.parseIdentifier();\n    this.checkIdentifier(node.id, 4096);\n    this.expect(29);\n    const moduleReference = this.tsParseModuleReference();\n    if (node.importKind === \"type\" && moduleReference.type !== \"TSExternalModuleReference\") {\n      this.raise(TSErrors.ImportAliasHasImportType, moduleReference);\n    }\n    node.moduleReference = moduleReference;\n    this.semicolon();\n    return this.finishNode(node, \"TSImportEqualsDeclaration\");\n  }\n  tsIsExternalModuleReference() {\n    return this.isContextual(119) && this.lookaheadCharCode() === 40;\n  }\n  tsParseModuleReference() {\n    return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);\n  }\n  tsParseExternalModuleReference() {\n    const node = this.startNode();\n    this.expectContextual(119);\n    this.expect(10);\n    if (!this.match(133)) {\n      this.unexpected();\n    }\n    node.expression = super.parseExprAtom();\n    this.expect(11);\n    this.sawUnambiguousESM = true;\n    return this.finishNode(node, \"TSExternalModuleReference\");\n  }\n  tsLookAhead(f) {\n    const state = this.state.clone();\n    const res = f();\n    this.state = state;\n    return res;\n  }\n  tsTryParseAndCatch(f) {\n    const result = this.tryParse(abort => f() || abort());\n    if (result.aborted || !result.node) return;\n    if (result.error) this.state = result.failState;\n    return result.node;\n  }\n  tsTryParse(f) {\n    const state = this.state.clone();\n    const result = f();\n    if (result !== undefined && result !== false) {\n      return result;\n    }\n    this.state = state;\n  }\n  tsTryParseDeclare(nany) {\n    if (this.isLineTerminator()) {\n      return;\n    }\n    let startType = this.state.type;\n    let kind;\n    if (this.isContextual(100)) {\n      startType = 74;\n      kind = \"let\";\n    }\n    return this.tsInAmbientContext(() => {\n      switch (startType) {\n        case 68:\n          nany.declare = true;\n          return super.parseFunctionStatement(nany, false, false);\n        case 80:\n          nany.declare = true;\n          return this.parseClass(nany, true, false);\n        case 126:\n          return this.tsParseEnumDeclaration(nany, {\n            declare: true\n          });\n        case 112:\n          return this.tsParseAmbientExternalModuleDeclaration(nany);\n        case 75:\n        case 74:\n          if (!this.match(75) || !this.isLookaheadContextual(\"enum\")) {\n            nany.declare = true;\n            return this.parseVarStatement(nany, kind || this.state.value, true);\n          }\n          this.expect(75);\n          return this.tsParseEnumDeclaration(nany, {\n            const: true,\n            declare: true\n          });\n        case 129:\n          {\n            const result = this.tsParseInterfaceDeclaration(nany, {\n              declare: true\n            });\n            if (result) return result;\n          }\n        default:\n          if (tokenIsIdentifier(startType)) {\n            return this.tsParseDeclaration(nany, this.state.value, true, null);\n          }\n      }\n    });\n  }\n  tsTryParseExportDeclaration() {\n    return this.tsParseDeclaration(this.startNode(), this.state.value, true, null);\n  }\n  tsParseExpressionStatement(node, expr, decorators) {\n    switch (expr.name) {\n      case \"declare\":\n        {\n          const declaration = this.tsTryParseDeclare(node);\n          if (declaration) {\n            declaration.declare = true;\n          }\n          return declaration;\n        }\n      case \"global\":\n        if (this.match(5)) {\n          this.scope.enter(256);\n          this.prodParam.enter(0);\n          const 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        break;\n      default:\n        return this.tsParseDeclaration(node, expr.name, false, decorators);\n    }\n  }\n  tsParseDeclaration(node, value, next, decorators) {\n    switch (value) {\n      case \"abstract\":\n        if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) {\n          return this.tsParseAbstractDeclaration(node, decorators);\n        }\n        break;\n      case \"module\":\n        if (this.tsCheckLineTerminator(next)) {\n          if (this.match(133)) {\n            return this.tsParseAmbientExternalModuleDeclaration(node);\n          } else if (tokenIsIdentifier(this.state.type)) {\n            return this.tsParseModuleOrNamespaceDeclaration(node);\n          }\n        }\n        break;\n      case \"namespace\":\n        if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {\n          return this.tsParseModuleOrNamespaceDeclaration(node);\n        }\n        break;\n      case \"type\":\n        if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {\n          return this.tsParseTypeAliasDeclaration(node);\n        }\n        break;\n    }\n  }\n  tsCheckLineTerminator(next) {\n    if (next) {\n      if (this.hasFollowingLineBreak()) return false;\n      this.next();\n      return true;\n    }\n    return !this.isLineTerminator();\n  }\n  tsTryParseGenericAsyncArrowFunction(startLoc) {\n    if (!this.match(47)) return;\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    this.state.maybeInArrowParameters = true;\n    const res = this.tsTryParseAndCatch(() => {\n      const node = this.startNodeAt(startLoc);\n      node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);\n      super.parseFunctionParams(node);\n      node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();\n      this.expect(19);\n      return node;\n    });\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    if (!res) return;\n    return super.parseArrowExpression(res, null, true);\n  }\n  tsParseTypeArgumentsInExpression() {\n    if (this.reScan_lt() !== 47) return;\n    return this.tsParseTypeArguments();\n  }\n  tsParseTypeArguments() {\n    const node = this.startNode();\n    node.params = this.tsInType(() => this.tsInNoContext(() => {\n      this.expect(47);\n      return this.tsParseDelimitedList(\"TypeParametersOrArguments\", this.tsParseType.bind(this));\n    }));\n    if (node.params.length === 0) {\n      this.raise(TSErrors.EmptyTypeArguments, node);\n    } else if (!this.state.inType && this.curContext() === types.brace) {\n      this.reScan_lt_gt();\n    }\n    this.expect(48);\n    return this.finishNode(node, \"TSTypeParameterInstantiation\");\n  }\n  tsIsDeclarationStart() {\n    return tokenIsTSDeclarationStart(this.state.type);\n  }\n  isExportDefaultSpecifier() {\n    if (this.tsIsDeclarationStart()) return false;\n    return super.isExportDefaultSpecifier();\n  }\n  parseAssignableListItem(flags, decorators) {\n    const startLoc = this.state.startLoc;\n    const modified = {};\n    this.tsParseModifiers({\n      allowedModifiers: [\"public\", \"private\", \"protected\", \"override\", \"readonly\"]\n    }, modified);\n    const accessibility = modified.accessibility;\n    const override = modified.override;\n    const readonly = modified.readonly;\n    if (!(flags & 4) && (accessibility || readonly || override)) {\n      this.raise(TSErrors.UnexpectedParameterModifier, startLoc);\n    }\n    const left = this.parseMaybeDefault();\n    this.parseAssignableListItemTypes(left, flags);\n    const elt = this.parseMaybeDefault(left.loc.start, left);\n    if (accessibility || readonly || override) {\n      const pp = this.startNodeAt(startLoc);\n      if (decorators.length) {\n        pp.decorators = decorators;\n      }\n      if (accessibility) pp.accessibility = accessibility;\n      if (readonly) pp.readonly = readonly;\n      if (override) pp.override = override;\n      if (elt.type !== \"Identifier\" && elt.type !== \"AssignmentPattern\") {\n        this.raise(TSErrors.UnsupportedParameterPropertyKind, pp);\n      }\n      pp.parameter = elt;\n      return this.finishNode(pp, \"TSParameterProperty\");\n    }\n    if (decorators.length) {\n      left.decorators = decorators;\n    }\n    return elt;\n  }\n  isSimpleParameter(node) {\n    return node.type === \"TSParameterProperty\" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node);\n  }\n  tsDisallowOptionalPattern(node) {\n    for (const param of node.params) {\n      if (param.type !== \"Identifier\" && param.optional && !this.state.isAmbientContext) {\n        this.raise(TSErrors.PatternIsOptional, param);\n      }\n    }\n  }\n  setArrowFunctionParameters(node, params, trailingCommaLoc) {\n    super.setArrowFunctionParameters(node, params, trailingCommaLoc);\n    this.tsDisallowOptionalPattern(node);\n  }\n  parseFunctionBodyAndFinish(node, type, isMethod = false) {\n    if (this.match(14)) {\n      node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14);\n    }\n    const bodilessType = type === \"FunctionDeclaration\" ? \"TSDeclareFunction\" : type === \"ClassMethod\" || type === \"ClassPrivateMethod\" ? \"TSDeclareMethod\" : undefined;\n    if (bodilessType && !this.match(5) && this.isLineTerminator()) {\n      return this.finishNode(node, bodilessType);\n    }\n    if (bodilessType === \"TSDeclareFunction\" && this.state.isAmbientContext) {\n      this.raise(TSErrors.DeclareFunctionHasImplementation, node);\n      if (node.declare) {\n        return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);\n      }\n    }\n    this.tsDisallowOptionalPattern(node);\n    return super.parseFunctionBodyAndFinish(node, type, isMethod);\n  }\n  registerFunctionStatementId(node) {\n    if (!node.body && node.id) {\n      this.checkIdentifier(node.id, 1024);\n    } else {\n      super.registerFunctionStatementId(node);\n    }\n  }\n  tsCheckForInvalidTypeCasts(items) {\n    items.forEach(node => {\n      if ((node == null ? void 0 : node.type) === \"TSTypeCastExpression\") {\n        this.raise(TSErrors.UnexpectedTypeAnnotation, node.typeAnnotation);\n      }\n    });\n  }\n  toReferencedList(exprList, isInParens) {\n    this.tsCheckForInvalidTypeCasts(exprList);\n    return exprList;\n  }\n  parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {\n    const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);\n    if (node.type === \"ArrayExpression\") {\n      this.tsCheckForInvalidTypeCasts(node.elements);\n    }\n    return node;\n  }\n  parseSubscript(base, startLoc, noCalls, state) {\n    if (!this.hasPrecedingLineBreak() && this.match(35)) {\n      this.state.canStartJSXElement = false;\n      this.next();\n      const nonNullExpression = this.startNodeAt(startLoc);\n      nonNullExpression.expression = base;\n      return this.finishNode(nonNullExpression, \"TSNonNullExpression\");\n    }\n    let isOptionalCall = false;\n    if (this.match(18) && this.lookaheadCharCode() === 60) {\n      if (noCalls) {\n        state.stop = true;\n        return base;\n      }\n      state.optionalChainMember = isOptionalCall = true;\n      this.next();\n    }\n    if (this.match(47) || this.match(51)) {\n      let missingParenErrorLoc;\n      const result = this.tsTryParseAndCatch(() => {\n        if (!noCalls && this.atPossibleAsyncArrow(base)) {\n          const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startLoc);\n          if (asyncArrowFn) {\n            return asyncArrowFn;\n          }\n        }\n        const typeArguments = this.tsParseTypeArgumentsInExpression();\n        if (!typeArguments) return;\n        if (isOptionalCall && !this.match(10)) {\n          missingParenErrorLoc = this.state.curPosition();\n          return;\n        }\n        if (tokenIsTemplate(this.state.type)) {\n          const result = super.parseTaggedTemplateExpression(base, startLoc, state);\n          result.typeParameters = typeArguments;\n          return result;\n        }\n        if (!noCalls && this.eat(10)) {\n          const node = this.startNodeAt(startLoc);\n          node.callee = base;\n          node.arguments = this.parseCallExpressionArguments(11, false);\n          this.tsCheckForInvalidTypeCasts(node.arguments);\n          node.typeParameters = typeArguments;\n          if (state.optionalChainMember) {\n            node.optional = isOptionalCall;\n          }\n          return this.finishCallExpression(node, state.optionalChainMember);\n        }\n        const tokenType = this.state.type;\n        if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {\n          return;\n        }\n        const node = this.startNodeAt(startLoc);\n        node.expression = base;\n        node.typeParameters = typeArguments;\n        return this.finishNode(node, \"TSInstantiationExpression\");\n      });\n      if (missingParenErrorLoc) {\n        this.unexpected(missingParenErrorLoc, 10);\n      }\n      if (result) {\n        if (result.type === \"TSInstantiationExpression\" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) {\n          this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, this.state.startLoc);\n        }\n        return result;\n      }\n    }\n    return super.parseSubscript(base, startLoc, noCalls, state);\n  }\n  parseNewCallee(node) {\n    var _callee$extra;\n    super.parseNewCallee(node);\n    const {\n      callee\n    } = node;\n    if (callee.type === \"TSInstantiationExpression\" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {\n      node.typeParameters = callee.typeParameters;\n      node.callee = callee.expression;\n    }\n  }\n  parseExprOp(left, leftStartLoc, minPrec) {\n    let isSatisfies;\n    if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(120)))) {\n      const node = this.startNodeAt(leftStartLoc);\n      node.expression = left;\n      node.typeAnnotation = this.tsInType(() => {\n        this.next();\n        if (this.match(75)) {\n          if (isSatisfies) {\n            this.raise(Errors.UnexpectedKeyword, this.state.startLoc, {\n              keyword: \"const\"\n            });\n          }\n          return this.tsParseTypeReference();\n        }\n        return this.tsParseType();\n      });\n      this.finishNode(node, isSatisfies ? \"TSSatisfiesExpression\" : \"TSAsExpression\");\n      this.reScan_lt_gt();\n      return this.parseExprOp(node, leftStartLoc, minPrec);\n    }\n    return super.parseExprOp(left, leftStartLoc, minPrec);\n  }\n  checkReservedWord(word, startLoc, checkKeywords, isBinding) {\n    if (!this.state.isAmbientContext) {\n      super.checkReservedWord(word, startLoc, checkKeywords, isBinding);\n    }\n  }\n  checkImportReflection(node) {\n    super.checkImportReflection(node);\n    if (node.module && node.importKind !== \"value\") {\n      this.raise(TSErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);\n    }\n  }\n  checkDuplicateExports() {}\n  isPotentialImportPhase(isExport) {\n    if (super.isPotentialImportPhase(isExport)) return true;\n    if (this.isContextual(130)) {\n      const ch = this.lookaheadCharCode();\n      return isExport ? ch === 123 || ch === 42 : ch !== 61;\n    }\n    return !isExport && this.isContextual(87);\n  }\n  applyImportPhase(node, isExport, phase, loc) {\n    super.applyImportPhase(node, isExport, phase, loc);\n    if (isExport) {\n      node.exportKind = phase === \"type\" ? \"type\" : \"value\";\n    } else {\n      node.importKind = phase === \"type\" || phase === \"typeof\" ? phase : \"value\";\n    }\n  }\n  parseImport(node) {\n    if (this.match(133)) {\n      node.importKind = \"value\";\n      return super.parseImport(node);\n    }\n    let importNode;\n    if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) {\n      node.importKind = \"value\";\n      return this.tsParseImportEqualsDeclaration(node);\n    } else if (this.isContextual(130)) {\n      const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);\n      if (this.lookaheadCharCode() === 61) {\n        return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);\n      } else {\n        importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier);\n      }\n    } else {\n      importNode = super.parseImport(node);\n    }\n    if (importNode.importKind === \"type\" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === \"ImportDefaultSpecifier\") {\n      this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, importNode);\n    }\n    return importNode;\n  }\n  parseExport(node, decorators) {\n    if (this.match(83)) {\n      this.next();\n      const nodeImportEquals = node;\n      let maybeDefaultIdentifier = null;\n      if (this.isContextual(130) && this.isPotentialImportPhase(false)) {\n        maybeDefaultIdentifier = this.parseMaybeImportPhase(nodeImportEquals, false);\n      } else {\n        nodeImportEquals.importKind = \"value\";\n      }\n      return this.tsParseImportEqualsDeclaration(nodeImportEquals, maybeDefaultIdentifier, true);\n    } else if (this.eat(29)) {\n      const assign = node;\n      assign.expression = super.parseExpression();\n      this.semicolon();\n      this.sawUnambiguousESM = true;\n      return this.finishNode(assign, \"TSExportAssignment\");\n    } else if (this.eatContextual(93)) {\n      const decl = node;\n      this.expectContextual(128);\n      decl.id = this.parseIdentifier();\n      this.semicolon();\n      return this.finishNode(decl, \"TSNamespaceExportDeclaration\");\n    } else {\n      return super.parseExport(node, decorators);\n    }\n  }\n  isAbstractClass() {\n    return this.isContextual(124) && this.lookahead().type === 80;\n  }\n  parseExportDefaultExpression() {\n    if (this.isAbstractClass()) {\n      const cls = this.startNode();\n      this.next();\n      cls.abstract = true;\n      return this.parseClass(cls, true, true);\n    }\n    if (this.match(129)) {\n      const result = this.tsParseInterfaceDeclaration(this.startNode());\n      if (result) return result;\n    }\n    return super.parseExportDefaultExpression();\n  }\n  parseVarStatement(node, kind, allowMissingInitializer = false) {\n    const {\n      isAmbientContext\n    } = this.state;\n    const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);\n    if (!isAmbientContext) return declaration;\n    for (const {\n      id,\n      init\n    } of declaration.declarations) {\n      if (!init) continue;\n      if (kind !== \"const\" || !!id.typeAnnotation) {\n        this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);\n      } else if (!isValidAmbientConstInitializer(init, this.hasPlugin(\"estree\"))) {\n        this.raise(TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);\n      }\n    }\n    return declaration;\n  }\n  parseStatementContent(flags, decorators) {\n    if (this.match(75) && this.isLookaheadContextual(\"enum\")) {\n      const node = this.startNode();\n      this.expect(75);\n      return this.tsParseEnumDeclaration(node, {\n        const: true\n      });\n    }\n    if (this.isContextual(126)) {\n      return this.tsParseEnumDeclaration(this.startNode());\n    }\n    if (this.isContextual(129)) {\n      const result = this.tsParseInterfaceDeclaration(this.startNode());\n      if (result) return result;\n    }\n    return super.parseStatementContent(flags, decorators);\n  }\n  parseAccessModifier() {\n    return this.tsParseModifier([\"public\", \"protected\", \"private\"]);\n  }\n  tsHasSomeModifiers(member, modifiers) {\n    return modifiers.some(modifier => {\n      if (tsIsAccessModifier(modifier)) {\n        return member.accessibility === modifier;\n      }\n      return !!member[modifier];\n    });\n  }\n  tsIsStartOfStaticBlocks() {\n    return this.isContextual(106) && this.lookaheadCharCode() === 123;\n  }\n  parseClassMember(classBody, member, state) {\n    const modifiers = [\"declare\", \"private\", \"public\", \"protected\", \"override\", \"abstract\", \"readonly\", \"static\"];\n    this.tsParseModifiers({\n      allowedModifiers: modifiers,\n      disallowedModifiers: [\"in\", \"out\"],\n      stopOnStartOfClassStaticBlock: true,\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions\n    }, member);\n    const callParseClassMemberWithIsStatic = () => {\n      if (this.tsIsStartOfStaticBlocks()) {\n        this.next();\n        this.next();\n        if (this.tsHasSomeModifiers(member, modifiers)) {\n          this.raise(TSErrors.StaticBlockCannotHaveModifier, this.state.curPosition());\n        }\n        super.parseClassStaticBlock(classBody, member);\n      } else {\n        this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);\n      }\n    };\n    if (member.declare) {\n      this.tsInAmbientContext(callParseClassMemberWithIsStatic);\n    } else {\n      callParseClassMemberWithIsStatic();\n    }\n  }\n  parseClassMemberWithIsStatic(classBody, member, state, isStatic) {\n    const idx = this.tsTryParseIndexSignature(member);\n    if (idx) {\n      classBody.body.push(idx);\n      if (member.abstract) {\n        this.raise(TSErrors.IndexSignatureHasAbstract, member);\n      }\n      if (member.accessibility) {\n        this.raise(TSErrors.IndexSignatureHasAccessibility, member, {\n          modifier: member.accessibility\n        });\n      }\n      if (member.declare) {\n        this.raise(TSErrors.IndexSignatureHasDeclare, member);\n      }\n      if (member.override) {\n        this.raise(TSErrors.IndexSignatureHasOverride, member);\n      }\n      return;\n    }\n    if (!this.state.inAbstractClass && member.abstract) {\n      this.raise(TSErrors.NonAbstractClassHasAbstractMethod, member);\n    }\n    if (member.override) {\n      if (!state.hadSuperClass) {\n        this.raise(TSErrors.OverrideNotInSubClass, member);\n      }\n    }\n    super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);\n  }\n  parsePostMemberNameModifiers(methodOrProp) {\n    const optional = this.eat(17);\n    if (optional) methodOrProp.optional = true;\n    if (methodOrProp.readonly && this.match(10)) {\n      this.raise(TSErrors.ClassMethodHasReadonly, methodOrProp);\n    }\n    if (methodOrProp.declare && this.match(10)) {\n      this.raise(TSErrors.ClassMethodHasDeclare, methodOrProp);\n    }\n  }\n  parseExpressionStatement(node, expr, decorators) {\n    const decl = expr.type === \"Identifier\" ? this.tsParseExpressionStatement(node, expr, decorators) : undefined;\n    return decl || super.parseExpressionStatement(node, expr, decorators);\n  }\n  shouldParseExportDeclaration() {\n    if (this.tsIsDeclarationStart()) return true;\n    return super.shouldParseExportDeclaration();\n  }\n  parseConditional(expr, startLoc, refExpressionErrors) {\n    if (!this.state.maybeInArrowParameters || !this.match(17)) {\n      return super.parseConditional(expr, startLoc, refExpressionErrors);\n    }\n    const result = this.tryParse(() => super.parseConditional(expr, startLoc));\n    if (!result.node) {\n      if (result.error) {\n        super.setOptionalParametersError(refExpressionErrors, result.error);\n      }\n      return expr;\n    }\n    if (result.error) this.state = result.failState;\n    return result.node;\n  }\n  parseParenItem(node, startLoc) {\n    const newNode = super.parseParenItem(node, startLoc);\n    if (this.eat(17)) {\n      newNode.optional = true;\n      this.resetEndLocation(node);\n    }\n    if (this.match(14)) {\n      const typeCastNode = this.startNodeAt(startLoc);\n      typeCastNode.expression = node;\n      typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();\n      return this.finishNode(typeCastNode, \"TSTypeCastExpression\");\n    }\n    return node;\n  }\n  parseExportDeclaration(node) {\n    if (!this.state.isAmbientContext && this.isContextual(125)) {\n      return this.tsInAmbientContext(() => this.parseExportDeclaration(node));\n    }\n    const startLoc = this.state.startLoc;\n    const isDeclare = this.eatContextual(125);\n    if (isDeclare && (this.isContextual(125) || !this.shouldParseExportDeclaration())) {\n      throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, this.state.startLoc);\n    }\n    const isIdentifier = tokenIsIdentifier(this.state.type);\n    const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);\n    if (!declaration) return null;\n    if (declaration.type === \"TSInterfaceDeclaration\" || declaration.type === \"TSTypeAliasDeclaration\" || isDeclare) {\n      node.exportKind = \"type\";\n    }\n    if (isDeclare) {\n      this.resetStartLocation(declaration, startLoc);\n      declaration.declare = true;\n    }\n    return declaration;\n  }\n  parseClassId(node, isStatement, optionalId, bindingType) {\n    if ((!isStatement || optionalId) && this.isContextual(113)) {\n      return;\n    }\n    super.parseClassId(node, isStatement, optionalId, node.declare ? 1024 : 8331);\n    const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);\n    if (typeParameters) node.typeParameters = typeParameters;\n  }\n  parseClassPropertyAnnotation(node) {\n    if (!node.optional) {\n      if (this.eat(35)) {\n        node.definite = true;\n      } else if (this.eat(17)) {\n        node.optional = true;\n      }\n    }\n    const type = this.tsTryParseTypeAnnotation();\n    if (type) node.typeAnnotation = type;\n  }\n  parseClassProperty(node) {\n    this.parseClassPropertyAnnotation(node);\n    if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) {\n      this.raise(TSErrors.DeclareClassFieldHasInitializer, this.state.startLoc);\n    }\n    if (node.abstract && this.match(29)) {\n      const {\n        key\n      } = node;\n      this.raise(TSErrors.AbstractPropertyHasInitializer, this.state.startLoc, {\n        propertyName: key.type === \"Identifier\" && !node.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`\n      });\n    }\n    return super.parseClassProperty(node);\n  }\n  parseClassPrivateProperty(node) {\n    if (node.abstract) {\n      this.raise(TSErrors.PrivateElementHasAbstract, node);\n    }\n    if (node.accessibility) {\n      this.raise(TSErrors.PrivateElementHasAccessibility, node, {\n        modifier: node.accessibility\n      });\n    }\n    this.parseClassPropertyAnnotation(node);\n    return super.parseClassPrivateProperty(node);\n  }\n  parseClassAccessorProperty(node) {\n    this.parseClassPropertyAnnotation(node);\n    if (node.optional) {\n      this.raise(TSErrors.AccessorCannotBeOptional, node);\n    }\n    return super.parseClassAccessorProperty(node);\n  }\n  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);\n    if (typeParameters && isConstructor) {\n      this.raise(TSErrors.ConstructorHasTypeParameters, typeParameters);\n    }\n    const {\n      declare = false,\n      kind\n    } = method;\n    if (declare && (kind === \"get\" || kind === \"set\")) {\n      this.raise(TSErrors.DeclareAccessor, method, {\n        kind\n      });\n    }\n    if (typeParameters) method.typeParameters = typeParameters;\n    super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);\n  }\n  pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {\n    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);\n    if (typeParameters) method.typeParameters = typeParameters;\n    super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);\n  }\n  declareClassPrivateMethodInScope(node, kind) {\n    if (node.type === \"TSDeclareMethod\") return;\n    if (node.type === \"MethodDefinition\" && !hasOwnProperty.call(node.value, \"body\")) {\n      return;\n    }\n    super.declareClassPrivateMethodInScope(node, kind);\n  }\n  parseClassSuper(node) {\n    super.parseClassSuper(node);\n    if (node.superClass && (this.match(47) || this.match(51))) {\n      node.superTypeParameters = this.tsParseTypeArgumentsInExpression();\n    }\n    if (this.eatContextual(113)) {\n      node.implements = this.tsParseHeritageClause(\"implements\");\n    }\n  }\n  parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {\n    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);\n    if (typeParameters) prop.typeParameters = typeParameters;\n    return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);\n  }\n  parseFunctionParams(node, isConstructor) {\n    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);\n    if (typeParameters) node.typeParameters = typeParameters;\n    super.parseFunctionParams(node, isConstructor);\n  }\n  parseVarId(decl, kind) {\n    super.parseVarId(decl, kind);\n    if (decl.id.type === \"Identifier\" && !this.hasPrecedingLineBreak() && this.eat(35)) {\n      decl.definite = true;\n    }\n    const type = this.tsTryParseTypeAnnotation();\n    if (type) {\n      decl.id.typeAnnotation = type;\n      this.resetEndLocation(decl.id);\n    }\n  }\n  parseAsyncArrowFromCallExpression(node, call) {\n    if (this.match(14)) {\n      node.returnType = this.tsParseTypeAnnotation();\n    }\n    return super.parseAsyncArrowFromCallExpression(node, call);\n  }\n  parseMaybeAssign(refExpressionErrors, afterLeftParse) {\n    var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2;\n    let state;\n    let jsx;\n    let typeCast;\n    if (this.hasPlugin(\"jsx\") && (this.match(142) || this.match(47))) {\n      state = this.state.clone();\n      jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);\n      if (!jsx.error) return jsx.node;\n      const {\n        context\n      } = this.state;\n      const currentContext = context[context.length - 1];\n      if (currentContext === types.j_oTag || currentContext === types.j_expr) {\n        context.pop();\n      }\n    }\n    if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) {\n      return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n    }\n    if (!state || state === this.state) state = this.state.clone();\n    let typeParameters;\n    const arrow = this.tryParse(abort => {\n      var _expr$extra, _typeParameters;\n      typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);\n      const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n      if (expr.type !== \"ArrowFunctionExpression\" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {\n        abort();\n      }\n      if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) {\n        this.resetStartLocationFromNode(expr, typeParameters);\n      }\n      expr.typeParameters = typeParameters;\n      return expr;\n    }, state);\n    if (!arrow.error && !arrow.aborted) {\n      if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);\n      return arrow.node;\n    }\n    if (!jsx) {\n      assert(!this.hasPlugin(\"jsx\"));\n      typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);\n      if (!typeCast.error) return typeCast.node;\n    }\n    if ((_jsx2 = jsx) != null && _jsx2.node) {\n      this.state = jsx.failState;\n      return jsx.node;\n    }\n    if (arrow.node) {\n      this.state = arrow.failState;\n      if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);\n      return arrow.node;\n    }\n    if ((_typeCast = typeCast) != null && _typeCast.node) {\n      this.state = typeCast.failState;\n      return typeCast.node;\n    }\n    throw ((_jsx3 = jsx) == null ? void 0 : _jsx3.error) || arrow.error || ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.error);\n  }\n  reportReservedArrowTypeParam(node) {\n    var _node$extra;\n    if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption(\"typescript\", \"disallowAmbiguousJSXLike\")) {\n      this.raise(TSErrors.ReservedArrowTypeParam, node);\n    }\n  }\n  parseMaybeUnary(refExpressionErrors, sawUnary) {\n    if (!this.hasPlugin(\"jsx\") && this.match(47)) {\n      return this.tsParseTypeAssertion();\n    }\n    return super.parseMaybeUnary(refExpressionErrors, sawUnary);\n  }\n  parseArrow(node) {\n    if (this.match(14)) {\n      const result = this.tryParse(abort => {\n        const returnType = this.tsParseTypeOrTypePredicateAnnotation(14);\n        if (this.canInsertSemicolon() || !this.match(19)) abort();\n        return returnType;\n      });\n      if (result.aborted) return;\n      if (!result.thrown) {\n        if (result.error) this.state = result.failState;\n        node.returnType = result.node;\n      }\n    }\n    return super.parseArrow(node);\n  }\n  parseAssignableListItemTypes(param, flags) {\n    if (!(flags & 2)) return param;\n    if (this.eat(17)) {\n      param.optional = true;\n    }\n    const type = this.tsTryParseTypeAnnotation();\n    if (type) param.typeAnnotation = type;\n    this.resetEndLocation(param);\n    return param;\n  }\n  isAssignable(node, isBinding) {\n    switch (node.type) {\n      case \"TSTypeCastExpression\":\n        return this.isAssignable(node.expression, isBinding);\n      case \"TSParameterProperty\":\n        return true;\n      default:\n        return super.isAssignable(node, isBinding);\n    }\n  }\n  toAssignable(node, isLHS = false) {\n    switch (node.type) {\n      case \"ParenthesizedExpression\":\n        this.toAssignableParenthesizedExpression(node, isLHS);\n        break;\n      case \"TSAsExpression\":\n      case \"TSSatisfiesExpression\":\n      case \"TSNonNullExpression\":\n      case \"TSTypeAssertion\":\n        if (isLHS) {\n          this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, node);\n        } else {\n          this.raise(TSErrors.UnexpectedTypeCastInParameter, node);\n        }\n        this.toAssignable(node.expression, isLHS);\n        break;\n      case \"AssignmentExpression\":\n        if (!isLHS && node.left.type === \"TSTypeCastExpression\") {\n          node.left = this.typeCastToParameter(node.left);\n        }\n      default:\n        super.toAssignable(node, isLHS);\n    }\n  }\n  toAssignableParenthesizedExpression(node, isLHS) {\n    switch (node.expression.type) {\n      case \"TSAsExpression\":\n      case \"TSSatisfiesExpression\":\n      case \"TSNonNullExpression\":\n      case \"TSTypeAssertion\":\n      case \"ParenthesizedExpression\":\n        this.toAssignable(node.expression, isLHS);\n        break;\n      default:\n        super.toAssignable(node, isLHS);\n    }\n  }\n  checkToRestConversion(node, allowPattern) {\n    switch (node.type) {\n      case \"TSAsExpression\":\n      case \"TSSatisfiesExpression\":\n      case \"TSTypeAssertion\":\n      case \"TSNonNullExpression\":\n        this.checkToRestConversion(node.expression, false);\n        break;\n      default:\n        super.checkToRestConversion(node, allowPattern);\n    }\n  }\n  isValidLVal(type, isUnparenthesizedInAssign, binding) {\n    switch (type) {\n      case \"TSTypeCastExpression\":\n        return true;\n      case \"TSParameterProperty\":\n        return \"parameter\";\n      case \"TSNonNullExpression\":\n      case \"TSInstantiationExpression\":\n        return \"expression\";\n      case \"TSAsExpression\":\n      case \"TSSatisfiesExpression\":\n      case \"TSTypeAssertion\":\n        return (binding !== 64 || !isUnparenthesizedInAssign) && [\"expression\", true];\n      default:\n        return super.isValidLVal(type, isUnparenthesizedInAssign, binding);\n    }\n  }\n  parseBindingAtom() {\n    if (this.state.type === 78) {\n      return this.parseIdentifier(true);\n    }\n    return super.parseBindingAtom();\n  }\n  parseMaybeDecoratorArguments(expr) {\n    if (this.match(47) || this.match(51)) {\n      const typeArguments = this.tsParseTypeArgumentsInExpression();\n      if (this.match(10)) {\n        const call = super.parseMaybeDecoratorArguments(expr);\n        call.typeParameters = typeArguments;\n        return call;\n      }\n      this.unexpected(null, 10);\n    }\n    return super.parseMaybeDecoratorArguments(expr);\n  }\n  checkCommaAfterRest(close) {\n    if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {\n      this.next();\n      return false;\n    }\n    return super.checkCommaAfterRest(close);\n  }\n  isClassMethod() {\n    return this.match(47) || super.isClassMethod();\n  }\n  isClassProperty() {\n    return this.match(35) || this.match(14) || super.isClassProperty();\n  }\n  parseMaybeDefault(startLoc, left) {\n    const node = super.parseMaybeDefault(startLoc, left);\n    if (node.type === \"AssignmentPattern\" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {\n      this.raise(TSErrors.TypeAnnotationAfterAssign, node.typeAnnotation);\n    }\n    return node;\n  }\n  getTokenFromCode(code) {\n    if (this.state.inType) {\n      if (code === 62) {\n        this.finishOp(48, 1);\n        return;\n      }\n      if (code === 60) {\n        this.finishOp(47, 1);\n        return;\n      }\n    }\n    super.getTokenFromCode(code);\n  }\n  reScan_lt_gt() {\n    const {\n      type\n    } = this.state;\n    if (type === 47) {\n      this.state.pos -= 1;\n      this.readToken_lt();\n    } else if (type === 48) {\n      this.state.pos -= 1;\n      this.readToken_gt();\n    }\n  }\n  reScan_lt() {\n    const {\n      type\n    } = this.state;\n    if (type === 51) {\n      this.state.pos -= 2;\n      this.finishOp(47, 1);\n      return 47;\n    }\n    return type;\n  }\n  toAssignableList(exprList, trailingCommaLoc, isLHS) {\n    for (let i = 0; i < exprList.length; i++) {\n      const expr = exprList[i];\n      if ((expr == null ? void 0 : expr.type) === \"TSTypeCastExpression\") {\n        exprList[i] = this.typeCastToParameter(expr);\n      }\n    }\n    super.toAssignableList(exprList, trailingCommaLoc, isLHS);\n  }\n  typeCastToParameter(node) {\n    node.expression.typeAnnotation = node.typeAnnotation;\n    this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);\n    return node.expression;\n  }\n  shouldParseArrow(params) {\n    if (this.match(14)) {\n      return params.every(expr => this.isAssignable(expr, true));\n    }\n    return super.shouldParseArrow(params);\n  }\n  shouldParseAsyncArrow() {\n    return this.match(14) || super.shouldParseAsyncArrow();\n  }\n  canHaveLeadingDecorator() {\n    return super.canHaveLeadingDecorator() || this.isAbstractClass();\n  }\n  jsxParseOpeningElementAfterName(node) {\n    if (this.match(47) || this.match(51)) {\n      const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());\n      if (typeArguments) node.typeParameters = typeArguments;\n    }\n    return super.jsxParseOpeningElementAfterName(node);\n  }\n  getGetterSetterExpectedParamCount(method) {\n    const baseCount = super.getGetterSetterExpectedParamCount(method);\n    const params = this.getObjectOrClassMethodParams(method);\n    const firstParam = params[0];\n    const hasContextParam = firstParam && this.isThisParam(firstParam);\n    return hasContextParam ? baseCount + 1 : baseCount;\n  }\n  parseCatchClauseParam() {\n    const param = super.parseCatchClauseParam();\n    const type = this.tsTryParseTypeAnnotation();\n    if (type) {\n      param.typeAnnotation = type;\n      this.resetEndLocation(param);\n    }\n    return param;\n  }\n  tsInAmbientContext(cb) {\n    const {\n      isAmbientContext: oldIsAmbientContext,\n      strict: oldStrict\n    } = this.state;\n    this.state.isAmbientContext = true;\n    this.state.strict = false;\n    try {\n      return cb();\n    } finally {\n      this.state.isAmbientContext = oldIsAmbientContext;\n      this.state.strict = oldStrict;\n    }\n  }\n  parseClass(node, isStatement, optionalId) {\n    const oldInAbstractClass = this.state.inAbstractClass;\n    this.state.inAbstractClass = !!node.abstract;\n    try {\n      return super.parseClass(node, isStatement, optionalId);\n    } finally {\n      this.state.inAbstractClass = oldInAbstractClass;\n    }\n  }\n  tsParseAbstractDeclaration(node, decorators) {\n    if (this.match(80)) {\n      node.abstract = true;\n      return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));\n    } else if (this.isContextual(129)) {\n      if (!this.hasFollowingLineBreak()) {\n        node.abstract = true;\n        this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, node);\n        return this.tsParseInterfaceDeclaration(node);\n      }\n    } else {\n      this.unexpected(null, 80);\n    }\n  }\n  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {\n    const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);\n    if (method.abstract) {\n      const hasBody = this.hasPlugin(\"estree\") ? !!method.value.body : !!method.body;\n      if (hasBody) {\n        const {\n          key\n        } = method;\n        this.raise(TSErrors.AbstractMethodHasImplementation, method, {\n          methodName: key.type === \"Identifier\" && !method.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`\n        });\n      }\n    }\n    return method;\n  }\n  tsParseTypeParameterName() {\n    const typeName = this.parseIdentifier();\n    return typeName.name;\n  }\n  shouldParseAsAmbientContext() {\n    return !!this.getPluginOption(\"typescript\", \"dts\");\n  }\n  parse() {\n    if (this.shouldParseAsAmbientContext()) {\n      this.state.isAmbientContext = true;\n    }\n    return super.parse();\n  }\n  getExpression() {\n    if (this.shouldParseAsAmbientContext()) {\n      this.state.isAmbientContext = true;\n    }\n    return super.getExpression();\n  }\n  parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {\n    if (!isString && isMaybeTypeOnly) {\n      this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);\n      return this.finishNode(node, \"ExportSpecifier\");\n    }\n    node.exportKind = \"value\";\n    return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly);\n  }\n  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {\n    if (!importedIsString && isMaybeTypeOnly) {\n      this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);\n      return this.finishNode(specifier, \"ImportSpecifier\");\n    }\n    specifier.importKind = \"value\";\n    return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? 4098 : 4096);\n  }\n  parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) {\n    const leftOfAsKey = isImport ? \"imported\" : \"local\";\n    const rightOfAsKey = isImport ? \"local\" : \"exported\";\n    let leftOfAs = node[leftOfAsKey];\n    let rightOfAs;\n    let hasTypeSpecifier = false;\n    let canParseAsKeyword = true;\n    const loc = leftOfAs.loc.start;\n    if (this.isContextual(93)) {\n      const firstAs = this.parseIdentifier();\n      if (this.isContextual(93)) {\n        const secondAs = this.parseIdentifier();\n        if (tokenIsKeywordOrIdentifier(this.state.type)) {\n          hasTypeSpecifier = true;\n          leftOfAs = firstAs;\n          rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();\n          canParseAsKeyword = false;\n        } else {\n          rightOfAs = secondAs;\n          canParseAsKeyword = false;\n        }\n      } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n        canParseAsKeyword = false;\n        rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();\n      } else {\n        hasTypeSpecifier = true;\n        leftOfAs = firstAs;\n      }\n    } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n      hasTypeSpecifier = true;\n      if (isImport) {\n        leftOfAs = this.parseIdentifier(true);\n        if (!this.isContextual(93)) {\n          this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);\n        }\n      } else {\n        leftOfAs = this.parseModuleExportName();\n      }\n    }\n    if (hasTypeSpecifier && isInTypeOnlyImportExport) {\n      this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, loc);\n    }\n    node[leftOfAsKey] = leftOfAs;\n    node[rightOfAsKey] = rightOfAs;\n    const kindKey = isImport ? \"importKind\" : \"exportKind\";\n    node[kindKey] = hasTypeSpecifier ? \"type\" : \"value\";\n    if (canParseAsKeyword && this.eatContextual(93)) {\n      node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();\n    }\n    if (!node[rightOfAsKey]) {\n      node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]);\n    }\n    if (isImport) {\n      this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? 4098 : 4096);\n    }\n  }\n};\nfunction isPossiblyLiteralEnum(expression) {\n  if (expression.type !== \"MemberExpression\") return false;\n  const {\n    computed,\n    property\n  } = expression;\n  if (computed && property.type !== \"StringLiteral\" && (property.type !== \"TemplateLiteral\" || property.expressions.length > 0)) {\n    return false;\n  }\n  return isUncomputedMemberExpressionChain(expression.object);\n}\nfunction isValidAmbientConstInitializer(expression, estree) {\n  var _expression$extra;\n  const {\n    type\n  } = expression;\n  if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) {\n    return false;\n  }\n  if (estree) {\n    if (type === \"Literal\") {\n      const {\n        value\n      } = expression;\n      if (typeof value === \"string\" || typeof value === \"boolean\") {\n        return true;\n      }\n    }\n  } else {\n    if (type === \"StringLiteral\" || type === \"BooleanLiteral\") {\n      return true;\n    }\n  }\n  if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) {\n    return true;\n  }\n  if (type === \"TemplateLiteral\" && expression.expressions.length === 0) {\n    return true;\n  }\n  if (isPossiblyLiteralEnum(expression)) {\n    return true;\n  }\n  return false;\n}\nfunction isNumber(expression, estree) {\n  if (estree) {\n    return expression.type === \"Literal\" && (typeof expression.value === \"number\" || \"bigint\" in expression);\n  }\n  return expression.type === \"NumericLiteral\" || expression.type === \"BigIntLiteral\";\n}\nfunction isNegativeNumber(expression, estree) {\n  if (expression.type === \"UnaryExpression\") {\n    const {\n      operator,\n      argument\n    } = expression;\n    if (operator === \"-\" && isNumber(argument, estree)) {\n      return true;\n    }\n  }\n  return false;\n}\nfunction isUncomputedMemberExpressionChain(expression) {\n  if (expression.type === \"Identifier\") return true;\n  if (expression.type !== \"MemberExpression\" || expression.computed) {\n    return false;\n  }\n  return isUncomputedMemberExpressionChain(expression.object);\n}\nconst PlaceholderErrors = ParseErrorEnum`placeholders`({\n  ClassNameIsRequired: \"A class name is required.\",\n  UnexpectedSpace: \"Unexpected space in placeholder.\"\n});\nvar placeholders = superClass => class PlaceholdersParserMixin extends superClass {\n  parsePlaceholder(expectedNode) {\n    if (this.match(144)) {\n      const node = this.startNode();\n      this.next();\n      this.assertNoSpace();\n      node.name = super.parseIdentifier(true);\n      this.assertNoSpace();\n      this.expect(144);\n      return this.finishPlaceholder(node, expectedNode);\n    }\n  }\n  finishPlaceholder(node, expectedNode) {\n    let placeholder = node;\n    if (!placeholder.expectedNode || !placeholder.type) {\n      placeholder = this.finishNode(placeholder, \"Placeholder\");\n    }\n    placeholder.expectedNode = expectedNode;\n    return placeholder;\n  }\n  getTokenFromCode(code) {\n    if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {\n      this.finishOp(144, 2);\n    } else {\n      super.getTokenFromCode(code);\n    }\n  }\n  parseExprAtom(refExpressionErrors) {\n    return this.parsePlaceholder(\"Expression\") || super.parseExprAtom(refExpressionErrors);\n  }\n  parseIdentifier(liberal) {\n    return this.parsePlaceholder(\"Identifier\") || super.parseIdentifier(liberal);\n  }\n  checkReservedWord(word, startLoc, checkKeywords, isBinding) {\n    if (word !== undefined) {\n      super.checkReservedWord(word, startLoc, checkKeywords, isBinding);\n    }\n  }\n  parseBindingAtom() {\n    return this.parsePlaceholder(\"Pattern\") || super.parseBindingAtom();\n  }\n  isValidLVal(type, isParenthesized, binding) {\n    return type === \"Placeholder\" || super.isValidLVal(type, isParenthesized, binding);\n  }\n  toAssignable(node, isLHS) {\n    if (node && node.type === \"Placeholder\" && node.expectedNode === \"Expression\") {\n      node.expectedNode = \"Pattern\";\n    } else {\n      super.toAssignable(node, isLHS);\n    }\n  }\n  chStartsBindingIdentifier(ch, pos) {\n    if (super.chStartsBindingIdentifier(ch, pos)) {\n      return true;\n    }\n    const nextToken = this.lookahead();\n    if (nextToken.type === 144) {\n      return true;\n    }\n    return false;\n  }\n  verifyBreakContinue(node, isBreak) {\n    if (node.label && node.label.type === \"Placeholder\") return;\n    super.verifyBreakContinue(node, isBreak);\n  }\n  parseExpressionStatement(node, expr) {\n    var _expr$extra;\n    if (expr.type !== \"Placeholder\" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {\n      return super.parseExpressionStatement(node, expr);\n    }\n    if (this.match(14)) {\n      const stmt = node;\n      stmt.label = this.finishPlaceholder(expr, \"Identifier\");\n      this.next();\n      stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();\n      return this.finishNode(stmt, \"LabeledStatement\");\n    }\n    this.semicolon();\n    const stmtPlaceholder = node;\n    stmtPlaceholder.name = expr.name;\n    return this.finishPlaceholder(stmtPlaceholder, \"Statement\");\n  }\n  parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {\n    return this.parsePlaceholder(\"BlockStatement\") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);\n  }\n  parseFunctionId(requireId) {\n    return this.parsePlaceholder(\"Identifier\") || super.parseFunctionId(requireId);\n  }\n  parseClass(node, isStatement, optionalId) {\n    const type = isStatement ? \"ClassDeclaration\" : \"ClassExpression\";\n    this.next();\n    const oldStrict = this.state.strict;\n    const placeholder = this.parsePlaceholder(\"Identifier\");\n    if (placeholder) {\n      if (this.match(81) || this.match(144) || this.match(5)) {\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        throw this.raise(PlaceholderErrors.ClassNameIsRequired, this.state.startLoc);\n      }\n    } else {\n      this.parseClassId(node, isStatement, optionalId);\n    }\n    super.parseClassSuper(node);\n    node.body = this.parsePlaceholder(\"ClassBody\") || super.parseClassBody(!!node.superClass, oldStrict);\n    return this.finishNode(node, type);\n  }\n  parseExport(node, decorators) {\n    const placeholder = this.parsePlaceholder(\"Identifier\");\n    if (!placeholder) return super.parseExport(node, decorators);\n    const node2 = node;\n    if (!this.isContextual(98) && !this.match(12)) {\n      node2.specifiers = [];\n      node2.source = null;\n      node2.declaration = this.finishPlaceholder(placeholder, \"Declaration\");\n      return this.finishNode(node2, \"ExportNamedDeclaration\");\n    }\n    this.expectPlugin(\"exportDefaultFrom\");\n    const specifier = this.startNode();\n    specifier.exported = placeholder;\n    node2.specifiers = [this.finishNode(specifier, \"ExportDefaultSpecifier\")];\n    return super.parseExport(node2, decorators);\n  }\n  isExportDefaultSpecifier() {\n    if (this.match(65)) {\n      const next = this.nextTokenStart();\n      if (this.isUnparsedContextual(next, \"from\")) {\n        if (this.input.startsWith(tokenLabelName(144), this.nextTokenStartSince(next + 4))) {\n          return true;\n        }\n      }\n    }\n    return super.isExportDefaultSpecifier();\n  }\n  maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {\n    var _specifiers;\n    if ((_specifiers = node.specifiers) != null && _specifiers.length) {\n      return true;\n    }\n    return super.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);\n  }\n  checkExport(node) {\n    const {\n      specifiers\n    } = node;\n    if (specifiers != null && specifiers.length) {\n      node.specifiers = specifiers.filter(node => node.exported.type === \"Placeholder\");\n    }\n    super.checkExport(node);\n    node.specifiers = specifiers;\n  }\n  parseImport(node) {\n    const placeholder = this.parsePlaceholder(\"Identifier\");\n    if (!placeholder) return super.parseImport(node);\n    node.specifiers = [];\n    if (!this.isContextual(98) && !this.match(12)) {\n      node.source = this.finishPlaceholder(placeholder, \"StringLiteral\");\n      this.semicolon();\n      return this.finishNode(node, \"ImportDeclaration\");\n    }\n    const specifier = this.startNodeAtNode(placeholder);\n    specifier.local = placeholder;\n    node.specifiers.push(this.finishNode(specifier, \"ImportDefaultSpecifier\"));\n    if (this.eat(12)) {\n      const hasStarImport = this.maybeParseStarImportSpecifier(node);\n      if (!hasStarImport) this.parseNamedImportSpecifiers(node);\n    }\n    this.expectContextual(98);\n    node.source = this.parseImportSource();\n    this.semicolon();\n    return this.finishNode(node, \"ImportDeclaration\");\n  }\n  parseImportSource() {\n    return this.parsePlaceholder(\"StringLiteral\") || super.parseImportSource();\n  }\n  assertNoSpace() {\n    if (this.state.start > this.state.lastTokEndLoc.index) {\n      this.raise(PlaceholderErrors.UnexpectedSpace, this.state.lastTokEndLoc);\n    }\n  }\n};\nvar v8intrinsic = superClass => class V8IntrinsicMixin extends superClass {\n  parseV8Intrinsic() {\n    if (this.match(54)) {\n      const v8IntrinsicStartLoc = this.state.startLoc;\n      const node = this.startNode();\n      this.next();\n      if (tokenIsIdentifier(this.state.type)) {\n        const name = this.parseIdentifierName();\n        const identifier = this.createIdentifier(node, name);\n        identifier.type = \"V8IntrinsicIdentifier\";\n        if (this.match(10)) {\n          return identifier;\n        }\n      }\n      this.unexpected(v8IntrinsicStartLoc);\n    }\n  }\n  parseExprAtom(refExpressionErrors) {\n    return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);\n  }\n};\nconst PIPELINE_PROPOSALS = [\"minimal\", \"fsharp\", \"hack\", \"smart\"];\nconst TOPIC_TOKENS = [\"^^\", \"@@\", \"^\", \"%\", \"#\"];\nfunction validatePlugins(pluginsMap) {\n  if (pluginsMap.has(\"decorators\")) {\n    if (pluginsMap.has(\"decorators-legacy\")) {\n      throw new Error(\"Cannot use the decorators and decorators-legacy plugin together\");\n    }\n    const decoratorsBeforeExport = pluginsMap.get(\"decorators\").decoratorsBeforeExport;\n    if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== \"boolean\") {\n      throw new Error(\"'decoratorsBeforeExport' must be a boolean, if specified.\");\n    }\n    const allowCallParenthesized = pluginsMap.get(\"decorators\").allowCallParenthesized;\n    if (allowCallParenthesized != null && typeof allowCallParenthesized !== \"boolean\") {\n      throw new Error(\"'allowCallParenthesized' must be a boolean.\");\n    }\n  }\n  if (pluginsMap.has(\"flow\") && pluginsMap.has(\"typescript\")) {\n    throw new Error(\"Cannot combine flow and typescript plugins.\");\n  }\n  if (pluginsMap.has(\"placeholders\") && pluginsMap.has(\"v8intrinsic\")) {\n    throw new Error(\"Cannot combine placeholders and v8intrinsic plugins.\");\n  }\n  if (pluginsMap.has(\"pipelineOperator\")) {\n    var _pluginsMap$get;\n    const proposal = pluginsMap.get(\"pipelineOperator\").proposal;\n    if (!PIPELINE_PROPOSALS.includes(proposal)) {\n      const proposalList = PIPELINE_PROPOSALS.map(p => `\"${p}\"`).join(\", \");\n      throw new Error(`\"pipelineOperator\" requires \"proposal\" option whose value must be one of: ${proposalList}.`);\n    }\n    const tupleSyntaxIsHash = ((_pluginsMap$get = pluginsMap.get(\"recordAndTuple\")) == null ? void 0 : _pluginsMap$get.syntaxType) === \"hash\";\n    if (proposal === \"hack\") {\n      if (pluginsMap.has(\"placeholders\")) {\n        throw new Error(\"Cannot combine placeholders plugin and Hack-style pipes.\");\n      }\n      if (pluginsMap.has(\"v8intrinsic\")) {\n        throw new Error(\"Cannot combine v8intrinsic plugin and Hack-style pipes.\");\n      }\n      const topicToken = pluginsMap.get(\"pipelineOperator\").topicToken;\n      if (!TOPIC_TOKENS.includes(topicToken)) {\n        const tokenList = TOPIC_TOKENS.map(t => `\"${t}\"`).join(\", \");\n        throw new Error(`\"pipelineOperator\" in \"proposal\": \"hack\" mode also requires a \"topicToken\" option whose value must be one of: ${tokenList}.`);\n      }\n      if (topicToken === \"#\" && tupleSyntaxIsHash) {\n        throw new Error(`Plugin conflict between \\`[\"pipelineOperator\", { proposal: \"hack\", topicToken: \"#\" }]\\` and \\`${JSON.stringify([\"recordAndTuple\", pluginsMap.get(\"recordAndTuple\")])}\\`.`);\n      }\n    } else if (proposal === \"smart\" && tupleSyntaxIsHash) {\n      throw new Error(`Plugin conflict between \\`[\"pipelineOperator\", { proposal: \"smart\" }]\\` and \\`${JSON.stringify([\"recordAndTuple\", pluginsMap.get(\"recordAndTuple\")])}\\`.`);\n    }\n  }\n  if (pluginsMap.has(\"moduleAttributes\")) {\n    {\n      if (pluginsMap.has(\"importAttributes\") || pluginsMap.has(\"importAssertions\")) {\n        throw new Error(\"Cannot combine importAssertions, importAttributes and moduleAttributes plugins.\");\n      }\n      const moduleAttributesVersionPluginOption = pluginsMap.get(\"moduleAttributes\").version;\n      if (moduleAttributesVersionPluginOption !== \"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 (pluginsMap.has(\"importAttributes\") && pluginsMap.has(\"importAssertions\")) {\n    throw new Error(\"Cannot combine importAssertions and importAttributes plugins.\");\n  }\n  if (pluginsMap.has(\"recordAndTuple\")) {\n    const syntaxType = pluginsMap.get(\"recordAndTuple\").syntaxType;\n    if (syntaxType != null) {\n      {\n        const RECORD_AND_TUPLE_SYNTAX_TYPES = [\"hash\", \"bar\"];\n        if (!RECORD_AND_TUPLE_SYNTAX_TYPES.includes(syntaxType)) {\n          throw new Error(\"The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: \" + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(\", \"));\n        }\n      }\n    }\n  }\n  if (pluginsMap.has(\"asyncDoExpressions\") && !pluginsMap.has(\"doExpressions\")) {\n    const error = new Error(\"'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.\");\n    error.missingPlugins = \"doExpressions\";\n    throw error;\n  }\n  if (pluginsMap.has(\"optionalChainingAssign\") && pluginsMap.get(\"optionalChainingAssign\").version !== \"2023-07\") {\n    throw new Error(\"The 'optionalChainingAssign' plugin requires a 'version' option,\" + \" representing the last proposal update. Currently, the\" + \" only supported value is '2023-07'.\");\n  }\n}\nconst mixinPlugins = {\n  estree,\n  jsx,\n  flow,\n  typescript,\n  v8intrinsic,\n  placeholders\n};\nconst mixinPluginNames = Object.keys(mixinPlugins);\nconst defaultOptions = {\n  sourceType: \"script\",\n  sourceFilename: undefined,\n  startColumn: 0,\n  startLine: 1,\n  allowAwaitOutsideFunction: false,\n  allowReturnOutsideFunction: false,\n  allowNewTargetOutsideFunction: false,\n  allowImportExportEverywhere: false,\n  allowSuperOutsideMethod: false,\n  allowUndeclaredExports: false,\n  plugins: [],\n  strictMode: null,\n  ranges: false,\n  tokens: false,\n  createImportExpressions: false,\n  createParenthesizedExpressions: false,\n  errorRecovery: false,\n  attachComment: true,\n  annexB: true\n};\nfunction getOptions(opts) {\n  if (opts == null) {\n    return Object.assign({}, defaultOptions);\n  }\n  if (opts.annexB != null && opts.annexB !== false) {\n    throw new Error(\"The `annexB` option can only be set to `false`.\");\n  }\n  const options = {};\n  for (const key of Object.keys(defaultOptions)) {\n    var _opts$key;\n    options[key] = (_opts$key = opts[key]) != null ? _opts$key : defaultOptions[key];\n  }\n  return options;\n}\nclass ExpressionParser extends LValParser {\n  checkProto(prop, isRecord, protoRef, refExpressionErrors) {\n    if (prop.type === \"SpreadElement\" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) {\n      return;\n    }\n    const key = prop.key;\n    const name = key.type === \"Identifier\" ? key.name : key.value;\n    if (name === \"__proto__\") {\n      if (isRecord) {\n        this.raise(Errors.RecordNoProto, key);\n        return;\n      }\n      if (protoRef.used) {\n        if (refExpressionErrors) {\n          if (refExpressionErrors.doubleProtoLoc === null) {\n            refExpressionErrors.doubleProtoLoc = key.loc.start;\n          }\n        } else {\n          this.raise(Errors.DuplicateProto, key);\n        }\n      }\n      protoRef.used = true;\n    }\n  }\n  shouldExitDescending(expr, potentialArrowAt) {\n    return expr.type === \"ArrowFunctionExpression\" && expr.start === potentialArrowAt;\n  }\n  getExpression() {\n    this.enterInitialScopes();\n    this.nextToken();\n    const expr = this.parseExpression();\n    if (!this.match(139)) {\n      this.unexpected();\n    }\n    this.finalizeRemainingComments();\n    expr.comments = this.comments;\n    expr.errors = this.state.errors;\n    if (this.options.tokens) {\n      expr.tokens = this.tokens;\n    }\n    return expr;\n  }\n  parseExpression(disallowIn, refExpressionErrors) {\n    if (disallowIn) {\n      return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors));\n    }\n    return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));\n  }\n  parseExpressionBase(refExpressionErrors) {\n    const startLoc = this.state.startLoc;\n    const expr = this.parseMaybeAssign(refExpressionErrors);\n    if (this.match(12)) {\n      const node = this.startNodeAt(startLoc);\n      node.expressions = [expr];\n      while (this.eat(12)) {\n        node.expressions.push(this.parseMaybeAssign(refExpressionErrors));\n      }\n      this.toReferencedList(node.expressions);\n      return this.finishNode(node, \"SequenceExpression\");\n    }\n    return expr;\n  }\n  parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) {\n    return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));\n  }\n  parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) {\n    return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));\n  }\n  setOptionalParametersError(refExpressionErrors, resultError) {\n    var _resultError$loc;\n    refExpressionErrors.optionalParametersLoc = (_resultError$loc = resultError == null ? void 0 : resultError.loc) != null ? _resultError$loc : this.state.startLoc;\n  }\n  parseMaybeAssign(refExpressionErrors, afterLeftParse) {\n    const startLoc = this.state.startLoc;\n    if (this.isContextual(108)) {\n      if (this.prodParam.hasYield) {\n        let left = this.parseYield();\n        if (afterLeftParse) {\n          left = afterLeftParse.call(this, left, startLoc);\n        }\n        return left;\n      }\n    }\n    let ownExpressionErrors;\n    if (refExpressionErrors) {\n      ownExpressionErrors = false;\n    } else {\n      refExpressionErrors = new ExpressionErrors();\n      ownExpressionErrors = true;\n    }\n    const {\n      type\n    } = this.state;\n    if (type === 10 || tokenIsIdentifier(type)) {\n      this.state.potentialArrowAt = this.state.start;\n    }\n    let left = this.parseMaybeConditional(refExpressionErrors);\n    if (afterLeftParse) {\n      left = afterLeftParse.call(this, left, startLoc);\n    }\n    if (tokenIsAssignment(this.state.type)) {\n      const node = this.startNodeAt(startLoc);\n      const operator = this.state.value;\n      node.operator = operator;\n      if (this.match(29)) {\n        this.toAssignable(left, true);\n        node.left = left;\n        const startIndex = startLoc.index;\n        if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startIndex) {\n          refExpressionErrors.doubleProtoLoc = null;\n        }\n        if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startIndex) {\n          refExpressionErrors.shorthandAssignLoc = null;\n        }\n        if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startIndex) {\n          this.checkDestructuringPrivate(refExpressionErrors);\n          refExpressionErrors.privateKeyLoc = null;\n        }\n      } else {\n        node.left = left;\n      }\n      this.next();\n      node.right = this.parseMaybeAssign();\n      this.checkLVal(left, this.finishNode(node, \"AssignmentExpression\"));\n      return node;\n    } else if (ownExpressionErrors) {\n      this.checkExpressionErrors(refExpressionErrors, true);\n    }\n    return left;\n  }\n  parseMaybeConditional(refExpressionErrors) {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseExprOps(refExpressionErrors);\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n    return this.parseConditional(expr, startLoc, refExpressionErrors);\n  }\n  parseConditional(expr, startLoc, refExpressionErrors) {\n    if (this.eat(17)) {\n      const node = this.startNodeAt(startLoc);\n      node.test = expr;\n      node.consequent = this.parseMaybeAssignAllowIn();\n      this.expect(14);\n      node.alternate = this.parseMaybeAssign();\n      return this.finishNode(node, \"ConditionalExpression\");\n    }\n    return expr;\n  }\n  parseMaybeUnaryOrPrivate(refExpressionErrors) {\n    return this.match(138) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);\n  }\n  parseExprOps(refExpressionErrors) {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n    return this.parseExprOp(expr, startLoc, -1);\n  }\n  parseExprOp(left, leftStartLoc, minPrec) {\n    if (this.isPrivateName(left)) {\n      const value = this.getPrivateNameSV(left);\n      if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) {\n        this.raise(Errors.PrivateInExpectedIn, left, {\n          identifierName: value\n        });\n      }\n      this.classScope.usePrivateName(value, left.loc.start);\n    }\n    const op = this.state.type;\n    if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) {\n      let prec = tokenOperatorPrecedence(op);\n      if (prec > minPrec) {\n        if (op === 39) {\n          this.expectPlugin(\"pipelineOperator\");\n          if (this.state.inFSharpPipelineDirectBody) {\n            return left;\n          }\n          this.checkPipelineAtInfixOperator(left, leftStartLoc);\n        }\n        const node = this.startNodeAt(leftStartLoc);\n        node.left = left;\n        node.operator = this.state.value;\n        const logical = op === 41 || op === 42;\n        const coalesce = op === 40;\n        if (coalesce) {\n          prec = tokenOperatorPrecedence(42);\n        }\n        this.next();\n        if (op === 39 && this.hasPlugin([\"pipelineOperator\", {\n          proposal: \"minimal\"\n        }])) {\n          if (this.state.type === 96 && this.prodParam.hasAwait) {\n            throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, this.state.startLoc);\n          }\n        }\n        node.right = this.parseExprOpRightExpr(op, prec);\n        const finishedNode = this.finishNode(node, logical || coalesce ? \"LogicalExpression\" : \"BinaryExpression\");\n        const nextOp = this.state.type;\n        if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) {\n          throw this.raise(Errors.MixingCoalesceWithLogical, this.state.startLoc);\n        }\n        return this.parseExprOp(finishedNode, leftStartLoc, minPrec);\n      }\n    }\n    return left;\n  }\n  parseExprOpRightExpr(op, prec) {\n    const startLoc = this.state.startLoc;\n    switch (op) {\n      case 39:\n        switch (this.getPluginOption(\"pipelineOperator\", \"proposal\")) {\n          case \"hack\":\n            return this.withTopicBindingContext(() => {\n              return this.parseHackPipeBody();\n            });\n          case \"smart\":\n            return this.withTopicBindingContext(() => {\n              if (this.prodParam.hasYield && this.isContextual(108)) {\n                throw this.raise(Errors.PipeBodyIsTighter, this.state.startLoc);\n              }\n              return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);\n            });\n          case \"fsharp\":\n            return this.withSoloAwaitPermittingContext(() => {\n              return this.parseFSharpPipelineBody(prec);\n            });\n        }\n      default:\n        return this.parseExprOpBaseRightExpr(op, prec);\n    }\n  }\n  parseExprOpBaseRightExpr(op, prec) {\n    const startLoc = this.state.startLoc;\n    return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec);\n  }\n  parseHackPipeBody() {\n    var _body$extra;\n    const {\n      startLoc\n    } = this.state;\n    const body = this.parseMaybeAssign();\n    const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(body.type);\n    if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) {\n      this.raise(Errors.PipeUnparenthesizedBody, startLoc, {\n        type: body.type\n      });\n    }\n    if (!this.topicReferenceWasUsedInCurrentContext()) {\n      this.raise(Errors.PipeTopicUnused, startLoc);\n    }\n    return body;\n  }\n  checkExponentialAfterUnary(node) {\n    if (this.match(57)) {\n      this.raise(Errors.UnexpectedTokenUnaryExponentiation, node.argument);\n    }\n  }\n  parseMaybeUnary(refExpressionErrors, sawUnary) {\n    const startLoc = this.state.startLoc;\n    const isAwait = this.isContextual(96);\n    if (isAwait && this.recordAwaitIfAllowed()) {\n      this.next();\n      const expr = this.parseAwait(startLoc);\n      if (!sawUnary) this.checkExponentialAfterUnary(expr);\n      return expr;\n    }\n    const update = this.match(34);\n    const node = this.startNode();\n    if (tokenIsPrefix(this.state.type)) {\n      node.operator = this.state.value;\n      node.prefix = true;\n      if (this.match(72)) {\n        this.expectPlugin(\"throwExpressions\");\n      }\n      const isDelete = this.match(89);\n      this.next();\n      node.argument = this.parseMaybeUnary(null, true);\n      this.checkExpressionErrors(refExpressionErrors, true);\n      if (this.state.strict && isDelete) {\n        const arg = node.argument;\n        if (arg.type === \"Identifier\") {\n          this.raise(Errors.StrictDelete, node);\n        } else if (this.hasPropertyAsPrivateName(arg)) {\n          this.raise(Errors.DeletePrivateField, node);\n        }\n      }\n      if (!update) {\n        if (!sawUnary) {\n          this.checkExponentialAfterUnary(node);\n        }\n        return this.finishNode(node, \"UnaryExpression\");\n      }\n    }\n    const expr = this.parseUpdate(node, update, refExpressionErrors);\n    if (isAwait) {\n      const {\n        type\n      } = this.state;\n      const startsExpr = this.hasPlugin(\"v8intrinsic\") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54);\n      if (startsExpr && !this.isAmbiguousAwait()) {\n        this.raiseOverwrite(Errors.AwaitNotInAsyncContext, startLoc);\n        return this.parseAwait(startLoc);\n      }\n    }\n    return expr;\n  }\n  parseUpdate(node, update, refExpressionErrors) {\n    if (update) {\n      const updateExpressionNode = node;\n      this.checkLVal(updateExpressionNode.argument, this.finishNode(updateExpressionNode, \"UpdateExpression\"));\n      return node;\n    }\n    const startLoc = this.state.startLoc;\n    let expr = this.parseExprSubscripts(refExpressionErrors);\n    if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;\n    while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {\n      const node = this.startNodeAt(startLoc);\n      node.operator = this.state.value;\n      node.prefix = false;\n      node.argument = expr;\n      this.next();\n      this.checkLVal(expr, expr = this.finishNode(node, \"UpdateExpression\"));\n    }\n    return expr;\n  }\n  parseExprSubscripts(refExpressionErrors) {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseExprAtom(refExpressionErrors);\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n    return this.parseSubscripts(expr, startLoc);\n  }\n  parseSubscripts(base, startLoc, noCalls) {\n    const state = {\n      optionalChainMember: false,\n      maybeAsyncArrow: this.atPossibleAsyncArrow(base),\n      stop: false\n    };\n    do {\n      base = this.parseSubscript(base, startLoc, noCalls, state);\n      state.maybeAsyncArrow = false;\n    } while (!state.stop);\n    return base;\n  }\n  parseSubscript(base, startLoc, noCalls, state) {\n    const {\n      type\n    } = this.state;\n    if (!noCalls && type === 15) {\n      return this.parseBind(base, startLoc, noCalls, state);\n    } else if (tokenIsTemplate(type)) {\n      return this.parseTaggedTemplateExpression(base, startLoc, state);\n    }\n    let optional = false;\n    if (type === 18) {\n      if (noCalls) {\n        this.raise(Errors.OptionalChainingNoNew, this.state.startLoc);\n        if (this.lookaheadCharCode() === 40) {\n          state.stop = true;\n          return base;\n        }\n      }\n      state.optionalChainMember = optional = true;\n      this.next();\n    }\n    if (!noCalls && this.match(10)) {\n      return this.parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional);\n    } else {\n      const computed = this.eat(0);\n      if (computed || optional || this.eat(16)) {\n        return this.parseMember(base, startLoc, state, computed, optional);\n      } else {\n        state.stop = true;\n        return base;\n      }\n    }\n  }\n  parseMember(base, startLoc, state, computed, optional) {\n    const node = this.startNodeAt(startLoc);\n    node.object = base;\n    node.computed = computed;\n    if (computed) {\n      node.property = this.parseExpression();\n      this.expect(3);\n    } else if (this.match(138)) {\n      if (base.type === \"Super\") {\n        this.raise(Errors.SuperPrivateField, startLoc);\n      }\n      this.classScope.usePrivateName(this.state.value, this.state.startLoc);\n      node.property = this.parsePrivateName();\n    } else {\n      node.property = this.parseIdentifier(true);\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  parseBind(base, startLoc, noCalls, state) {\n    const node = this.startNodeAt(startLoc);\n    node.object = base;\n    this.next();\n    node.callee = this.parseNoCallExpr();\n    state.stop = true;\n    return this.parseSubscripts(this.finishNode(node, \"BindExpression\"), startLoc, noCalls);\n  }\n  parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional) {\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    let refExpressionErrors = null;\n    this.state.maybeInArrowParameters = true;\n    this.next();\n    const node = this.startNodeAt(startLoc);\n    node.callee = base;\n    const {\n      maybeAsyncArrow,\n      optionalChainMember\n    } = state;\n    if (maybeAsyncArrow) {\n      this.expressionScope.enter(newAsyncArrowScope());\n      refExpressionErrors = new ExpressionErrors();\n    }\n    if (optionalChainMember) {\n      node.optional = optional;\n    }\n    if (optional) {\n      node.arguments = this.parseCallExpressionArguments(11);\n    } else {\n      node.arguments = this.parseCallExpressionArguments(11, base.type === \"Import\", base.type !== \"Super\", node, refExpressionErrors);\n    }\n    let finishedNode = this.finishCallExpression(node, optionalChainMember);\n    if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {\n      state.stop = true;\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.expressionScope.validateAsPattern();\n      this.expressionScope.exit();\n      finishedNode = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startLoc), finishedNode);\n    } else {\n      if (maybeAsyncArrow) {\n        this.checkExpressionErrors(refExpressionErrors, true);\n        this.expressionScope.exit();\n      }\n      this.toReferencedArguments(finishedNode);\n    }\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    return finishedNode;\n  }\n  toReferencedArguments(node, isParenthesizedExpr) {\n    this.toReferencedListDeep(node.arguments, isParenthesizedExpr);\n  }\n  parseTaggedTemplateExpression(base, startLoc, state) {\n    const node = this.startNodeAt(startLoc);\n    node.tag = base;\n    node.quasi = this.parseTemplate(true);\n    if (state.optionalChainMember) {\n      this.raise(Errors.OptionalChainingNoTemplate, startLoc);\n    }\n    return this.finishNode(node, \"TaggedTemplateExpression\");\n  }\n  atPossibleAsyncArrow(base) {\n    return base.type === \"Identifier\" && base.name === \"async\" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt;\n  }\n  expectImportAttributesPlugin() {\n    if (!this.hasPlugin(\"importAssertions\")) {\n      this.expectPlugin(\"importAttributes\");\n    }\n  }\n  finishCallExpression(node, optional) {\n    if (node.callee.type === \"Import\") {\n      if (node.arguments.length === 2) {\n        {\n          if (!this.hasPlugin(\"moduleAttributes\")) {\n            this.expectImportAttributesPlugin();\n          }\n        }\n      }\n      if (node.arguments.length === 0 || node.arguments.length > 2) {\n        this.raise(Errors.ImportCallArity, node, {\n          maxArgumentCount: this.hasPlugin(\"importAttributes\") || this.hasPlugin(\"importAssertions\") || this.hasPlugin(\"moduleAttributes\") ? 2 : 1\n        });\n      } else {\n        for (const arg of node.arguments) {\n          if (arg.type === \"SpreadElement\") {\n            this.raise(Errors.ImportCallSpreadArgument, arg);\n          }\n        }\n      }\n    }\n    return this.finishNode(node, optional ? \"OptionalCallExpression\" : \"CallExpression\");\n  }\n  parseCallExpressionArguments(close, dynamicImport, allowPlaceholder, nodeForExtra, refExpressionErrors) {\n    const elts = [];\n    let first = true;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(12);\n        if (this.match(close)) {\n          if (dynamicImport && !this.hasPlugin(\"importAttributes\") && !this.hasPlugin(\"importAssertions\") && !this.hasPlugin(\"moduleAttributes\")) {\n            this.raise(Errors.ImportCallArgumentTrailingComma, this.state.lastTokStartLoc);\n          }\n          if (nodeForExtra) {\n            this.addTrailingCommaExtraToNode(nodeForExtra);\n          }\n          this.next();\n          break;\n        }\n      }\n      elts.push(this.parseExprListItem(false, refExpressionErrors, allowPlaceholder));\n    }\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    return elts;\n  }\n  shouldParseAsyncArrow() {\n    return this.match(19) && !this.canInsertSemicolon();\n  }\n  parseAsyncArrowFromCallExpression(node, call) {\n    var _call$extra;\n    this.resetPreviousNodeTrailingComments(call);\n    this.expect(19);\n    this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc);\n    if (call.innerComments) {\n      setInnerComments(node, call.innerComments);\n    }\n    if (call.callee.trailingComments) {\n      setInnerComments(node, call.callee.trailingComments);\n    }\n    return node;\n  }\n  parseNoCallExpr() {\n    const startLoc = this.state.startLoc;\n    return this.parseSubscripts(this.parseExprAtom(), startLoc, true);\n  }\n  parseExprAtom(refExpressionErrors) {\n    let node;\n    let decorators = null;\n    const {\n      type\n    } = this.state;\n    switch (type) {\n      case 79:\n        return this.parseSuper();\n      case 83:\n        node = this.startNode();\n        this.next();\n        if (this.match(16)) {\n          return this.parseImportMetaProperty(node);\n        }\n        if (this.match(10)) {\n          if (this.options.createImportExpressions) {\n            return this.parseImportCall(node);\n          } else {\n            return this.finishNode(node, \"Import\");\n          }\n        } else {\n          this.raise(Errors.UnsupportedImport, this.state.lastTokStartLoc);\n          return this.finishNode(node, \"Import\");\n        }\n      case 78:\n        node = this.startNode();\n        this.next();\n        return this.finishNode(node, \"ThisExpression\");\n      case 90:\n        {\n          return this.parseDo(this.startNode(), false);\n        }\n      case 56:\n      case 31:\n        {\n          this.readRegexp();\n          return this.parseRegExpLiteral(this.state.value);\n        }\n      case 134:\n        return this.parseNumericLiteral(this.state.value);\n      case 135:\n        return this.parseBigIntLiteral(this.state.value);\n      case 136:\n        return this.parseDecimalLiteral(this.state.value);\n      case 133:\n        return this.parseStringLiteral(this.state.value);\n      case 84:\n        return this.parseNullLiteral();\n      case 85:\n        return this.parseBooleanLiteral(true);\n      case 86:\n        return this.parseBooleanLiteral(false);\n      case 10:\n        {\n          const canBeArrow = this.state.potentialArrowAt === this.state.start;\n          return this.parseParenAndDistinguishExpression(canBeArrow);\n        }\n      case 2:\n      case 1:\n        {\n          return this.parseArrayLike(this.state.type === 2 ? 4 : 3, false, true);\n        }\n      case 0:\n        {\n          return this.parseArrayLike(3, true, false, refExpressionErrors);\n        }\n      case 6:\n      case 7:\n        {\n          return this.parseObjectLike(this.state.type === 6 ? 9 : 8, false, true);\n        }\n      case 5:\n        {\n          return this.parseObjectLike(8, false, false, refExpressionErrors);\n        }\n      case 68:\n        return this.parseFunctionOrFunctionSent();\n      case 26:\n        decorators = this.parseDecorators();\n      case 80:\n        return this.parseClass(this.maybeTakeDecorators(decorators, this.startNode()), false);\n      case 77:\n        return this.parseNewOrNewTarget();\n      case 25:\n      case 24:\n        return this.parseTemplate(false);\n      case 15:\n        {\n          node = this.startNode();\n          this.next();\n          node.object = null;\n          const callee = node.callee = this.parseNoCallExpr();\n          if (callee.type === \"MemberExpression\") {\n            return this.finishNode(node, \"BindExpression\");\n          } else {\n            throw this.raise(Errors.UnsupportedBind, callee);\n          }\n        }\n      case 138:\n        {\n          this.raise(Errors.PrivateInExpectedIn, this.state.startLoc, {\n            identifierName: this.state.value\n          });\n          return this.parsePrivateName();\n        }\n      case 33:\n        {\n          return this.parseTopicReferenceThenEqualsSign(54, \"%\");\n        }\n      case 32:\n        {\n          return this.parseTopicReferenceThenEqualsSign(44, \"^\");\n        }\n      case 37:\n      case 38:\n        {\n          return this.parseTopicReference(\"hack\");\n        }\n      case 44:\n      case 54:\n      case 27:\n        {\n          const pipeProposal = this.getPluginOption(\"pipelineOperator\", \"proposal\");\n          if (pipeProposal) {\n            return this.parseTopicReference(pipeProposal);\n          }\n          this.unexpected();\n          break;\n        }\n      case 47:\n        {\n          const lookaheadCh = this.input.codePointAt(this.nextTokenStart());\n          if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) {\n            this.expectOnePlugin([\"jsx\", \"flow\", \"typescript\"]);\n          } else {\n            this.unexpected();\n          }\n          break;\n        }\n      default:\n        if (tokenIsIdentifier(type)) {\n          if (this.isContextual(127) && this.lookaheadInLineCharCode() === 123) {\n            return this.parseModuleExpression();\n          }\n          const canBeArrow = this.state.potentialArrowAt === this.state.start;\n          const containsEsc = this.state.containsEsc;\n          const id = this.parseIdentifier();\n          if (!containsEsc && id.name === \"async\" && !this.canInsertSemicolon()) {\n            const {\n              type\n            } = this.state;\n            if (type === 68) {\n              this.resetPreviousNodeTrailingComments(id);\n              this.next();\n              return this.parseAsyncFunctionExpression(this.startNodeAtNode(id));\n            } else if (tokenIsIdentifier(type)) {\n              if (this.lookaheadCharCode() === 61) {\n                return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));\n              } else {\n                return id;\n              }\n            } else if (type === 90) {\n              this.resetPreviousNodeTrailingComments(id);\n              return this.parseDo(this.startNodeAtNode(id), true);\n            }\n          }\n          if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) {\n            this.next();\n            return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);\n          }\n          return id;\n        } else {\n          this.unexpected();\n        }\n    }\n  }\n  parseTopicReferenceThenEqualsSign(topicTokenType, topicTokenValue) {\n    const pipeProposal = this.getPluginOption(\"pipelineOperator\", \"proposal\");\n    if (pipeProposal) {\n      this.state.type = topicTokenType;\n      this.state.value = topicTokenValue;\n      this.state.pos--;\n      this.state.end--;\n      this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);\n      return this.parseTopicReference(pipeProposal);\n    } else {\n      this.unexpected();\n    }\n  }\n  parseTopicReference(pipeProposal) {\n    const node = this.startNode();\n    const startLoc = this.state.startLoc;\n    const tokenType = this.state.type;\n    this.next();\n    return this.finishTopicReference(node, startLoc, pipeProposal, tokenType);\n  }\n  finishTopicReference(node, startLoc, pipeProposal, tokenType) {\n    if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {\n      const nodeType = pipeProposal === \"smart\" ? \"PipelinePrimaryTopicReference\" : \"TopicReference\";\n      if (!this.topicReferenceIsAllowedInCurrentContext()) {\n        this.raise(pipeProposal === \"smart\" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, startLoc);\n      }\n      this.registerTopicReference();\n      return this.finishNode(node, nodeType);\n    } else {\n      throw this.raise(Errors.PipeTopicUnconfiguredToken, startLoc, {\n        token: tokenLabelName(tokenType)\n      });\n    }\n  }\n  testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) {\n    switch (pipeProposal) {\n      case \"hack\":\n        {\n          return this.hasPlugin([\"pipelineOperator\", {\n            topicToken: tokenLabelName(tokenType)\n          }]);\n        }\n      case \"smart\":\n        return tokenType === 27;\n      default:\n        throw this.raise(Errors.PipeTopicRequiresHackPipes, startLoc);\n    }\n  }\n  parseAsyncArrowUnaryFunction(node) {\n    this.prodParam.enter(functionFlags(true, this.prodParam.hasYield));\n    const params = [this.parseIdentifier()];\n    this.prodParam.exit();\n    if (this.hasPrecedingLineBreak()) {\n      this.raise(Errors.LineTerminatorBeforeArrow, this.state.curPosition());\n    }\n    this.expect(19);\n    return this.parseArrowExpression(node, params, true);\n  }\n  parseDo(node, isAsync) {\n    this.expectPlugin(\"doExpressions\");\n    if (isAsync) {\n      this.expectPlugin(\"asyncDoExpressions\");\n    }\n    node.async = isAsync;\n    this.next();\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n    if (isAsync) {\n      this.prodParam.enter(2);\n      node.body = this.parseBlock();\n      this.prodParam.exit();\n    } else {\n      node.body = this.parseBlock();\n    }\n    this.state.labels = oldLabels;\n    return this.finishNode(node, \"DoExpression\");\n  }\n  parseSuper() {\n    const node = this.startNode();\n    this.next();\n    if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {\n      this.raise(Errors.SuperNotAllowed, node);\n    } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {\n      this.raise(Errors.UnexpectedSuper, node);\n    }\n    if (!this.match(10) && !this.match(0) && !this.match(16)) {\n      this.raise(Errors.UnsupportedSuper, node);\n    }\n    return this.finishNode(node, \"Super\");\n  }\n  parsePrivateName() {\n    const node = this.startNode();\n    const id = this.startNodeAt(createPositionWithColumnOffset(this.state.startLoc, 1));\n    const name = this.state.value;\n    this.next();\n    node.id = this.createIdentifier(id, name);\n    return this.finishNode(node, \"PrivateName\");\n  }\n  parseFunctionOrFunctionSent() {\n    const node = this.startNode();\n    this.next();\n    if (this.prodParam.hasYield && this.match(16)) {\n      const meta = this.createIdentifier(this.startNodeAtNode(node), \"function\");\n      this.next();\n      if (this.match(103)) {\n        this.expectPlugin(\"functionSent\");\n      } else if (!this.hasPlugin(\"functionSent\")) {\n        this.unexpected();\n      }\n      return this.parseMetaProperty(node, meta, \"sent\");\n    }\n    return this.parseFunction(node);\n  }\n  parseMetaProperty(node, meta, propertyName) {\n    node.meta = meta;\n    const containsEsc = this.state.containsEsc;\n    node.property = this.parseIdentifier(true);\n    if (node.property.name !== propertyName || containsEsc) {\n      this.raise(Errors.UnsupportedMetaProperty, node.property, {\n        target: meta.name,\n        onlyValidPropertyName: propertyName\n      });\n    }\n    return this.finishNode(node, \"MetaProperty\");\n  }\n  parseImportMetaProperty(node) {\n    const id = this.createIdentifier(this.startNodeAtNode(node), \"import\");\n    this.next();\n    if (this.isContextual(101)) {\n      if (!this.inModule) {\n        this.raise(Errors.ImportMetaOutsideModule, id);\n      }\n      this.sawUnambiguousESM = true;\n    } else if (this.isContextual(105) || this.isContextual(97)) {\n      const isSource = this.isContextual(105);\n      if (!isSource) this.unexpected();\n      this.expectPlugin(isSource ? \"sourcePhaseImports\" : \"deferredImportEvaluation\");\n      if (!this.options.createImportExpressions) {\n        throw this.raise(Errors.DynamicImportPhaseRequiresImportExpressions, this.state.startLoc, {\n          phase: this.state.value\n        });\n      }\n      this.next();\n      node.phase = isSource ? \"source\" : \"defer\";\n      return this.parseImportCall(node);\n    }\n    return this.parseMetaProperty(node, id, \"meta\");\n  }\n  parseLiteralAtNode(value, type, node) {\n    this.addExtra(node, \"rawValue\", value);\n    this.addExtra(node, \"raw\", this.input.slice(node.start, this.state.end));\n    node.value = value;\n    this.next();\n    return this.finishNode(node, type);\n  }\n  parseLiteral(value, type) {\n    const node = this.startNode();\n    return this.parseLiteralAtNode(value, type, node);\n  }\n  parseStringLiteral(value) {\n    return this.parseLiteral(value, \"StringLiteral\");\n  }\n  parseNumericLiteral(value) {\n    return this.parseLiteral(value, \"NumericLiteral\");\n  }\n  parseBigIntLiteral(value) {\n    return this.parseLiteral(value, \"BigIntLiteral\");\n  }\n  parseDecimalLiteral(value) {\n    return this.parseLiteral(value, \"DecimalLiteral\");\n  }\n  parseRegExpLiteral(value) {\n    const node = this.startNode();\n    this.addExtra(node, \"raw\", this.input.slice(node.start, this.state.end));\n    node.pattern = value.pattern;\n    node.flags = value.flags;\n    this.next();\n    return this.finishNode(node, \"RegExpLiteral\");\n  }\n  parseBooleanLiteral(value) {\n    const node = this.startNode();\n    node.value = value;\n    this.next();\n    return this.finishNode(node, \"BooleanLiteral\");\n  }\n  parseNullLiteral() {\n    const node = this.startNode();\n    this.next();\n    return this.finishNode(node, \"NullLiteral\");\n  }\n  parseParenAndDistinguishExpression(canBeArrow) {\n    const startLoc = this.state.startLoc;\n    let val;\n    this.next();\n    this.expressionScope.enter(newArrowHeadScope());\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.maybeInArrowParameters = true;\n    this.state.inFSharpPipelineDirectBody = false;\n    const innerStartLoc = this.state.startLoc;\n    const exprList = [];\n    const refExpressionErrors = new ExpressionErrors();\n    let first = true;\n    let spreadStartLoc;\n    let optionalCommaStartLoc;\n    while (!this.match(11)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc);\n        if (this.match(11)) {\n          optionalCommaStartLoc = this.state.startLoc;\n          break;\n        }\n      }\n      if (this.match(21)) {\n        const spreadNodeStartLoc = this.state.startLoc;\n        spreadStartLoc = this.state.startLoc;\n        exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc));\n        if (!this.checkCommaAfterRest(41)) {\n          break;\n        }\n      } else {\n        exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem));\n      }\n    }\n    const innerEndLoc = this.state.lastTokEndLoc;\n    this.expect(11);\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    let arrowNode = this.startNodeAt(startLoc);\n    if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) {\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.expressionScope.validateAsPattern();\n      this.expressionScope.exit();\n      this.parseArrowExpression(arrowNode, exprList, false);\n      return arrowNode;\n    }\n    this.expressionScope.exit();\n    if (!exprList.length) {\n      this.unexpected(this.state.lastTokStartLoc);\n    }\n    if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc);\n    if (spreadStartLoc) this.unexpected(spreadStartLoc);\n    this.checkExpressionErrors(refExpressionErrors, true);\n    this.toReferencedListDeep(exprList, true);\n    if (exprList.length > 1) {\n      val = this.startNodeAt(innerStartLoc);\n      val.expressions = exprList;\n      this.finishNode(val, \"SequenceExpression\");\n      this.resetEndLocation(val, innerEndLoc);\n    } else {\n      val = exprList[0];\n    }\n    return this.wrapParenthesis(startLoc, val);\n  }\n  wrapParenthesis(startLoc, expression) {\n    if (!this.options.createParenthesizedExpressions) {\n      this.addExtra(expression, \"parenthesized\", true);\n      this.addExtra(expression, \"parenStart\", startLoc.index);\n      this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index);\n      return expression;\n    }\n    const parenExpression = this.startNodeAt(startLoc);\n    parenExpression.expression = expression;\n    return this.finishNode(parenExpression, \"ParenthesizedExpression\");\n  }\n  shouldParseArrow(params) {\n    return !this.canInsertSemicolon();\n  }\n  parseArrow(node) {\n    if (this.eat(19)) {\n      return node;\n    }\n  }\n  parseParenItem(node, startLoc) {\n    return node;\n  }\n  parseNewOrNewTarget() {\n    const node = this.startNode();\n    this.next();\n    if (this.match(16)) {\n      const meta = this.createIdentifier(this.startNodeAtNode(node), \"new\");\n      this.next();\n      const metaProp = this.parseMetaProperty(node, meta, \"target\");\n      if (!this.scope.inNonArrowFunction && !this.scope.inClass && !this.options.allowNewTargetOutsideFunction) {\n        this.raise(Errors.UnexpectedNewTarget, metaProp);\n      }\n      return metaProp;\n    }\n    return this.parseNew(node);\n  }\n  parseNew(node) {\n    this.parseNewCallee(node);\n    if (this.eat(10)) {\n      const args = this.parseExprList(11);\n      this.toReferencedList(args);\n      node.arguments = args;\n    } else {\n      node.arguments = [];\n    }\n    return this.finishNode(node, \"NewExpression\");\n  }\n  parseNewCallee(node) {\n    const isImport = this.match(83);\n    const callee = this.parseNoCallExpr();\n    node.callee = callee;\n    if (isImport && (callee.type === \"Import\" || callee.type === \"ImportExpression\")) {\n      this.raise(Errors.ImportCallNotNewExpression, callee);\n    }\n  }\n  parseTemplateElement(isTagged) {\n    const {\n      start,\n      startLoc,\n      end,\n      value\n    } = this.state;\n    const elemStart = start + 1;\n    const elem = this.startNodeAt(createPositionWithColumnOffset(startLoc, 1));\n    if (value === null) {\n      if (!isTagged) {\n        this.raise(Errors.InvalidEscapeSequenceTemplate, createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1));\n      }\n    }\n    const isTail = this.match(24);\n    const endOffset = isTail ? -1 : -2;\n    const elemEnd = end + endOffset;\n    elem.value = {\n      raw: this.input.slice(elemStart, elemEnd).replace(/\\r\\n?/g, \"\\n\"),\n      cooked: value === null ? null : value.slice(1, endOffset)\n    };\n    elem.tail = isTail;\n    this.next();\n    const finishedNode = this.finishNode(elem, \"TemplateElement\");\n    this.resetEndLocation(finishedNode, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset));\n    return finishedNode;\n  }\n  parseTemplate(isTagged) {\n    const node = this.startNode();\n    let curElt = this.parseTemplateElement(isTagged);\n    const quasis = [curElt];\n    const substitutions = [];\n    while (!curElt.tail) {\n      substitutions.push(this.parseTemplateSubstitution());\n      this.readTemplateContinuation();\n      quasis.push(curElt = this.parseTemplateElement(isTagged));\n    }\n    node.expressions = substitutions;\n    node.quasis = quasis;\n    return this.finishNode(node, \"TemplateLiteral\");\n  }\n  parseTemplateSubstitution() {\n    return this.parseExpression();\n  }\n  parseObjectLike(close, isPattern, isRecord, refExpressionErrors) {\n    if (isRecord) {\n      this.expectPlugin(\"recordAndTuple\");\n    }\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n    const propHash = Object.create(null);\n    let first = true;\n    const node = this.startNode();\n    node.properties = [];\n    this.next();\n    while (!this.match(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(12);\n        if (this.match(close)) {\n          this.addTrailingCommaExtraToNode(node);\n          break;\n        }\n      }\n      let prop;\n      if (isPattern) {\n        prop = this.parseBindingProperty();\n      } else {\n        prop = this.parsePropertyDefinition(refExpressionErrors);\n        this.checkProto(prop, isRecord, propHash, refExpressionErrors);\n      }\n      if (isRecord && !this.isObjectProperty(prop) && prop.type !== \"SpreadElement\") {\n        this.raise(Errors.InvalidRecordProperty, prop);\n      }\n      {\n        if (prop.shorthand) {\n          this.addExtra(prop, \"shorthand\", true);\n        }\n      }\n      node.properties.push(prop);\n    }\n    this.next();\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    let type = \"ObjectExpression\";\n    if (isPattern) {\n      type = \"ObjectPattern\";\n    } else if (isRecord) {\n      type = \"RecordExpression\";\n    }\n    return this.finishNode(node, type);\n  }\n  addTrailingCommaExtraToNode(node) {\n    this.addExtra(node, \"trailingComma\", this.state.lastTokStartLoc.index);\n    this.addExtra(node, \"trailingCommaLoc\", this.state.lastTokStartLoc, false);\n  }\n  maybeAsyncOrAccessorProp(prop) {\n    return !prop.computed && prop.key.type === \"Identifier\" && (this.isLiteralPropertyName() || this.match(0) || this.match(55));\n  }\n  parsePropertyDefinition(refExpressionErrors) {\n    let decorators = [];\n    if (this.match(26)) {\n      if (this.hasPlugin(\"decorators\")) {\n        this.raise(Errors.UnsupportedPropertyDecorator, this.state.startLoc);\n      }\n      while (this.match(26)) {\n        decorators.push(this.parseDecorator());\n      }\n    }\n    const prop = this.startNode();\n    let isAsync = false;\n    let isAccessor = false;\n    let startLoc;\n    if (this.match(21)) {\n      if (decorators.length) this.unexpected();\n      return this.parseSpread();\n    }\n    if (decorators.length) {\n      prop.decorators = decorators;\n      decorators = [];\n    }\n    prop.method = false;\n    if (refExpressionErrors) {\n      startLoc = this.state.startLoc;\n    }\n    let isGenerator = this.eat(55);\n    this.parsePropertyNamePrefixOperator(prop);\n    const containsEsc = this.state.containsEsc;\n    this.parsePropertyName(prop, refExpressionErrors);\n    if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {\n      const {\n        key\n      } = prop;\n      const keyName = key.name;\n      if (keyName === \"async\" && !this.hasPrecedingLineBreak()) {\n        isAsync = true;\n        this.resetPreviousNodeTrailingComments(key);\n        isGenerator = this.eat(55);\n        this.parsePropertyName(prop);\n      }\n      if (keyName === \"get\" || keyName === \"set\") {\n        isAccessor = true;\n        this.resetPreviousNodeTrailingComments(key);\n        prop.kind = keyName;\n        if (this.match(55)) {\n          isGenerator = true;\n          this.raise(Errors.AccessorIsGenerator, this.state.curPosition(), {\n            kind: keyName\n          });\n          this.next();\n        }\n        this.parsePropertyName(prop);\n      }\n    }\n    return this.parseObjPropValue(prop, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors);\n  }\n  getGetterSetterExpectedParamCount(method) {\n    return method.kind === \"get\" ? 0 : 1;\n  }\n  getObjectOrClassMethodParams(method) {\n    return method.params;\n  }\n  checkGetterSetterParams(method) {\n    var _params;\n    const paramCount = this.getGetterSetterExpectedParamCount(method);\n    const params = this.getObjectOrClassMethodParams(method);\n    if (params.length !== paramCount) {\n      this.raise(method.kind === \"get\" ? Errors.BadGetterArity : Errors.BadSetterArity, method);\n    }\n    if (method.kind === \"set\" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === \"RestElement\") {\n      this.raise(Errors.BadSetterRestParameter, method);\n    }\n  }\n  parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {\n    if (isAccessor) {\n      const finishedProp = this.parseMethod(prop, isGenerator, false, false, false, \"ObjectMethod\");\n      this.checkGetterSetterParams(finishedProp);\n      return finishedProp;\n    }\n    if (isAsync || isGenerator || this.match(10)) {\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  parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {\n    prop.shorthand = false;\n    if (this.eat(14)) {\n      prop.value = isPattern ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowIn(refExpressionErrors);\n      return this.finishNode(prop, \"ObjectProperty\");\n    }\n    if (!prop.computed && prop.key.type === \"Identifier\") {\n      this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);\n      if (isPattern) {\n        prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));\n      } else if (this.match(29)) {\n        const shorthandAssignLoc = this.state.startLoc;\n        if (refExpressionErrors != null) {\n          if (refExpressionErrors.shorthandAssignLoc === null) {\n            refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;\n          }\n        } else {\n          this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);\n        }\n        prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));\n      } else {\n        prop.value = cloneIdentifier(prop.key);\n      }\n      prop.shorthand = true;\n      return this.finishNode(prop, \"ObjectProperty\");\n    }\n  }\n  parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {\n    const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);\n    if (!node) this.unexpected();\n    return node;\n  }\n  parsePropertyName(prop, refExpressionErrors) {\n    if (this.eat(0)) {\n      prop.computed = true;\n      prop.key = this.parseMaybeAssignAllowIn();\n      this.expect(3);\n    } else {\n      const {\n        type,\n        value\n      } = this.state;\n      let key;\n      if (tokenIsKeywordOrIdentifier(type)) {\n        key = this.parseIdentifier(true);\n      } else {\n        switch (type) {\n          case 134:\n            key = this.parseNumericLiteral(value);\n            break;\n          case 133:\n            key = this.parseStringLiteral(value);\n            break;\n          case 135:\n            key = this.parseBigIntLiteral(value);\n            break;\n          case 136:\n            key = this.parseDecimalLiteral(value);\n            break;\n          case 138:\n            {\n              const privateKeyLoc = this.state.startLoc;\n              if (refExpressionErrors != null) {\n                if (refExpressionErrors.privateKeyLoc === null) {\n                  refExpressionErrors.privateKeyLoc = privateKeyLoc;\n                }\n              } else {\n                this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);\n              }\n              key = this.parsePrivateName();\n              break;\n            }\n          default:\n            this.unexpected();\n        }\n      }\n      prop.key = key;\n      if (type !== 138) {\n        prop.computed = false;\n      }\n    }\n  }\n  initFunction(node, isAsync) {\n    node.id = null;\n    node.generator = false;\n    node.async = isAsync;\n  }\n  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {\n    this.initFunction(node, isAsync);\n    node.generator = isGenerator;\n    this.scope.enter(2 | 16 | (inClassScope ? 64 : 0) | (allowDirectSuper ? 32 : 0));\n    this.prodParam.enter(functionFlags(isAsync, node.generator));\n    this.parseFunctionParams(node, isConstructor);\n    const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);\n    this.prodParam.exit();\n    this.scope.exit();\n    return finishedNode;\n  }\n  parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {\n    if (isTuple) {\n      this.expectPlugin(\"recordAndTuple\");\n    }\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n    const node = this.startNode();\n    this.next();\n    node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node);\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    return this.finishNode(node, isTuple ? \"TupleExpression\" : \"ArrayExpression\");\n  }\n  parseArrowExpression(node, params, isAsync, trailingCommaLoc) {\n    this.scope.enter(2 | 4);\n    let flags = functionFlags(isAsync, false);\n    if (!this.match(5) && this.prodParam.hasIn) {\n      flags |= 8;\n    }\n    this.prodParam.enter(flags);\n    this.initFunction(node, isAsync);\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    if (params) {\n      this.state.maybeInArrowParameters = true;\n      this.setArrowFunctionParameters(node, params, trailingCommaLoc);\n    }\n    this.state.maybeInArrowParameters = false;\n    this.parseFunctionBody(node, true);\n    this.prodParam.exit();\n    this.scope.exit();\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    return this.finishNode(node, \"ArrowFunctionExpression\");\n  }\n  setArrowFunctionParameters(node, params, trailingCommaLoc) {\n    this.toAssignableList(params, trailingCommaLoc, false);\n    node.params = params;\n  }\n  parseFunctionBodyAndFinish(node, type, isMethod = false) {\n    this.parseFunctionBody(node, false, isMethod);\n    return this.finishNode(node, type);\n  }\n  parseFunctionBody(node, allowExpression, isMethod = false) {\n    const isExpression = allowExpression && !this.match(5);\n    this.expressionScope.enter(newExpressionScope());\n    if (isExpression) {\n      node.body = this.parseMaybeAssign();\n      this.checkParams(node, false, allowExpression, false);\n    } else {\n      const oldStrict = this.state.strict;\n      const oldLabels = this.state.labels;\n      this.state.labels = [];\n      this.prodParam.enter(this.prodParam.currentFlags() | 4);\n      node.body = this.parseBlock(true, false, hasStrictModeDirective => {\n        const nonSimple = !this.isSimpleParamList(node.params);\n        if (hasStrictModeDirective && nonSimple) {\n          this.raise(Errors.IllegalLanguageModeDirective, (node.kind === \"method\" || node.kind === \"constructor\") && !!node.key ? node.key.loc.end : node);\n        }\n        const strictModeChanged = !oldStrict && this.state.strict;\n        this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);\n        if (this.state.strict && node.id) {\n          this.checkIdentifier(node.id, 65, strictModeChanged);\n        }\n      });\n      this.prodParam.exit();\n      this.state.labels = oldLabels;\n    }\n    this.expressionScope.exit();\n  }\n  isSimpleParameter(node) {\n    return node.type === \"Identifier\";\n  }\n  isSimpleParamList(params) {\n    for (let i = 0, len = params.length; i < len; i++) {\n      if (!this.isSimpleParameter(params[i])) return false;\n    }\n    return true;\n  }\n  checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {\n    const checkClashes = !allowDuplicates && new Set();\n    const formalParameters = {\n      type: \"FormalParameters\"\n    };\n    for (const param of node.params) {\n      this.checkLVal(param, formalParameters, 5, checkClashes, strictModeChanged);\n    }\n  }\n  parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) {\n    const elts = [];\n    let first = true;\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(12);\n        if (this.match(close)) {\n          if (nodeForExtra) {\n            this.addTrailingCommaExtraToNode(nodeForExtra);\n          }\n          this.next();\n          break;\n        }\n      }\n      elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));\n    }\n    return elts;\n  }\n  parseExprListItem(allowEmpty, refExpressionErrors, allowPlaceholder) {\n    let elt;\n    if (this.match(12)) {\n      if (!allowEmpty) {\n        this.raise(Errors.UnexpectedToken, this.state.curPosition(), {\n          unexpected: \",\"\n        });\n      }\n      elt = null;\n    } else if (this.match(21)) {\n      const spreadNodeStartLoc = this.state.startLoc;\n      elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc);\n    } else if (this.match(17)) {\n      this.expectPlugin(\"partialApplication\");\n      if (!allowPlaceholder) {\n        this.raise(Errors.UnexpectedArgumentPlaceholder, this.state.startLoc);\n      }\n      const node = this.startNode();\n      this.next();\n      elt = this.finishNode(node, \"ArgumentPlaceholder\");\n    } else {\n      elt = this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem);\n    }\n    return elt;\n  }\n  parseIdentifier(liberal) {\n    const node = this.startNode();\n    const name = this.parseIdentifierName(liberal);\n    return this.createIdentifier(node, name);\n  }\n  createIdentifier(node, name) {\n    node.name = name;\n    node.loc.identifierName = name;\n    return this.finishNode(node, \"Identifier\");\n  }\n  parseIdentifierName(liberal) {\n    let name;\n    const {\n      startLoc,\n      type\n    } = this.state;\n    if (tokenIsKeywordOrIdentifier(type)) {\n      name = this.state.value;\n    } else {\n      this.unexpected();\n    }\n    const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);\n    if (liberal) {\n      if (tokenIsKeyword) {\n        this.replaceToken(132);\n      }\n    } else {\n      this.checkReservedWord(name, startLoc, tokenIsKeyword, false);\n    }\n    this.next();\n    return name;\n  }\n  checkReservedWord(word, startLoc, checkKeywords, isBinding) {\n    if (word.length > 10) {\n      return;\n    }\n    if (!canBeReservedWord(word)) {\n      return;\n    }\n    if (checkKeywords && isKeyword(word)) {\n      this.raise(Errors.UnexpectedKeyword, startLoc, {\n        keyword: word\n      });\n      return;\n    }\n    const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;\n    if (reservedTest(word, this.inModule)) {\n      this.raise(Errors.UnexpectedReservedWord, startLoc, {\n        reservedWord: word\n      });\n      return;\n    } else if (word === \"yield\") {\n      if (this.prodParam.hasYield) {\n        this.raise(Errors.YieldBindingIdentifier, startLoc);\n        return;\n      }\n    } else if (word === \"await\") {\n      if (this.prodParam.hasAwait) {\n        this.raise(Errors.AwaitBindingIdentifier, startLoc);\n        return;\n      }\n      if (this.scope.inStaticBlock) {\n        this.raise(Errors.AwaitBindingIdentifierInStaticBlock, startLoc);\n        return;\n      }\n      this.expressionScope.recordAsyncArrowParametersError(startLoc);\n    } else if (word === \"arguments\") {\n      if (this.scope.inClassAndNotInNonArrowFunction) {\n        this.raise(Errors.ArgumentsInClass, startLoc);\n        return;\n      }\n    }\n  }\n  recordAwaitIfAllowed() {\n    const isAwaitAllowed = this.prodParam.hasAwait || this.options.allowAwaitOutsideFunction && !this.scope.inFunction;\n    if (isAwaitAllowed && !this.scope.inFunction) {\n      this.state.hasTopLevelAwait = true;\n    }\n    return isAwaitAllowed;\n  }\n  parseAwait(startLoc) {\n    const node = this.startNodeAt(startLoc);\n    this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, node);\n    if (this.eat(55)) {\n      this.raise(Errors.ObsoleteAwaitStar, node);\n    }\n    if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {\n      if (this.isAmbiguousAwait()) {\n        this.ambiguousScriptDifferentAst = true;\n      } else {\n        this.sawUnambiguousESM = true;\n      }\n    }\n    if (!this.state.soloAwait) {\n      node.argument = this.parseMaybeUnary(null, true);\n    }\n    return this.finishNode(node, \"AwaitExpression\");\n  }\n  isAmbiguousAwait() {\n    if (this.hasPrecedingLineBreak()) return true;\n    const {\n      type\n    } = this.state;\n    return type === 53 || type === 10 || type === 0 || tokenIsTemplate(type) || type === 102 && !this.state.containsEsc || type === 137 || type === 56 || this.hasPlugin(\"v8intrinsic\") && type === 54;\n  }\n  parseYield() {\n    const node = this.startNode();\n    this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, node);\n    this.next();\n    let delegating = false;\n    let argument = null;\n    if (!this.hasPrecedingLineBreak()) {\n      delegating = this.eat(55);\n      switch (this.state.type) {\n        case 13:\n        case 139:\n        case 8:\n        case 11:\n        case 3:\n        case 9:\n        case 14:\n        case 12:\n          if (!delegating) break;\n        default:\n          argument = this.parseMaybeAssign();\n      }\n    }\n    node.delegate = delegating;\n    node.argument = argument;\n    return this.finishNode(node, \"YieldExpression\");\n  }\n  parseImportCall(node) {\n    this.next();\n    node.source = this.parseMaybeAssignAllowIn();\n    if (this.hasPlugin(\"importAttributes\") || this.hasPlugin(\"importAssertions\")) {\n      node.options = null;\n    }\n    if (this.eat(12)) {\n      this.expectImportAttributesPlugin();\n      if (!this.match(11)) {\n        node.options = this.parseMaybeAssignAllowIn();\n        this.eat(12);\n      }\n    }\n    this.expect(11);\n    return this.finishNode(node, \"ImportExpression\");\n  }\n  checkPipelineAtInfixOperator(left, leftStartLoc) {\n    if (this.hasPlugin([\"pipelineOperator\", {\n      proposal: \"smart\"\n    }])) {\n      if (left.type === \"SequenceExpression\") {\n        this.raise(Errors.PipelineHeadSequenceExpression, leftStartLoc);\n      }\n    }\n  }\n  parseSmartPipelineBodyInStyle(childExpr, startLoc) {\n    if (this.isSimpleReference(childExpr)) {\n      const bodyNode = this.startNodeAt(startLoc);\n      bodyNode.callee = childExpr;\n      return this.finishNode(bodyNode, \"PipelineBareFunction\");\n    } else {\n      const bodyNode = this.startNodeAt(startLoc);\n      this.checkSmartPipeTopicBodyEarlyErrors(startLoc);\n      bodyNode.expression = childExpr;\n      return this.finishNode(bodyNode, \"PipelineTopicExpression\");\n    }\n  }\n  isSimpleReference(expression) {\n    switch (expression.type) {\n      case \"MemberExpression\":\n        return !expression.computed && this.isSimpleReference(expression.object);\n      case \"Identifier\":\n        return true;\n      default:\n        return false;\n    }\n  }\n  checkSmartPipeTopicBodyEarlyErrors(startLoc) {\n    if (this.match(19)) {\n      throw this.raise(Errors.PipelineBodyNoArrow, this.state.startLoc);\n    }\n    if (!this.topicReferenceWasUsedInCurrentContext()) {\n      this.raise(Errors.PipelineTopicUnused, startLoc);\n    }\n  }\n  withTopicBindingContext(callback) {\n    const outerContextTopicState = this.state.topicContext;\n    this.state.topicContext = {\n      maxNumOfResolvableTopics: 1,\n      maxTopicIndex: null\n    };\n    try {\n      return callback();\n    } finally {\n      this.state.topicContext = outerContextTopicState;\n    }\n  }\n  withSmartMixTopicForbiddingContext(callback) {\n    if (this.hasPlugin([\"pipelineOperator\", {\n      proposal: \"smart\"\n    }])) {\n      const outerContextTopicState = this.state.topicContext;\n      this.state.topicContext = {\n        maxNumOfResolvableTopics: 0,\n        maxTopicIndex: null\n      };\n      try {\n        return callback();\n      } finally {\n        this.state.topicContext = outerContextTopicState;\n      }\n    } else {\n      return callback();\n    }\n  }\n  withSoloAwaitPermittingContext(callback) {\n    const outerContextSoloAwaitState = this.state.soloAwait;\n    this.state.soloAwait = true;\n    try {\n      return callback();\n    } finally {\n      this.state.soloAwait = outerContextSoloAwaitState;\n    }\n  }\n  allowInAnd(callback) {\n    const flags = this.prodParam.currentFlags();\n    const prodParamToSet = 8 & ~flags;\n    if (prodParamToSet) {\n      this.prodParam.enter(flags | 8);\n      try {\n        return callback();\n      } finally {\n        this.prodParam.exit();\n      }\n    }\n    return callback();\n  }\n  disallowInAnd(callback) {\n    const flags = this.prodParam.currentFlags();\n    const prodParamToClear = 8 & flags;\n    if (prodParamToClear) {\n      this.prodParam.enter(flags & ~8);\n      try {\n        return callback();\n      } finally {\n        this.prodParam.exit();\n      }\n    }\n    return callback();\n  }\n  registerTopicReference() {\n    this.state.topicContext.maxTopicIndex = 0;\n  }\n  topicReferenceIsAllowedInCurrentContext() {\n    return this.state.topicContext.maxNumOfResolvableTopics >= 1;\n  }\n  topicReferenceWasUsedInCurrentContext() {\n    return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;\n  }\n  parseFSharpPipelineBody(prec) {\n    const startLoc = this.state.startLoc;\n    this.state.potentialArrowAt = this.state.start;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = true;\n    const ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, prec);\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    return ret;\n  }\n  parseModuleExpression() {\n    this.expectPlugin(\"moduleBlocks\");\n    const node = this.startNode();\n    this.next();\n    if (!this.match(5)) {\n      this.unexpected(null, 5);\n    }\n    const program = this.startNodeAt(this.state.endLoc);\n    this.next();\n    const revertScopes = this.initializeScopes(true);\n    this.enterInitialScopes();\n    try {\n      node.body = this.parseProgram(program, 8, \"module\");\n    } finally {\n      revertScopes();\n    }\n    return this.finishNode(node, \"ModuleExpression\");\n  }\n  parsePropertyNamePrefixOperator(prop) {}\n}\nconst loopLabel = {\n    kind: 1\n  },\n  switchLabel = {\n    kind: 2\n  };\nconst loneSurrogate = /[\\uD800-\\uDFFF]/u;\nconst keywordRelationalOperator = /in(?:stanceof)?/y;\nfunction babel7CompatTokens(tokens, input) {\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    const {\n      type\n    } = token;\n    if (typeof type === \"number\") {\n      {\n        if (type === 138) {\n          const {\n            loc,\n            start,\n            value,\n            end\n          } = token;\n          const hashEndPos = start + 1;\n          const hashEndLoc = createPositionWithColumnOffset(loc.start, 1);\n          tokens.splice(i, 1, new Token({\n            type: getExportedToken(27),\n            value: \"#\",\n            start: start,\n            end: hashEndPos,\n            startLoc: loc.start,\n            endLoc: hashEndLoc\n          }), new Token({\n            type: getExportedToken(132),\n            value: value,\n            start: hashEndPos,\n            end: end,\n            startLoc: hashEndLoc,\n            endLoc: loc.end\n          }));\n          i++;\n          continue;\n        }\n        if (tokenIsTemplate(type)) {\n          const {\n            loc,\n            start,\n            value,\n            end\n          } = token;\n          const backquoteEnd = start + 1;\n          const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);\n          let startToken;\n          if (input.charCodeAt(start) === 96) {\n            startToken = new Token({\n              type: getExportedToken(22),\n              value: \"`\",\n              start: start,\n              end: backquoteEnd,\n              startLoc: loc.start,\n              endLoc: backquoteEndLoc\n            });\n          } else {\n            startToken = new Token({\n              type: getExportedToken(8),\n              value: \"}\",\n              start: start,\n              end: backquoteEnd,\n              startLoc: loc.start,\n              endLoc: backquoteEndLoc\n            });\n          }\n          let templateValue, templateElementEnd, templateElementEndLoc, endToken;\n          if (type === 24) {\n            templateElementEnd = end - 1;\n            templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1);\n            templateValue = value === null ? null : value.slice(1, -1);\n            endToken = new Token({\n              type: getExportedToken(22),\n              value: \"`\",\n              start: templateElementEnd,\n              end: end,\n              startLoc: templateElementEndLoc,\n              endLoc: loc.end\n            });\n          } else {\n            templateElementEnd = end - 2;\n            templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2);\n            templateValue = value === null ? null : value.slice(1, -2);\n            endToken = new Token({\n              type: getExportedToken(23),\n              value: \"${\",\n              start: templateElementEnd,\n              end: end,\n              startLoc: templateElementEndLoc,\n              endLoc: loc.end\n            });\n          }\n          tokens.splice(i, 1, startToken, new Token({\n            type: getExportedToken(20),\n            value: templateValue,\n            start: backquoteEnd,\n            end: templateElementEnd,\n            startLoc: backquoteEndLoc,\n            endLoc: templateElementEndLoc\n          }), endToken);\n          i += 2;\n          continue;\n        }\n      }\n      token.type = getExportedToken(type);\n    }\n  }\n  return tokens;\n}\nclass StatementParser extends ExpressionParser {\n  parseTopLevel(file, program) {\n    file.program = this.parseProgram(program);\n    file.comments = this.comments;\n    if (this.options.tokens) {\n      file.tokens = babel7CompatTokens(this.tokens, this.input);\n    }\n    return this.finishNode(file, \"File\");\n  }\n  parseProgram(program, end = 139, sourceType = this.options.sourceType) {\n    program.sourceType = sourceType;\n    program.interpreter = this.parseInterpreterDirective();\n    this.parseBlockBody(program, true, true, end);\n    if (this.inModule) {\n      if (!this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {\n        for (const [localName, at] of Array.from(this.scope.undefinedExports)) {\n          this.raise(Errors.ModuleExportUndefined, at, {\n            localName\n          });\n        }\n      }\n      this.addExtra(program, \"topLevelAwait\", this.state.hasTopLevelAwait);\n    }\n    let finishedProgram;\n    if (end === 139) {\n      finishedProgram = this.finishNode(program, \"Program\");\n    } else {\n      finishedProgram = this.finishNodeAt(program, \"Program\", createPositionWithColumnOffset(this.state.startLoc, -1));\n    }\n    return finishedProgram;\n  }\n  stmtToDirective(stmt) {\n    const directive = stmt;\n    directive.type = \"Directive\";\n    directive.value = directive.expression;\n    delete directive.expression;\n    const directiveLiteral = directive.value;\n    const expressionValue = directiveLiteral.value;\n    const raw = this.input.slice(directiveLiteral.start, directiveLiteral.end);\n    const val = directiveLiteral.value = raw.slice(1, -1);\n    this.addExtra(directiveLiteral, \"raw\", raw);\n    this.addExtra(directiveLiteral, \"rawValue\", val);\n    this.addExtra(directiveLiteral, \"expressionValue\", expressionValue);\n    directiveLiteral.type = \"DirectiveLiteral\";\n    return directive;\n  }\n  parseInterpreterDirective() {\n    if (!this.match(28)) {\n      return null;\n    }\n    const node = this.startNode();\n    node.value = this.state.value;\n    this.next();\n    return this.finishNode(node, \"InterpreterDirective\");\n  }\n  isLet() {\n    if (!this.isContextual(100)) {\n      return false;\n    }\n    return this.hasFollowingBindingAtom();\n  }\n  chStartsBindingIdentifier(ch, pos) {\n    if (isIdentifierStart(ch)) {\n      keywordRelationalOperator.lastIndex = pos;\n      if (keywordRelationalOperator.test(this.input)) {\n        const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);\n        if (!isIdentifierChar(endCh) && endCh !== 92) {\n          return false;\n        }\n      }\n      return true;\n    } else if (ch === 92) {\n      return true;\n    } else {\n      return false;\n    }\n  }\n  chStartsBindingPattern(ch) {\n    return ch === 91 || ch === 123;\n  }\n  hasFollowingBindingAtom() {\n    const next = this.nextTokenStart();\n    const nextCh = this.codePointAtPos(next);\n    return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next);\n  }\n  hasInLineFollowingBindingIdentifierOrBrace() {\n    const next = this.nextTokenInLineStart();\n    const nextCh = this.codePointAtPos(next);\n    return nextCh === 123 || this.chStartsBindingIdentifier(nextCh, next);\n  }\n  startsUsingForOf() {\n    const {\n      type,\n      containsEsc\n    } = this.lookahead();\n    if (type === 102 && !containsEsc) {\n      return false;\n    } else if (tokenIsIdentifier(type) && !this.hasFollowingLineBreak()) {\n      this.expectPlugin(\"explicitResourceManagement\");\n      return true;\n    }\n  }\n  startsAwaitUsing() {\n    let next = this.nextTokenInLineStart();\n    if (this.isUnparsedContextual(next, \"using\")) {\n      next = this.nextTokenInLineStartSince(next + 5);\n      const nextCh = this.codePointAtPos(next);\n      if (this.chStartsBindingIdentifier(nextCh, next)) {\n        this.expectPlugin(\"explicitResourceManagement\");\n        return true;\n      }\n    }\n    return false;\n  }\n  parseModuleItem() {\n    return this.parseStatementLike(1 | 2 | 4 | 8);\n  }\n  parseStatementListItem() {\n    return this.parseStatementLike(2 | 4 | (!this.options.annexB || this.state.strict ? 0 : 8));\n  }\n  parseStatementOrSloppyAnnexBFunctionDeclaration(allowLabeledFunction = false) {\n    let flags = 0;\n    if (this.options.annexB && !this.state.strict) {\n      flags |= 4;\n      if (allowLabeledFunction) {\n        flags |= 8;\n      }\n    }\n    return this.parseStatementLike(flags);\n  }\n  parseStatement() {\n    return this.parseStatementLike(0);\n  }\n  parseStatementLike(flags) {\n    let decorators = null;\n    if (this.match(26)) {\n      decorators = this.parseDecorators(true);\n    }\n    return this.parseStatementContent(flags, decorators);\n  }\n  parseStatementContent(flags, decorators) {\n    const startType = this.state.type;\n    const node = this.startNode();\n    const allowDeclaration = !!(flags & 2);\n    const allowFunctionDeclaration = !!(flags & 4);\n    const topLevel = flags & 1;\n    switch (startType) {\n      case 60:\n        return this.parseBreakContinueStatement(node, true);\n      case 63:\n        return this.parseBreakContinueStatement(node, false);\n      case 64:\n        return this.parseDebuggerStatement(node);\n      case 90:\n        return this.parseDoWhileStatement(node);\n      case 91:\n        return this.parseForStatement(node);\n      case 68:\n        if (this.lookaheadCharCode() === 46) break;\n        if (!allowFunctionDeclaration) {\n          this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, this.state.startLoc);\n        }\n        return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);\n      case 80:\n        if (!allowDeclaration) this.unexpected();\n        return this.parseClass(this.maybeTakeDecorators(decorators, node), true);\n      case 69:\n        return this.parseIfStatement(node);\n      case 70:\n        return this.parseReturnStatement(node);\n      case 71:\n        return this.parseSwitchStatement(node);\n      case 72:\n        return this.parseThrowStatement(node);\n      case 73:\n        return this.parseTryStatement(node);\n      case 96:\n        if (!this.state.containsEsc && this.startsAwaitUsing()) {\n          if (!this.recordAwaitIfAllowed()) {\n            this.raise(Errors.AwaitUsingNotInAsyncContext, node);\n          } else if (!allowDeclaration) {\n            this.raise(Errors.UnexpectedLexicalDeclaration, node);\n          }\n          this.next();\n          return this.parseVarStatement(node, \"await using\");\n        }\n        break;\n      case 107:\n        if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifierOrBrace()) {\n          break;\n        }\n        this.expectPlugin(\"explicitResourceManagement\");\n        if (!this.scope.inModule && this.scope.inTopLevel) {\n          this.raise(Errors.UnexpectedUsingDeclaration, this.state.startLoc);\n        } else if (!allowDeclaration) {\n          this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);\n        }\n        return this.parseVarStatement(node, \"using\");\n      case 100:\n        {\n          if (this.state.containsEsc) {\n            break;\n          }\n          const next = this.nextTokenStart();\n          const nextCh = this.codePointAtPos(next);\n          if (nextCh !== 91) {\n            if (!allowDeclaration && this.hasFollowingLineBreak()) break;\n            if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) {\n              break;\n            }\n          }\n        }\n      case 75:\n        {\n          if (!allowDeclaration) {\n            this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);\n          }\n        }\n      case 74:\n        {\n          const kind = this.state.value;\n          return this.parseVarStatement(node, kind);\n        }\n      case 92:\n        return this.parseWhileStatement(node);\n      case 76:\n        return this.parseWithStatement(node);\n      case 5:\n        return this.parseBlock();\n      case 13:\n        return this.parseEmptyStatement(node);\n      case 83:\n        {\n          const nextTokenCharCode = this.lookaheadCharCode();\n          if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {\n            break;\n          }\n        }\n      case 82:\n        {\n          if (!this.options.allowImportExportEverywhere && !topLevel) {\n            this.raise(Errors.UnexpectedImportExport, this.state.startLoc);\n          }\n          this.next();\n          let result;\n          if (startType === 83) {\n            result = this.parseImport(node);\n            if (result.type === \"ImportDeclaration\" && (!result.importKind || result.importKind === \"value\")) {\n              this.sawUnambiguousESM = true;\n            }\n          } else {\n            result = this.parseExport(node, decorators);\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          this.assertModuleNodeAllowed(result);\n          return result;\n        }\n      default:\n        {\n          if (this.isAsyncFunction()) {\n            if (!allowDeclaration) {\n              this.raise(Errors.AsyncFunctionInSingleStatementContext, this.state.startLoc);\n            }\n            this.next();\n            return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration);\n          }\n        }\n    }\n    const maybeName = this.state.value;\n    const expr = this.parseExpression();\n    if (tokenIsIdentifier(startType) && expr.type === \"Identifier\" && this.eat(14)) {\n      return this.parseLabeledStatement(node, maybeName, expr, flags);\n    } else {\n      return this.parseExpressionStatement(node, expr, decorators);\n    }\n  }\n  assertModuleNodeAllowed(node) {\n    if (!this.options.allowImportExportEverywhere && !this.inModule) {\n      this.raise(Errors.ImportOutsideModule, node);\n    }\n  }\n  decoratorsEnabledBeforeExport() {\n    if (this.hasPlugin(\"decorators-legacy\")) return true;\n    return this.hasPlugin(\"decorators\") && this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") !== false;\n  }\n  maybeTakeDecorators(maybeDecorators, classNode, exportNode) {\n    if (maybeDecorators) {\n      if (classNode.decorators && classNode.decorators.length > 0) {\n        if (typeof this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") !== \"boolean\") {\n          this.raise(Errors.DecoratorsBeforeAfterExport, classNode.decorators[0]);\n        }\n        classNode.decorators.unshift(...maybeDecorators);\n      } else {\n        classNode.decorators = maybeDecorators;\n      }\n      this.resetStartLocationFromNode(classNode, maybeDecorators[0]);\n      if (exportNode) this.resetStartLocationFromNode(exportNode, classNode);\n    }\n    return classNode;\n  }\n  canHaveLeadingDecorator() {\n    return this.match(80);\n  }\n  parseDecorators(allowExport) {\n    const decorators = [];\n    do {\n      decorators.push(this.parseDecorator());\n    } while (this.match(26));\n    if (this.match(82)) {\n      if (!allowExport) {\n        this.unexpected();\n      }\n      if (!this.decoratorsEnabledBeforeExport()) {\n        this.raise(Errors.DecoratorExportClass, this.state.startLoc);\n      }\n    } else if (!this.canHaveLeadingDecorator()) {\n      throw this.raise(Errors.UnexpectedLeadingDecorator, this.state.startLoc);\n    }\n    return decorators;\n  }\n  parseDecorator() {\n    this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n    const node = this.startNode();\n    this.next();\n    if (this.hasPlugin(\"decorators\")) {\n      const startLoc = this.state.startLoc;\n      let expr;\n      if (this.match(10)) {\n        const startLoc = this.state.startLoc;\n        this.next();\n        expr = this.parseExpression();\n        this.expect(11);\n        expr = this.wrapParenthesis(startLoc, expr);\n        const paramsStartLoc = this.state.startLoc;\n        node.expression = this.parseMaybeDecoratorArguments(expr);\n        if (this.getPluginOption(\"decorators\", \"allowCallParenthesized\") === false && node.expression !== expr) {\n          this.raise(Errors.DecoratorArgumentsOutsideParentheses, paramsStartLoc);\n        }\n      } else {\n        expr = this.parseIdentifier(false);\n        while (this.eat(16)) {\n          const node = this.startNodeAt(startLoc);\n          node.object = expr;\n          if (this.match(138)) {\n            this.classScope.usePrivateName(this.state.value, this.state.startLoc);\n            node.property = this.parsePrivateName();\n          } else {\n            node.property = this.parseIdentifier(true);\n          }\n          node.computed = false;\n          expr = this.finishNode(node, \"MemberExpression\");\n        }\n        node.expression = this.parseMaybeDecoratorArguments(expr);\n      }\n    } else {\n      node.expression = this.parseExprSubscripts();\n    }\n    return this.finishNode(node, \"Decorator\");\n  }\n  parseMaybeDecoratorArguments(expr) {\n    if (this.eat(10)) {\n      const node = this.startNodeAtNode(expr);\n      node.callee = expr;\n      node.arguments = this.parseCallExpressionArguments(11, false);\n      this.toReferencedList(node.arguments);\n      return this.finishNode(node, \"CallExpression\");\n    }\n    return expr;\n  }\n  parseBreakContinueStatement(node, isBreak) {\n    this.next();\n    if (this.isLineTerminator()) {\n      node.label = null;\n    } else {\n      node.label = this.parseIdentifier();\n      this.semicolon();\n    }\n    this.verifyBreakContinue(node, isBreak);\n    return this.finishNode(node, isBreak ? \"BreakStatement\" : \"ContinueStatement\");\n  }\n  verifyBreakContinue(node, isBreak) {\n    let i;\n    for (i = 0; i < this.state.labels.length; ++i) {\n      const lab = this.state.labels[i];\n      if (node.label == null || lab.name === node.label.name) {\n        if (lab.kind != null && (isBreak || lab.kind === 1)) {\n          break;\n        }\n        if (node.label && isBreak) break;\n      }\n    }\n    if (i === this.state.labels.length) {\n      const type = isBreak ? \"BreakStatement\" : \"ContinueStatement\";\n      this.raise(Errors.IllegalBreakContinue, node, {\n        type\n      });\n    }\n  }\n  parseDebuggerStatement(node) {\n    this.next();\n    this.semicolon();\n    return this.finishNode(node, \"DebuggerStatement\");\n  }\n  parseHeaderExpression() {\n    this.expect(10);\n    const val = this.parseExpression();\n    this.expect(11);\n    return val;\n  }\n  parseDoWhileStatement(node) {\n    this.next();\n    this.state.labels.push(loopLabel);\n    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());\n    this.state.labels.pop();\n    this.expect(92);\n    node.test = this.parseHeaderExpression();\n    this.eat(13);\n    return this.finishNode(node, \"DoWhileStatement\");\n  }\n  parseForStatement(node) {\n    this.next();\n    this.state.labels.push(loopLabel);\n    let awaitAt = null;\n    if (this.isContextual(96) && this.recordAwaitIfAllowed()) {\n      awaitAt = this.state.startLoc;\n      this.next();\n    }\n    this.scope.enter(0);\n    this.expect(10);\n    if (this.match(13)) {\n      if (awaitAt !== null) {\n        this.unexpected(awaitAt);\n      }\n      return this.parseFor(node, null);\n    }\n    const startsWithLet = this.isContextual(100);\n    {\n      const startsWithAwaitUsing = this.isContextual(96) && this.startsAwaitUsing();\n      const starsWithUsingDeclaration = startsWithAwaitUsing || this.isContextual(107) && this.startsUsingForOf();\n      const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration;\n      if (this.match(74) || this.match(75) || isLetOrUsing) {\n        const initNode = this.startNode();\n        let kind;\n        if (startsWithAwaitUsing) {\n          kind = \"await using\";\n          if (!this.recordAwaitIfAllowed()) {\n            this.raise(Errors.AwaitUsingNotInAsyncContext, this.state.startLoc);\n          }\n          this.next();\n        } else {\n          kind = this.state.value;\n        }\n        this.next();\n        this.parseVar(initNode, true, kind);\n        const init = this.finishNode(initNode, \"VariableDeclaration\");\n        const isForIn = this.match(58);\n        if (isForIn && starsWithUsingDeclaration) {\n          this.raise(Errors.ForInUsing, init);\n        }\n        if ((isForIn || this.isContextual(102)) && init.declarations.length === 1) {\n          return this.parseForIn(node, init, awaitAt);\n        }\n        if (awaitAt !== null) {\n          this.unexpected(awaitAt);\n        }\n        return this.parseFor(node, init);\n      }\n    }\n    const startsWithAsync = this.isContextual(95);\n    const refExpressionErrors = new ExpressionErrors();\n    const init = this.parseExpression(true, refExpressionErrors);\n    const isForOf = this.isContextual(102);\n    if (isForOf) {\n      if (startsWithLet) {\n        this.raise(Errors.ForOfLet, init);\n      }\n      if (awaitAt === null && startsWithAsync && init.type === \"Identifier\") {\n        this.raise(Errors.ForOfAsync, init);\n      }\n    }\n    if (isForOf || this.match(58)) {\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.toAssignable(init, true);\n      const type = isForOf ? \"ForOfStatement\" : \"ForInStatement\";\n      this.checkLVal(init, {\n        type\n      });\n      return this.parseForIn(node, init, awaitAt);\n    } else {\n      this.checkExpressionErrors(refExpressionErrors, true);\n    }\n    if (awaitAt !== null) {\n      this.unexpected(awaitAt);\n    }\n    return this.parseFor(node, init);\n  }\n  parseFunctionStatement(node, isAsync, isHangingDeclaration) {\n    this.next();\n    return this.parseFunction(node, 1 | (isHangingDeclaration ? 2 : 0) | (isAsync ? 8 : 0));\n  }\n  parseIfStatement(node) {\n    this.next();\n    node.test = this.parseHeaderExpression();\n    node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();\n    node.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;\n    return this.finishNode(node, \"IfStatement\");\n  }\n  parseReturnStatement(node) {\n    if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {\n      this.raise(Errors.IllegalReturn, this.state.startLoc);\n    }\n    this.next();\n    if (this.isLineTerminator()) {\n      node.argument = null;\n    } else {\n      node.argument = this.parseExpression();\n      this.semicolon();\n    }\n    return this.finishNode(node, \"ReturnStatement\");\n  }\n  parseSwitchStatement(node) {\n    this.next();\n    node.discriminant = this.parseHeaderExpression();\n    const cases = node.cases = [];\n    this.expect(5);\n    this.state.labels.push(switchLabel);\n    this.scope.enter(0);\n    let cur;\n    for (let sawDefault; !this.match(8);) {\n      if (this.match(61) || this.match(65)) {\n        const isCase = this.match(61);\n        if (cur) this.finishNode(cur, \"SwitchCase\");\n        cases.push(cur = this.startNode());\n        cur.consequent = [];\n        this.next();\n        if (isCase) {\n          cur.test = this.parseExpression();\n        } else {\n          if (sawDefault) {\n            this.raise(Errors.MultipleDefaultsInSwitch, this.state.lastTokStartLoc);\n          }\n          sawDefault = true;\n          cur.test = null;\n        }\n        this.expect(14);\n      } else {\n        if (cur) {\n          cur.consequent.push(this.parseStatementListItem());\n        } else {\n          this.unexpected();\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  parseThrowStatement(node) {\n    this.next();\n    if (this.hasPrecedingLineBreak()) {\n      this.raise(Errors.NewlineAfterThrow, this.state.lastTokEndLoc);\n    }\n    node.argument = this.parseExpression();\n    this.semicolon();\n    return this.finishNode(node, \"ThrowStatement\");\n  }\n  parseCatchClauseParam() {\n    const param = this.parseBindingAtom();\n    this.scope.enter(this.options.annexB && param.type === \"Identifier\" ? 8 : 0);\n    this.checkLVal(param, {\n      type: \"CatchClause\"\n    }, 9);\n    return param;\n  }\n  parseTryStatement(node) {\n    this.next();\n    node.block = this.parseBlock();\n    node.handler = null;\n    if (this.match(62)) {\n      const clause = this.startNode();\n      this.next();\n      if (this.match(10)) {\n        this.expect(10);\n        clause.param = this.parseCatchClauseParam();\n        this.expect(11);\n      } else {\n        clause.param = null;\n        this.scope.enter(0);\n      }\n      clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false));\n      this.scope.exit();\n      node.handler = this.finishNode(clause, \"CatchClause\");\n    }\n    node.finalizer = this.eat(67) ? this.parseBlock() : null;\n    if (!node.handler && !node.finalizer) {\n      this.raise(Errors.NoCatchOrFinally, node);\n    }\n    return this.finishNode(node, \"TryStatement\");\n  }\n  parseVarStatement(node, kind, allowMissingInitializer = false) {\n    this.next();\n    this.parseVar(node, false, kind, allowMissingInitializer);\n    this.semicolon();\n    return this.finishNode(node, \"VariableDeclaration\");\n  }\n  parseWhileStatement(node) {\n    this.next();\n    node.test = this.parseHeaderExpression();\n    this.state.labels.push(loopLabel);\n    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());\n    this.state.labels.pop();\n    return this.finishNode(node, \"WhileStatement\");\n  }\n  parseWithStatement(node) {\n    if (this.state.strict) {\n      this.raise(Errors.StrictWith, this.state.startLoc);\n    }\n    this.next();\n    node.object = this.parseHeaderExpression();\n    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());\n    return this.finishNode(node, \"WithStatement\");\n  }\n  parseEmptyStatement(node) {\n    this.next();\n    return this.finishNode(node, \"EmptyStatement\");\n  }\n  parseLabeledStatement(node, maybeName, expr, flags) {\n    for (const label of this.state.labels) {\n      if (label.name === maybeName) {\n        this.raise(Errors.LabelRedeclaration, expr, {\n          labelName: maybeName\n        });\n      }\n    }\n    const kind = tokenIsLoop(this.state.type) ? 1 : this.match(71) ? 2 : null;\n    for (let i = this.state.labels.length - 1; i >= 0; i--) {\n      const label = this.state.labels[i];\n      if (label.statementStart === node.start) {\n        label.statementStart = this.state.start;\n        label.kind = kind;\n      } else {\n        break;\n      }\n    }\n    this.state.labels.push({\n      name: maybeName,\n      kind: kind,\n      statementStart: this.state.start\n    });\n    node.body = flags & 8 ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true) : this.parseStatement();\n    this.state.labels.pop();\n    node.label = expr;\n    return this.finishNode(node, \"LabeledStatement\");\n  }\n  parseExpressionStatement(node, expr, decorators) {\n    node.expression = expr;\n    this.semicolon();\n    return this.finishNode(node, \"ExpressionStatement\");\n  }\n  parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) {\n    const node = this.startNode();\n    if (allowDirectives) {\n      this.state.strictErrors.clear();\n    }\n    this.expect(5);\n    if (createNewLexicalScope) {\n      this.scope.enter(0);\n    }\n    this.parseBlockBody(node, allowDirectives, false, 8, afterBlockParse);\n    if (createNewLexicalScope) {\n      this.scope.exit();\n    }\n    return this.finishNode(node, \"BlockStatement\");\n  }\n  isValidDirective(stmt) {\n    return stmt.type === \"ExpressionStatement\" && stmt.expression.type === \"StringLiteral\" && !stmt.expression.extra.parenthesized;\n  }\n  parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {\n    const body = node.body = [];\n    const directives = node.directives = [];\n    this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end, afterBlockParse);\n  }\n  parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) {\n    const oldStrict = this.state.strict;\n    let hasStrictModeDirective = false;\n    let parsedNonDirective = false;\n    while (!this.match(end)) {\n      const stmt = topLevel ? this.parseModuleItem() : this.parseStatementListItem();\n      if (directives && !parsedNonDirective) {\n        if (this.isValidDirective(stmt)) {\n          const directive = this.stmtToDirective(stmt);\n          directives.push(directive);\n          if (!hasStrictModeDirective && directive.value.value === \"use strict\") {\n            hasStrictModeDirective = true;\n            this.setStrict(true);\n          }\n          continue;\n        }\n        parsedNonDirective = true;\n        this.state.strictErrors.clear();\n      }\n      body.push(stmt);\n    }\n    afterBlockParse == null || afterBlockParse.call(this, hasStrictModeDirective);\n    if (!oldStrict) {\n      this.setStrict(false);\n    }\n    this.next();\n  }\n  parseFor(node, init) {\n    node.init = init;\n    this.semicolon(false);\n    node.test = this.match(13) ? null : this.parseExpression();\n    this.semicolon(false);\n    node.update = this.match(11) ? null : this.parseExpression();\n    this.expect(11);\n    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());\n    this.scope.exit();\n    this.state.labels.pop();\n    return this.finishNode(node, \"ForStatement\");\n  }\n  parseForIn(node, init, awaitAt) {\n    const isForIn = this.match(58);\n    this.next();\n    if (isForIn) {\n      if (awaitAt !== null) this.unexpected(awaitAt);\n    } else {\n      node.await = awaitAt !== null;\n    }\n    if (init.type === \"VariableDeclaration\" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== \"var\" || init.declarations[0].id.type !== \"Identifier\")) {\n      this.raise(Errors.ForInOfLoopInitializer, init, {\n        type: isForIn ? \"ForInStatement\" : \"ForOfStatement\"\n      });\n    }\n    if (init.type === \"AssignmentPattern\") {\n      this.raise(Errors.InvalidLhs, init, {\n        ancestor: {\n          type: \"ForStatement\"\n        }\n      });\n    }\n    node.left = init;\n    node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();\n    this.expect(11);\n    node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());\n    this.scope.exit();\n    this.state.labels.pop();\n    return this.finishNode(node, isForIn ? \"ForInStatement\" : \"ForOfStatement\");\n  }\n  parseVar(node, isFor, kind, allowMissingInitializer = false) {\n    const declarations = node.declarations = [];\n    node.kind = kind;\n    for (;;) {\n      const decl = this.startNode();\n      this.parseVarId(decl, kind);\n      decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();\n      if (decl.init === null && !allowMissingInitializer) {\n        if (decl.id.type !== \"Identifier\" && !(isFor && (this.match(58) || this.isContextual(102)))) {\n          this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, {\n            kind: \"destructuring\"\n          });\n        } else if ((kind === \"const\" || kind === \"using\" || kind === \"await using\") && !(this.match(58) || this.isContextual(102))) {\n          this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, {\n            kind\n          });\n        }\n      }\n      declarations.push(this.finishNode(decl, \"VariableDeclarator\"));\n      if (!this.eat(12)) break;\n    }\n    return node;\n  }\n  parseVarId(decl, kind) {\n    const id = this.parseBindingAtom();\n    if (kind === \"using\" || kind === \"await using\") {\n      if (id.type === \"ArrayPattern\" || id.type === \"ObjectPattern\") {\n        this.raise(Errors.UsingDeclarationHasBindingPattern, id.loc.start);\n      }\n    }\n    this.checkLVal(id, {\n      type: \"VariableDeclarator\"\n    }, kind === \"var\" ? 5 : 8201);\n    decl.id = id;\n  }\n  parseAsyncFunctionExpression(node) {\n    return this.parseFunction(node, 8);\n  }\n  parseFunction(node, flags = 0) {\n    const hangingDeclaration = flags & 2;\n    const isDeclaration = !!(flags & 1);\n    const requireId = isDeclaration && !(flags & 4);\n    const isAsync = !!(flags & 8);\n    this.initFunction(node, isAsync);\n    if (this.match(55)) {\n      if (hangingDeclaration) {\n        this.raise(Errors.GeneratorInSingleStatementContext, this.state.startLoc);\n      }\n      this.next();\n      node.generator = true;\n    }\n    if (isDeclaration) {\n      node.id = this.parseFunctionId(requireId);\n    }\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    this.state.maybeInArrowParameters = false;\n    this.scope.enter(2);\n    this.prodParam.enter(functionFlags(isAsync, node.generator));\n    if (!isDeclaration) {\n      node.id = this.parseFunctionId();\n    }\n    this.parseFunctionParams(node, false);\n    this.withSmartMixTopicForbiddingContext(() => {\n      this.parseFunctionBodyAndFinish(node, isDeclaration ? \"FunctionDeclaration\" : \"FunctionExpression\");\n    });\n    this.prodParam.exit();\n    this.scope.exit();\n    if (isDeclaration && !hangingDeclaration) {\n      this.registerFunctionStatementId(node);\n    }\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    return node;\n  }\n  parseFunctionId(requireId) {\n    return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null;\n  }\n  parseFunctionParams(node, isConstructor) {\n    this.expect(10);\n    this.expressionScope.enter(newParameterDeclarationScope());\n    node.params = this.parseBindingList(11, 41, 2 | (isConstructor ? 4 : 0));\n    this.expressionScope.exit();\n  }\n  registerFunctionStatementId(node) {\n    if (!node.id) return;\n    this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? 5 : 8201 : 17, node.id.loc.start);\n  }\n  parseClass(node, isStatement, optionalId) {\n    this.next();\n    const 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  isClassProperty() {\n    return this.match(29) || this.match(13) || this.match(8);\n  }\n  isClassMethod() {\n    return this.match(10);\n  }\n  nameIsConstructor(key) {\n    return key.type === \"Identifier\" && key.name === \"constructor\" || key.type === \"StringLiteral\" && key.value === \"constructor\";\n  }\n  isNonstaticConstructor(method) {\n    return !method.computed && !method.static && this.nameIsConstructor(method.key);\n  }\n  parseClassBody(hadSuperClass, oldStrict) {\n    this.classScope.enter();\n    const state = {\n      hadConstructor: false,\n      hadSuperClass\n    };\n    let decorators = [];\n    const classBody = this.startNode();\n    classBody.body = [];\n    this.expect(5);\n    this.withSmartMixTopicForbiddingContext(() => {\n      while (!this.match(8)) {\n        if (this.eat(13)) {\n          if (decorators.length > 0) {\n            throw this.raise(Errors.DecoratorSemicolon, this.state.lastTokEndLoc);\n          }\n          continue;\n        }\n        if (this.match(26)) {\n          decorators.push(this.parseDecorator());\n          continue;\n        }\n        const member = this.startNode();\n        if (decorators.length) {\n          member.decorators = decorators;\n          this.resetStartLocationFromNode(member, decorators[0]);\n          decorators = [];\n        }\n        this.parseClassMember(classBody, member, state);\n        if (member.kind === \"constructor\" && member.decorators && member.decorators.length > 0) {\n          this.raise(Errors.DecoratorConstructor, member);\n        }\n      }\n    });\n    this.state.strict = oldStrict;\n    this.next();\n    if (decorators.length) {\n      throw this.raise(Errors.TrailingDecorator, this.state.startLoc);\n    }\n    this.classScope.exit();\n    return this.finishNode(classBody, \"ClassBody\");\n  }\n  parseClassMemberFromModifier(classBody, member) {\n    const key = this.parseIdentifier(true);\n    if (this.isClassMethod()) {\n      const 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      const 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    this.resetPreviousNodeTrailingComments(key);\n    return false;\n  }\n  parseClassMember(classBody, member, state) {\n    const isStatic = this.isContextual(106);\n    if (isStatic) {\n      if (this.parseClassMemberFromModifier(classBody, member)) {\n        return;\n      }\n      if (this.eat(5)) {\n        this.parseClassStaticBlock(classBody, member);\n        return;\n      }\n    }\n    this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);\n  }\n  parseClassMemberWithIsStatic(classBody, member, state, isStatic) {\n    const publicMethod = member;\n    const privateMethod = member;\n    const publicProp = member;\n    const privateProp = member;\n    const accessorProp = member;\n    const method = publicMethod;\n    const publicMember = publicMethod;\n    member.static = isStatic;\n    this.parsePropertyNamePrefixOperator(member);\n    if (this.eat(55)) {\n      method.kind = \"method\";\n      const isPrivateName = this.match(138);\n      this.parseClassElementName(method);\n      if (isPrivateName) {\n        this.pushClassPrivateMethod(classBody, privateMethod, true, false);\n        return;\n      }\n      if (this.isNonstaticConstructor(publicMethod)) {\n        this.raise(Errors.ConstructorIsGenerator, publicMethod.key);\n      }\n      this.pushClassMethod(classBody, publicMethod, true, false, false, false);\n      return;\n    }\n    const isContextual = !this.state.containsEsc && tokenIsIdentifier(this.state.type);\n    const key = this.parseClassElementName(member);\n    const maybeContextualKw = isContextual ? key.name : null;\n    const isPrivate = this.isPrivateName(key);\n    const maybeQuestionTokenStartLoc = this.state.startLoc;\n    this.parsePostMemberNameModifiers(publicMember);\n    if (this.isClassMethod()) {\n      method.kind = \"method\";\n      if (isPrivate) {\n        this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n        return;\n      }\n      const isConstructor = this.isNonstaticConstructor(publicMethod);\n      let allowsDirectSuper = false;\n      if (isConstructor) {\n        publicMethod.kind = \"constructor\";\n        if (state.hadConstructor && !this.hasPlugin(\"typescript\")) {\n          this.raise(Errors.DuplicateConstructor, key);\n        }\n        if (isConstructor && this.hasPlugin(\"typescript\") && member.override) {\n          this.raise(Errors.OverrideOnConstructor, key);\n        }\n        state.hadConstructor = true;\n        allowsDirectSuper = state.hadSuperClass;\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 (maybeContextualKw === \"async\" && !this.isLineTerminator()) {\n      this.resetPreviousNodeTrailingComments(key);\n      const isGenerator = this.eat(55);\n      if (publicMember.optional) {\n        this.unexpected(maybeQuestionTokenStartLoc);\n      }\n      method.kind = \"method\";\n      const isPrivate = this.match(138);\n      this.parseClassElementName(method);\n      this.parsePostMemberNameModifiers(publicMember);\n      if (isPrivate) {\n        this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);\n      } else {\n        if (this.isNonstaticConstructor(publicMethod)) {\n          this.raise(Errors.ConstructorIsAsync, publicMethod.key);\n        }\n        this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);\n      }\n    } else if ((maybeContextualKw === \"get\" || maybeContextualKw === \"set\") && !(this.match(55) && this.isLineTerminator())) {\n      this.resetPreviousNodeTrailingComments(key);\n      method.kind = maybeContextualKw;\n      const isPrivate = this.match(138);\n      this.parseClassElementName(publicMethod);\n      if (isPrivate) {\n        this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n      } else {\n        if (this.isNonstaticConstructor(publicMethod)) {\n          this.raise(Errors.ConstructorIsAccessor, publicMethod.key);\n        }\n        this.pushClassMethod(classBody, publicMethod, false, false, false, false);\n      }\n      this.checkGetterSetterParams(publicMethod);\n    } else if (maybeContextualKw === \"accessor\" && !this.isLineTerminator()) {\n      this.expectPlugin(\"decoratorAutoAccessors\");\n      this.resetPreviousNodeTrailingComments(key);\n      const isPrivate = this.match(138);\n      this.parseClassElementName(publicProp);\n      this.pushClassAccessorProperty(classBody, accessorProp, isPrivate);\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  parseClassElementName(member) {\n    const {\n      type,\n      value\n    } = this.state;\n    if ((type === 132 || type === 133) && member.static && value === \"prototype\") {\n      this.raise(Errors.StaticPrototype, this.state.startLoc);\n    }\n    if (type === 138) {\n      if (value === \"constructor\") {\n        this.raise(Errors.ConstructorClassPrivateField, this.state.startLoc);\n      }\n      const key = this.parsePrivateName();\n      member.key = key;\n      return key;\n    }\n    this.parsePropertyName(member);\n    return member.key;\n  }\n  parseClassStaticBlock(classBody, member) {\n    var _member$decorators;\n    this.scope.enter(64 | 128 | 16);\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n    this.prodParam.enter(0);\n    const body = member.body = [];\n    this.parseBlockOrModuleBlockBody(body, undefined, false, 8);\n    this.prodParam.exit();\n    this.scope.exit();\n    this.state.labels = oldLabels;\n    classBody.body.push(this.finishNode(member, \"StaticBlock\"));\n    if ((_member$decorators = member.decorators) != null && _member$decorators.length) {\n      this.raise(Errors.DecoratorStaticBlock, member);\n    }\n  }\n  pushClassProperty(classBody, prop) {\n    if (!prop.computed && this.nameIsConstructor(prop.key)) {\n      this.raise(Errors.ConstructorClassField, prop.key);\n    }\n    classBody.body.push(this.parseClassProperty(prop));\n  }\n  pushClassPrivateProperty(classBody, prop) {\n    const node = this.parseClassPrivateProperty(prop);\n    classBody.body.push(node);\n    this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);\n  }\n  pushClassAccessorProperty(classBody, prop, isPrivate) {\n    if (!isPrivate && !prop.computed && this.nameIsConstructor(prop.key)) {\n      this.raise(Errors.ConstructorClassField, prop.key);\n    }\n    const node = this.parseClassAccessorProperty(prop);\n    classBody.body.push(node);\n    if (isPrivate) {\n      this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);\n    }\n  }\n  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n    classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, \"ClassMethod\", true));\n  }\n  pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {\n    const node = this.parseMethod(method, isGenerator, isAsync, false, false, \"ClassPrivateMethod\", true);\n    classBody.body.push(node);\n    const kind = node.kind === \"get\" ? node.static ? 6 : 2 : node.kind === \"set\" ? node.static ? 5 : 1 : 0;\n    this.declareClassPrivateMethodInScope(node, kind);\n  }\n  declareClassPrivateMethodInScope(node, kind) {\n    this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start);\n  }\n  parsePostMemberNameModifiers(methodOrProp) {}\n  parseClassPrivateProperty(node) {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassPrivateProperty\");\n  }\n  parseClassProperty(node) {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassProperty\");\n  }\n  parseClassAccessorProperty(node) {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassAccessorProperty\");\n  }\n  parseInitializer(node) {\n    this.scope.enter(64 | 16);\n    this.expressionScope.enter(newExpressionScope());\n    this.prodParam.enter(0);\n    node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;\n    this.expressionScope.exit();\n    this.prodParam.exit();\n    this.scope.exit();\n  }\n  parseClassId(node, isStatement, optionalId, bindingType = 8331) {\n    if (tokenIsIdentifier(this.state.type)) {\n      node.id = this.parseIdentifier();\n      if (isStatement) {\n        this.declareNameFromIdentifier(node.id, bindingType);\n      }\n    } else {\n      if (optionalId || !isStatement) {\n        node.id = null;\n      } else {\n        throw this.raise(Errors.MissingClassName, this.state.startLoc);\n      }\n    }\n  }\n  parseClassSuper(node) {\n    node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;\n  }\n  parseExport(node, decorators) {\n    const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);\n    const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);\n    const parseAfterDefault = !hasDefault || this.eat(12);\n    const hasStar = parseAfterDefault && this.eatExportStar(node);\n    const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);\n    const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12));\n    const isFromRequired = hasDefault || hasStar;\n    if (hasStar && !hasNamespace) {\n      if (hasDefault) this.unexpected();\n      if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, node);\n      }\n      this.parseExportFrom(node, true);\n      return this.finishNode(node, \"ExportAllDeclaration\");\n    }\n    const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);\n    if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {\n      this.unexpected(null, 5);\n    }\n    if (hasNamespace && parseAfterNamespace) {\n      this.unexpected(null, 98);\n    }\n    let hasDeclaration;\n    if (isFromRequired || hasSpecifiers) {\n      hasDeclaration = false;\n      if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, node);\n      }\n      this.parseExportFrom(node, isFromRequired);\n    } else {\n      hasDeclaration = this.maybeParseExportDeclaration(node);\n    }\n    if (isFromRequired || hasSpecifiers || hasDeclaration) {\n      var _node2$declaration;\n      const node2 = node;\n      this.checkExport(node2, true, false, !!node2.source);\n      if (((_node2$declaration = node2.declaration) == null ? void 0 : _node2$declaration.type) === \"ClassDeclaration\") {\n        this.maybeTakeDecorators(decorators, node2.declaration, node2);\n      } else if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, node);\n      }\n      return this.finishNode(node2, \"ExportNamedDeclaration\");\n    }\n    if (this.eat(65)) {\n      const node2 = node;\n      const decl = this.parseExportDefaultExpression();\n      node2.declaration = decl;\n      if (decl.type === \"ClassDeclaration\") {\n        this.maybeTakeDecorators(decorators, decl, node2);\n      } else if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, node);\n      }\n      this.checkExport(node2, true, true);\n      return this.finishNode(node2, \"ExportDefaultDeclaration\");\n    }\n    this.unexpected(null, 5);\n  }\n  eatExportStar(node) {\n    return this.eat(55);\n  }\n  maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {\n    if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {\n      this.expectPlugin(\"exportDefaultFrom\", maybeDefaultIdentifier == null ? void 0 : maybeDefaultIdentifier.loc.start);\n      const id = maybeDefaultIdentifier || this.parseIdentifier(true);\n      const specifier = this.startNodeAtNode(id);\n      specifier.exported = id;\n      node.specifiers = [this.finishNode(specifier, \"ExportDefaultSpecifier\")];\n      return true;\n    }\n    return false;\n  }\n  maybeParseExportNamespaceSpecifier(node) {\n    if (this.isContextual(93)) {\n      var _ref, _ref$specifiers;\n      (_ref$specifiers = (_ref = node).specifiers) != null ? _ref$specifiers : _ref.specifiers = [];\n      const specifier = this.startNodeAt(this.state.lastTokStartLoc);\n      this.next();\n      specifier.exported = this.parseModuleExportName();\n      node.specifiers.push(this.finishNode(specifier, \"ExportNamespaceSpecifier\"));\n      return true;\n    }\n    return false;\n  }\n  maybeParseExportNamedSpecifiers(node) {\n    if (this.match(5)) {\n      const node2 = node;\n      if (!node2.specifiers) node2.specifiers = [];\n      const isTypeExport = node2.exportKind === \"type\";\n      node2.specifiers.push(...this.parseExportSpecifiers(isTypeExport));\n      node2.source = null;\n      node2.declaration = null;\n      if (this.hasPlugin(\"importAssertions\")) {\n        node2.assertions = [];\n      }\n      return true;\n    }\n    return false;\n  }\n  maybeParseExportDeclaration(node) {\n    if (this.shouldParseExportDeclaration()) {\n      node.specifiers = [];\n      node.source = null;\n      if (this.hasPlugin(\"importAssertions\")) {\n        node.assertions = [];\n      }\n      node.declaration = this.parseExportDeclaration(node);\n      return true;\n    }\n    return false;\n  }\n  isAsyncFunction() {\n    if (!this.isContextual(95)) return false;\n    const next = this.nextTokenInLineStart();\n    return this.isUnparsedContextual(next, \"function\");\n  }\n  parseExportDefaultExpression() {\n    const expr = this.startNode();\n    if (this.match(68)) {\n      this.next();\n      return this.parseFunction(expr, 1 | 4);\n    } else if (this.isAsyncFunction()) {\n      this.next();\n      this.next();\n      return this.parseFunction(expr, 1 | 4 | 8);\n    }\n    if (this.match(80)) {\n      return this.parseClass(expr, true, true);\n    }\n    if (this.match(26)) {\n      if (this.hasPlugin(\"decorators\") && this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") === true) {\n        this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);\n      }\n      return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);\n    }\n    if (this.match(75) || this.match(74) || this.isLet()) {\n      throw this.raise(Errors.UnsupportedDefaultExport, this.state.startLoc);\n    }\n    const res = this.parseMaybeAssignAllowIn();\n    this.semicolon();\n    return res;\n  }\n  parseExportDeclaration(node) {\n    if (this.match(80)) {\n      const node = this.parseClass(this.startNode(), true, false);\n      return node;\n    }\n    return this.parseStatementListItem();\n  }\n  isExportDefaultSpecifier() {\n    const {\n      type\n    } = this.state;\n    if (tokenIsIdentifier(type)) {\n      if (type === 95 && !this.state.containsEsc || type === 100) {\n        return false;\n      }\n      if ((type === 130 || type === 129) && !this.state.containsEsc) {\n        const {\n          type: nextType\n        } = this.lookahead();\n        if (tokenIsIdentifier(nextType) && nextType !== 98 || nextType === 5) {\n          this.expectOnePlugin([\"flow\", \"typescript\"]);\n          return false;\n        }\n      }\n    } else if (!this.match(65)) {\n      return false;\n    }\n    const next = this.nextTokenStart();\n    const hasFrom = this.isUnparsedContextual(next, \"from\");\n    if (this.input.charCodeAt(next) === 44 || tokenIsIdentifier(this.state.type) && hasFrom) {\n      return true;\n    }\n    if (this.match(65) && hasFrom) {\n      const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4));\n      return nextAfterFrom === 34 || nextAfterFrom === 39;\n    }\n    return false;\n  }\n  parseExportFrom(node, expect) {\n    if (this.eatContextual(98)) {\n      node.source = this.parseImportSource();\n      this.checkExport(node);\n      this.maybeParseImportAttributes(node);\n      this.checkJSONModuleImport(node);\n    } else if (expect) {\n      this.unexpected();\n    }\n    this.semicolon();\n  }\n  shouldParseExportDeclaration() {\n    const {\n      type\n    } = this.state;\n    if (type === 26) {\n      this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n      if (this.hasPlugin(\"decorators\")) {\n        if (this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") === true) {\n          this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);\n        }\n        return true;\n      }\n    }\n    if (this.isContextual(107)) {\n      this.raise(Errors.UsingDeclarationExport, this.state.startLoc);\n      return true;\n    }\n    if (this.isContextual(96) && this.startsAwaitUsing()) {\n      this.raise(Errors.UsingDeclarationExport, this.state.startLoc);\n      return true;\n    }\n    return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction();\n  }\n  checkExport(node, checkNames, isDefault, isFrom) {\n    if (checkNames) {\n      var _node$specifiers;\n      if (isDefault) {\n        this.checkDuplicateExports(node, \"default\");\n        if (this.hasPlugin(\"exportDefaultFrom\")) {\n          var _declaration$extra;\n          const declaration = node.declaration;\n          if (declaration.type === \"Identifier\" && declaration.name === \"from\" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) {\n            this.raise(Errors.ExportDefaultFromAsIdentifier, declaration);\n          }\n        }\n      } else if ((_node$specifiers = node.specifiers) != null && _node$specifiers.length) {\n        for (const specifier of node.specifiers) {\n          const {\n            exported\n          } = specifier;\n          const exportName = exported.type === \"Identifier\" ? exported.name : exported.value;\n          this.checkDuplicateExports(specifier, exportName);\n          if (!isFrom && specifier.local) {\n            const {\n              local\n            } = specifier;\n            if (local.type !== \"Identifier\") {\n              this.raise(Errors.ExportBindingIsString, specifier, {\n                localName: local.value,\n                exportName\n              });\n            } else {\n              this.checkReservedWord(local.name, local.loc.start, true, false);\n              this.scope.checkLocalExport(local);\n            }\n          }\n        }\n      } else if (node.declaration) {\n        const decl = node.declaration;\n        if (decl.type === \"FunctionDeclaration\" || decl.type === \"ClassDeclaration\") {\n          const {\n            id\n          } = decl;\n          if (!id) throw new Error(\"Assertion failure\");\n          this.checkDuplicateExports(node, id.name);\n        } else if (decl.type === \"VariableDeclaration\") {\n          for (const declaration of decl.declarations) {\n            this.checkDeclaration(declaration.id);\n          }\n        }\n      }\n    }\n  }\n  checkDeclaration(node) {\n    if (node.type === \"Identifier\") {\n      this.checkDuplicateExports(node, node.name);\n    } else if (node.type === \"ObjectPattern\") {\n      for (const prop of node.properties) {\n        this.checkDeclaration(prop);\n      }\n    } else if (node.type === \"ArrayPattern\") {\n      for (const elem of node.elements) {\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  checkDuplicateExports(node, exportName) {\n    if (this.exportedIdentifiers.has(exportName)) {\n      if (exportName === \"default\") {\n        this.raise(Errors.DuplicateDefaultExport, node);\n      } else {\n        this.raise(Errors.DuplicateExport, node, {\n          exportName\n        });\n      }\n    }\n    this.exportedIdentifiers.add(exportName);\n  }\n  parseExportSpecifiers(isInTypeExport) {\n    const nodes = [];\n    let first = true;\n    this.expect(5);\n    while (!this.eat(8)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(12);\n        if (this.eat(8)) break;\n      }\n      const isMaybeTypeOnly = this.isContextual(130);\n      const isString = this.match(133);\n      const node = this.startNode();\n      node.local = this.parseModuleExportName();\n      nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly));\n    }\n    return nodes;\n  }\n  parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {\n    if (this.eatContextual(93)) {\n      node.exported = this.parseModuleExportName();\n    } else if (isString) {\n      node.exported = cloneStringLiteral(node.local);\n    } else if (!node.exported) {\n      node.exported = cloneIdentifier(node.local);\n    }\n    return this.finishNode(node, \"ExportSpecifier\");\n  }\n  parseModuleExportName() {\n    if (this.match(133)) {\n      const result = this.parseStringLiteral(this.state.value);\n      const surrogate = loneSurrogate.exec(result.value);\n      if (surrogate) {\n        this.raise(Errors.ModuleExportNameHasLoneSurrogate, result, {\n          surrogateCharCode: surrogate[0].charCodeAt(0)\n        });\n      }\n      return result;\n    }\n    return this.parseIdentifier(true);\n  }\n  isJSONModuleImport(node) {\n    if (node.assertions != null) {\n      return node.assertions.some(({\n        key,\n        value\n      }) => {\n        return value.value === \"json\" && (key.type === \"Identifier\" ? key.name === \"type\" : key.value === \"type\");\n      });\n    }\n    return false;\n  }\n  checkImportReflection(node) {\n    const {\n      specifiers\n    } = node;\n    const singleBindingType = specifiers.length === 1 ? specifiers[0].type : null;\n    if (node.phase === \"source\") {\n      if (singleBindingType !== \"ImportDefaultSpecifier\") {\n        this.raise(Errors.SourcePhaseImportRequiresDefault, specifiers[0].loc.start);\n      }\n    } else if (node.phase === \"defer\") {\n      if (singleBindingType !== \"ImportNamespaceSpecifier\") {\n        this.raise(Errors.DeferImportRequiresNamespace, specifiers[0].loc.start);\n      }\n    } else if (node.module) {\n      var _node$assertions;\n      if (singleBindingType !== \"ImportDefaultSpecifier\") {\n        this.raise(Errors.ImportReflectionNotBinding, specifiers[0].loc.start);\n      }\n      if (((_node$assertions = node.assertions) == null ? void 0 : _node$assertions.length) > 0) {\n        this.raise(Errors.ImportReflectionHasAssertion, specifiers[0].loc.start);\n      }\n    }\n  }\n  checkJSONModuleImport(node) {\n    if (this.isJSONModuleImport(node) && node.type !== \"ExportAllDeclaration\") {\n      const {\n        specifiers\n      } = node;\n      if (specifiers != null) {\n        const nonDefaultNamedSpecifier = specifiers.find(specifier => {\n          let imported;\n          if (specifier.type === \"ExportSpecifier\") {\n            imported = specifier.local;\n          } else if (specifier.type === \"ImportSpecifier\") {\n            imported = specifier.imported;\n          }\n          if (imported !== undefined) {\n            return imported.type === \"Identifier\" ? imported.name !== \"default\" : imported.value !== \"default\";\n          }\n        });\n        if (nonDefaultNamedSpecifier !== undefined) {\n          this.raise(Errors.ImportJSONBindingNotDefault, nonDefaultNamedSpecifier.loc.start);\n        }\n      }\n    }\n  }\n  isPotentialImportPhase(isExport) {\n    if (isExport) return false;\n    return this.isContextual(105) || this.isContextual(97) || this.isContextual(127);\n  }\n  applyImportPhase(node, isExport, phase, loc) {\n    if (isExport) {\n      return;\n    }\n    if (phase === \"module\") {\n      this.expectPlugin(\"importReflection\", loc);\n      node.module = true;\n    } else if (this.hasPlugin(\"importReflection\")) {\n      node.module = false;\n    }\n    if (phase === \"source\") {\n      this.expectPlugin(\"sourcePhaseImports\", loc);\n      node.phase = \"source\";\n    } else if (phase === \"defer\") {\n      this.expectPlugin(\"deferredImportEvaluation\", loc);\n      node.phase = \"defer\";\n    } else if (this.hasPlugin(\"sourcePhaseImports\")) {\n      node.phase = null;\n    }\n  }\n  parseMaybeImportPhase(node, isExport) {\n    if (!this.isPotentialImportPhase(isExport)) {\n      this.applyImportPhase(node, isExport, null);\n      return null;\n    }\n    const phaseIdentifier = this.parseIdentifier(true);\n    const {\n      type\n    } = this.state;\n    const isImportPhase = tokenIsKeywordOrIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12;\n    if (isImportPhase) {\n      this.resetPreviousIdentifierLeadingComments(phaseIdentifier);\n      this.applyImportPhase(node, isExport, phaseIdentifier.name, phaseIdentifier.loc.start);\n      return null;\n    } else {\n      this.applyImportPhase(node, isExport, null);\n      return phaseIdentifier;\n    }\n  }\n  isPrecedingIdImportPhase(phase) {\n    const {\n      type\n    } = this.state;\n    return tokenIsIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12;\n  }\n  parseImport(node) {\n    if (this.match(133)) {\n      return this.parseImportSourceAndAttributes(node);\n    }\n    return this.parseImportSpecifiersAndAfter(node, this.parseMaybeImportPhase(node, false));\n  }\n  parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier) {\n    node.specifiers = [];\n    const hasDefault = this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier);\n    const parseNext = !hasDefault || this.eat(12);\n    const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);\n    if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);\n    this.expectContextual(98);\n    return this.parseImportSourceAndAttributes(node);\n  }\n  parseImportSourceAndAttributes(node) {\n    var _node$specifiers2;\n    (_node$specifiers2 = node.specifiers) != null ? _node$specifiers2 : node.specifiers = [];\n    node.source = this.parseImportSource();\n    this.maybeParseImportAttributes(node);\n    this.checkImportReflection(node);\n    this.checkJSONModuleImport(node);\n    this.semicolon();\n    return this.finishNode(node, \"ImportDeclaration\");\n  }\n  parseImportSource() {\n    if (!this.match(133)) this.unexpected();\n    return this.parseExprAtom();\n  }\n  parseImportSpecifierLocal(node, specifier, type) {\n    specifier.local = this.parseIdentifier();\n    node.specifiers.push(this.finishImportSpecifier(specifier, type));\n  }\n  finishImportSpecifier(specifier, type, bindingType = 8201) {\n    this.checkLVal(specifier.local, {\n      type\n    }, bindingType);\n    return this.finishNode(specifier, type);\n  }\n  parseImportAttributes() {\n    this.expect(5);\n    const attrs = [];\n    const attrNames = new Set();\n    do {\n      if (this.match(8)) {\n        break;\n      }\n      const node = this.startNode();\n      const keyName = this.state.value;\n      if (attrNames.has(keyName)) {\n        this.raise(Errors.ModuleAttributesWithDuplicateKeys, this.state.startLoc, {\n          key: keyName\n        });\n      }\n      attrNames.add(keyName);\n      if (this.match(133)) {\n        node.key = this.parseStringLiteral(keyName);\n      } else {\n        node.key = this.parseIdentifier(true);\n      }\n      this.expect(14);\n      if (!this.match(133)) {\n        throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);\n      }\n      node.value = this.parseStringLiteral(this.state.value);\n      attrs.push(this.finishNode(node, \"ImportAttribute\"));\n    } while (this.eat(12));\n    this.expect(8);\n    return attrs;\n  }\n  parseModuleAttributes() {\n    const attrs = [];\n    const attributes = new Set();\n    do {\n      const node = this.startNode();\n      node.key = this.parseIdentifier(true);\n      if (node.key.name !== \"type\") {\n        this.raise(Errors.ModuleAttributeDifferentFromType, node.key);\n      }\n      if (attributes.has(node.key.name)) {\n        this.raise(Errors.ModuleAttributesWithDuplicateKeys, node.key, {\n          key: node.key.name\n        });\n      }\n      attributes.add(node.key.name);\n      this.expect(14);\n      if (!this.match(133)) {\n        throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);\n      }\n      node.value = this.parseStringLiteral(this.state.value);\n      attrs.push(this.finishNode(node, \"ImportAttribute\"));\n    } while (this.eat(12));\n    return attrs;\n  }\n  maybeParseImportAttributes(node) {\n    let attributes;\n    let useWith = false;\n    if (this.match(76)) {\n      if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) {\n        return;\n      }\n      this.next();\n      {\n        if (this.hasPlugin(\"moduleAttributes\")) {\n          attributes = this.parseModuleAttributes();\n        } else {\n          this.expectImportAttributesPlugin();\n          attributes = this.parseImportAttributes();\n        }\n      }\n      useWith = true;\n    } else if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {\n      if (this.hasPlugin(\"importAttributes\")) {\n        if (this.getPluginOption(\"importAttributes\", \"deprecatedAssertSyntax\") !== true) {\n          this.raise(Errors.ImportAttributesUseAssert, this.state.startLoc);\n        }\n        this.addExtra(node, \"deprecatedAssertSyntax\", true);\n      } else {\n        this.expectOnePlugin([\"importAttributes\", \"importAssertions\"]);\n      }\n      this.next();\n      attributes = this.parseImportAttributes();\n    } else if (this.hasPlugin(\"importAttributes\") || this.hasPlugin(\"importAssertions\")) {\n      attributes = [];\n    } else {\n      if (this.hasPlugin(\"moduleAttributes\")) {\n        attributes = [];\n      } else return;\n    }\n    if (!useWith && this.hasPlugin(\"importAssertions\")) {\n      node.assertions = attributes;\n    } else {\n      node.attributes = attributes;\n    }\n  }\n  maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier) {\n    if (maybeDefaultIdentifier) {\n      const specifier = this.startNodeAtNode(maybeDefaultIdentifier);\n      specifier.local = maybeDefaultIdentifier;\n      node.specifiers.push(this.finishImportSpecifier(specifier, \"ImportDefaultSpecifier\"));\n      return true;\n    } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n      this.parseImportSpecifierLocal(node, this.startNode(), \"ImportDefaultSpecifier\");\n      return true;\n    }\n    return false;\n  }\n  maybeParseStarImportSpecifier(node) {\n    if (this.match(55)) {\n      const specifier = this.startNode();\n      this.next();\n      this.expectContextual(93);\n      this.parseImportSpecifierLocal(node, specifier, \"ImportNamespaceSpecifier\");\n      return true;\n    }\n    return false;\n  }\n  parseNamedImportSpecifiers(node) {\n    let first = true;\n    this.expect(5);\n    while (!this.eat(8)) {\n      if (first) {\n        first = false;\n      } else {\n        if (this.eat(14)) {\n          throw this.raise(Errors.DestructureNamedImport, this.state.startLoc);\n        }\n        this.expect(12);\n        if (this.eat(8)) break;\n      }\n      const specifier = this.startNode();\n      const importedIsString = this.match(133);\n      const isMaybeTypeOnly = this.isContextual(130);\n      specifier.imported = this.parseModuleExportName();\n      const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === \"type\" || node.importKind === \"typeof\", isMaybeTypeOnly, undefined);\n      node.specifiers.push(importSpecifier);\n    }\n  }\n  parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {\n    if (this.eatContextual(93)) {\n      specifier.local = this.parseIdentifier();\n    } else {\n      const {\n        imported\n      } = specifier;\n      if (importedIsString) {\n        throw this.raise(Errors.ImportBindingIsString, specifier, {\n          importName: imported.value\n        });\n      }\n      this.checkReservedWord(imported.name, specifier.loc.start, true, true);\n      if (!specifier.local) {\n        specifier.local = cloneIdentifier(imported);\n      }\n    }\n    return this.finishImportSpecifier(specifier, \"ImportSpecifier\", bindingType);\n  }\n  isThisParam(param) {\n    return param.type === \"Identifier\" && param.name === \"this\";\n  }\n}\nclass Parser extends StatementParser {\n  constructor(options, input, pluginsMap) {\n    options = getOptions(options);\n    super(options, input);\n    this.options = options;\n    this.initializeScopes();\n    this.plugins = pluginsMap;\n    this.filename = options.sourceFilename;\n  }\n  getScopeHandler() {\n    return ScopeHandler;\n  }\n  parse() {\n    this.enterInitialScopes();\n    const file = this.startNode();\n    const program = this.startNode();\n    this.nextToken();\n    file.errors = null;\n    this.parseTopLevel(file, program);\n    file.errors = this.state.errors;\n    file.comments.length = this.state.commentsLen;\n    return file;\n  }\n}\nfunction parse(input, options) {\n  var _options;\n  if (((_options = options) == null ? void 0 : _options.sourceType) === \"unambiguous\") {\n    options = Object.assign({}, options);\n    try {\n      options.sourceType = \"module\";\n      const parser = getParser(options, input);\n      const ast = parser.parse();\n      if (parser.sawUnambiguousESM) {\n        return ast;\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      return ast;\n    } catch (moduleError) {\n      try {\n        options.sourceType = \"script\";\n        return getParser(options, input).parse();\n      } catch (_unused2) {}\n      throw moduleError;\n    }\n  } else {\n    return getParser(options, input).parse();\n  }\n}\nfunction parseExpression(input, options) {\n  const parser = getParser(options, input);\n  if (parser.options.strictMode) {\n    parser.state.strict = true;\n  }\n  return parser.getExpression();\n}\nfunction generateExportedTokenTypes(internalTokenTypes) {\n  const tokenTypes = {};\n  for (const typeName of Object.keys(internalTokenTypes)) {\n    tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);\n  }\n  return tokenTypes;\n}\nconst tokTypes = generateExportedTokenTypes(tt);\nfunction getParser(options, input) {\n  let cls = Parser;\n  const pluginsMap = new Map();\n  if (options != null && options.plugins) {\n    for (const plugin of options.plugins) {\n      let name, opts;\n      if (typeof plugin === \"string\") {\n        name = plugin;\n      } else {\n        [name, opts] = plugin;\n      }\n      if (!pluginsMap.has(name)) {\n        pluginsMap.set(name, opts || {});\n      }\n    }\n    validatePlugins(pluginsMap);\n    cls = getParserClass(pluginsMap);\n  }\n  return new cls(options, input, pluginsMap);\n}\nconst parserClassCache = new Map();\nfunction getParserClass(pluginsMap) {\n  const pluginList = [];\n  for (const name of mixinPluginNames) {\n    if (pluginsMap.has(name)) {\n      pluginList.push(name);\n    }\n  }\n  const key = pluginList.join(\"|\");\n  let cls = parserClassCache.get(key);\n  if (!cls) {\n    cls = Parser;\n    for (const plugin of pluginList) {\n      cls = mixinPlugins[plugin](cls);\n    }\n    parserClassCache.set(key, cls);\n  }\n  return cls;\n}\nexports.parse = parse;\nexports.parseExpression = parseExpression;\nexports.tokTypes = tokTypes;\n//# sourceMappingURL=index.js.map\n"],"sourceRoot":""}