{"version":3,"sources":["../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/util/location.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parse-error/module-errors.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parse-error/to-node-description.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parse-error/standard-errors.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parse-error/strict-mode-errors.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parse-error/pipeline-operator-errors.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parse-error.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/options.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/plugins/estree.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/tokenizer/context.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/tokenizer/types.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/babel-helper-validator-identifier/src/identifier.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/babel-helper-validator-identifier/src/keyword.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/util/identifier.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/util/scope.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/plugins/flow/scope.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parser/base.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parser/comments.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/util/whitespace.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/tokenizer/state.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/babel-helper-string-parser/src/index.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/tokenizer/index.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/util/class-scope.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/util/expression-scope.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/util/production-parameter.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parser/util.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parser/node.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/plugins/flow/index.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/plugins/jsx/xhtml.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/plugins/jsx/index.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/plugins/typescript/scope.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parser/lval.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/plugins/typescript/index.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/plugins/placeholders.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/plugins/v8intrinsic.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/plugin-utils.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parser/expression.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parser/statement.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/parser/index.ts","../node_modules/.pnpm/@babel+parser@7.26.7/node_modules/@babel/parser/src/index.ts","../src/preset.ts","../src/codegen/save-story-utils.ts","../src/codegen/generate-story-code.ts","../src/constants.ts"],"names":["Position","constructor","line","col","index","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","ImportCallArity","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","Object","assign","PipeBodyIsTighter","PipeTopicRequiresHackPipes","PipeTopicUnbound","PipeTopicUnconfiguredToken","token","PipeTopicUnused","PipeUnparenthesizedBody","PipelineBodyNoArrow","PipelineBodySequenceExpression","PipelineHeadSequenceExpression","PipelineTopicUnused","PrimaryTopicNotAllowed","PrimaryTopicRequiresSmartPipeline","defineHidden","obj","value","defineProperty","enumerable","configurable","toParseErrorConstructor","toMessage","reasonCode","syntaxPlugin","hasMissingPlugin","oldReasonCodes","AccessorCannotDeclareThisParameter","AccessorCannotHaveTypeParameters","ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference","SetAccessorCannotHaveOptionalParameter","SetAccessorCannotHaveRestParameter","SetAccessorCannotHaveReturnType","loc","details","error","SyntaxError","pos","overrides","_overrides$loc","get","set","writable","ParseErrorEnum","argument","Array","isArray","parseErrorTemplates","ParseErrorConstructors","keys","template","_ref","rest","_objectWithoutPropertiesLoose","_excluded","Errors","PipelineOperatorErrors","createDefaultOptions","sourceType","sourceFilename","undefined","startIndex","startColumn","startLine","allowAwaitOutsideFunction","allowReturnOutsideFunction","allowNewTargetOutsideFunction","allowImportExportEverywhere","allowSuperOutsideMethod","allowUndeclaredExports","plugins","strictMode","ranges","tokens","createImportExpressions","createParenthesizedExpressions","errorRecovery","attachComment","annexB","getOptions","opts","options","Error","toUnenumerable","object","toESTreeLocation","estree","superClass","parse","file","optionFlags","parseRegExpLiteral","pattern","flags","regex","RegExp","estreeParseLiteral","parseBigIntLiteral","bigInt","BigInt","bigint","String","parseDecimalLiteral","decimal","parseLiteral","parseStringLiteral","parseNumericLiteral","parseNullLiteral","parseBooleanLiteral","directiveToStmt","directive","expression","raw","extra","expressionValue","stmt","rawValue","initFunction","isAsync","checkDeclaration","isObjectProperty","getObjectOrClassMethodParams","method","params","isValidDirective","_stmt$expression$extr","parenthesized","parseBlockBody","allowDirectives","topLevel","afterBlockParse","directiveStatements","directives","d","body","concat","parsePrivateName","getPluginOption","convertPrivateNameToPrivateIdentifier","getPrivateNameSV","id","isPrivateName","parseFunctionBody","allowExpression","isMethod","parseMethod","isGenerator","isConstructor","allowDirectSuper","inClassScope","funcNode","startNode","typeParameters","resetStartLocationFromNode","computed","finishNode","nameIsConstructor","parseClassProperty","args","propertyNode","parseClassPrivateProperty","parseObjectMethod","prop","isPattern","isAccessor","shorthand","parseObjectProperty","startLoc","refExpressionErrors","isValidLVal","isUnparenthesizedInAssign","binding","isAssignable","isBinding","toAssignable","isLHS","classScope","usePrivateName","toAssignableObjectExpressionProp","isLast","raise","finishCallExpression","unfinished","optional","callee","_ref2","source","arguments","attributes","toReferencedArguments","parseExport","decorators","exportStartLoc","state","lastTokStartLoc","exported","specifiers","length","_declaration$decorato","declaration","resetStartLocation","parseSubscript","base","noCalls","optionalChainMember","substring","stop","chain","startNodeAtNode","isOptionalMemberExpression","hasPropertyAsPrivateName","isObjectMethod","finishNodeAt","endLoc","resetEndLocation","lastTokEndLoc","TokContext","preserveSpace","types","brace","j_oTag","j_cTag","j_expr","beforeExpr","startsExpr","isLoop","isAssign","postfix","ExportedTokenType","label","conf","rightAssociative","binop","updateContext","keywords","Map","createKeyword","createToken","createBinop","tokenTypeCounter","tokenTypes","tokenLabels","tokenBinops","tokenBeforeExprs","tokenStartsExprs","tokenPrefixes","_options$binop","_options$beforeExpr","_options$startsExpr","_options$prefix","push","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","placeholder","string","num","regexp","privateName","eof","jsxName","jsxText","jsxTagStart","jsxTagEnd","tokenIsIdentifier","tokenKeywordOrIdentifierIsKeyword","tokenIsKeywordOrIdentifier","tokenIsLiteralPropertyName","tokenComesBeforeExpression","tokenCanStartExpression","tokenIsAssignment","tokenIsFlowInterfaceOrTypeOrOpaque","tokenIsLoop","tokenIsKeyword","tokenIsOperator","tokenIsPostfix","tokenIsPrefix","tokenIsTSTypeOperator","tokenIsTSDeclarationStart","tokenLabelName","tokenOperatorPrecedence","tokenIsRightAssociative","tokenIsTemplate","getExportedToken","context","pop","tc","nonASCIIidentifierStartChars","nonASCIIidentifierChars","nonASCIIidentifierStart","nonASCIIidentifier","astralIdentifierStartCodes","astralIdentifierCodes","isInAstralSet","i","isIdentifierStart","test","fromCharCode","isIdentifierChar","reservedWords","strict","strictBind","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","has","isStrictBindOnlyReservedWord","isStrictBindReservedWord","isKeyword","isIteratorStart","current","next","next2","reservedWordLikeSet","canBeReservedWord","Scope","names","firstLexicalName","ScopeHandler","parser","scopeStack","undefinedExports","inTopLevel","currentScope","inFunction","currentVarScopeFlags","allowSuper","currentThisScopeFlags","inClass","inClassAndNotInNonArrowFunction","inStaticBlock","ScopeFlag","inNonArrowFunction","treatFunctionsAsVar","treatFunctionsAsVarInScope","createScope","enter","exit","scope","declareName","bindingType","checkRedeclarationInScope","maybeExportDefined","delete","isRedeclaredInScope","checkLocalExport","FlowScope","declareFunctions","FlowScopeHandler","add","BaseParser","sawUnambiguousESM","ambiguousScriptDifferentAst","sourceToOffsetPos","sourcePos","offsetToSourcePos","offsetPos","hasPlugin","pluginConfig","pluginName","pluginOptions","actualOptions","plugin","_this$plugins$get","setTrailingComments","comments","trailingComments","unshift","setLeadingComments","leadingComments","setInnerComments","innerComments","adjustInnerComments","elements","commentWS","lastElement","CommentsParser","addComment","comment","commentsLen","processComment","commentStack","commentStackLength","lastCommentWS","leadingNode","nodeStart","commentEnd","containingNode","finalizeComment","splice","trailingNode","commentStart","input","charCodeAt","properties","members","finalizeRemainingComments","resetPreviousNodeTrailingComments","resetPreviousIdentifierLeadingComments","takeSurroundingComments","lineBreak","lineBreakG","isNewLine","hasNewLine","skipWhiteSpace","skipWhiteSpaceInLine","isWhitespace","State","curLine","lineStart","errors","potentialArrowAt","noArrowAt","noArrowParamsConversionAt","topicContext","maxNumOfResolvableTopics","maxTopicIndex","labels","ct","firstInvalidTemplateEscapePos","strictErrors","tokensLength","v","init","maybeInArrowParameters","inType","noAnonFunctionType","hasFlowComment","isAmbientContext","inAbstractClass","inDisallowConditionalTypesContext","soloAwait","inFSharpPipelineDirectBody","canStartJSXElement","containsEsc","hasTopLevelAwait","curPosition","clone","slice","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","octalStr","exec","octal","parseInt","len","forceLen","n","readInt","invalidEscapeSequence","allowNumSeparator","bailOnError","forbiddenSiblings","isAllowedSibling","invalid","total","e","Infinity","val","prev","Number","isNaN","unexpectedNumericSeparator","numericSeparatorInEscapeSequence","_isDigit","invalidDigit","indexOf","invalidCodePoint","buildPosition","VALID_REGEX_FLAGS","Token","Tokenizer","isLookahead","errorHandlers_readInt","errorBuilder","errorHandlers_readCodePoint","errorHandlers_readStringContents_string","recordStrictModeErrors","errorHandlers_readStringContents_template","pushToken","checkKeywordEscapes","nextToken","eat","match","createLookaheadState","curContext","lookahead","old","curr","nextTokenStart","nextTokenStartSince","lastIndex","lookaheadCharCode","nextTokenInLineStart","nextTokenInLineStartSince","lookaheadInLineCharCode","codePointAtPos","cp","trail","setStrict","forEach","toParseError","clear","skipSpace","finishToken","getTokenFromCode","skipBlockComment","skipLineComment","startSkip","spaceStart","loop","commentWhitespace","prevType","replaceToken","readToken_numberSign","readToken_interpreter","nextPos","expectPlugin","readWord1","finishOp","readToken_dot","readNumber","readToken_slash","readToken_mult_modulo","width","readToken_pipe_amp","readToken_caret","proposal","topicToken","codePointAt","readToken_atSign","readToken_plus_min","readToken_lt","readToken_gt","size","readToken_eq_excl","readToken_question","readTemplateToken","readRadixNumber","readString","readWord","readRegexp","escaped","content","mods","char","includes","isBigInt","replace","startsWithDot","isFloat","hasExponent","isOctal","hasLeadingZero","integer","underscorePos","isDecimal","parseFloat","quote","readTemplateContinuation","opening","firstCode","escStart","identifierCheck","esc","keywordTypes","raiseOverwrite","expectOnePlugin","pluginNames","some","ClassScope","privateNames","loneAccessors","undefinedPrivateNames","ClassScopeHandler","stack","oldClassScope","from","declarePrivateName","elementType","redefined","accessor","oldStatic","newStatic","oldKind","newKind","ExpressionScope","canBeArrowParameterDeclaration","isCertainlyParameterDeclaration","ArrowHeadParsingScope","declarationErrors","recordDeclarationError","ParsingErrorClass","clearDeclarationError","iterateErrors","iterator","ExpressionScopeHandler","recordParameterInitializerError","origin","recordArrowParameterBindingError","recordAsyncArrowParametersError","validateAsPattern","newParameterDeclarationScope","newArrowHeadScope","newAsyncArrowScope","newExpressionScope","ProductionParameterHandler","stacks","currentFlags","hasAwait","hasYield","hasReturn","hasIn","functionFlags","UtilParser","addExtra","isContextual","isUnparsedContextual","nameStart","nameEnd","nextCh","isLookaheadContextual","eatContextual","expectContextual","canInsertSemicolon","hasPrecedingLineBreak","hasFollowingLineBreak","isLineTerminator","semicolon","allowAsi","expect","tryParse","fn","oldState","abortSignal","failState","thrown","aborted","checkExpressionErrors","andThrow","shorthandAssignLoc","doubleProtoLoc","privateKeyLoc","optionalParametersLoc","hasErrors","isLiteralPropertyName","property","initializeScopes","oldLabels","oldExportedIdentifiers","exportedIdentifiers","oldInModule","oldScope","getScopeHandler","oldProdParam","prodParam","oldExpressionScope","expressionScope","enterInitialScopes","paramFlags","checkDestructuringPrivate","ExpressionErrors","Node","range","NodePrototype","prototype","__clone","newNode","clonePlaceholder","cloneIdentifier","cloned","create","expectedNode","cloneStringLiteral","NodeUtils","startNodeAt","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","shouldParseTypes","matches","flowParseTypeInitialiser","tok","oldInType","flowParseType","flowParsePredicate","moduloLoc","parseExpression","flowParseTypeAndPredicateInitialiser","predicate","flowParseDeclareClass","flowParseInterfaceish","flowParseDeclareFunction","parseIdentifier","typeNode","typeContainer","flowParseTypeParameterDeclaration","tmp","flowParseFunctionTypeParams","this","returnType","typeAnnotation","flowParseDeclare","insideModule","flowParseDeclareVariable","flowParseDeclareModuleExports","flowParseDeclareModule","flowParseDeclareTypeAlias","flowParseDeclareOpaqueType","flowParseDeclareInterface","flowParseDeclareExportDeclaration","flowParseTypeAnnotatableIdentifier","parseExprAtom","bodyNode","parseImport","hasModuleExport","default","isLet","exportKind","flowParseTypeAnnotation","finished","flowParseTypeAlias","flowParseOpaqueType","isClass","flowParseRestrictedIdentifier","extends","flowParseInterfaceExtends","implements","mixins","flowParseObjectType","allowStatic","allowExact","allowSpread","allowProto","allowInexact","flowParseQualifiedTypeIdentifier","flowParseTypeParameterInstantiation","flowParseInterface","checkNotUnderscore","checkReservedType","liberal","right","declare","supertype","impltype","flowParseTypeParameter","requireDefault","nodeStartLoc","variance","flowParseVariance","ident","bound","defaultRequired","typeParameter","flowInTopLevelContext","cb","oldContext","flowParseTypeParameterInstantiationInExpression","reScan_lt","oldNoAnonFunctionType","reScan_lt_gt","flowParseTypeParameterInstantiationCallOrNew","flowParseTypeOrImplicitInstantiation","flowParseInterfaceType","flowParseObjectPropertyKey","flowParseObjectTypeIndexer","isStatic","static","flowParseObjectTypeInternalSlot","flowParseObjectTypeMethodish","flowParseFunctionTypeParam","flowParseObjectTypeCallProperty","valueNode","callProperties","indexers","internalSlots","endDelim","exact","inexact","protoStartLoc","inexactStartLoc","propOrInexact","flowParseObjectTypeProperty","flowObjectTypeSemicolon","proto","flowCheckGetterSetterParams","paramCount","_startLoc","node2","qualification","flowParseGenericType","flowParseTypeofType","flowParsePrimaryType","flowParseTupleType","first","lh","isThis","reinterpretTypeAsFunctionTypeParam","flowIdentToTypeAnnotation","isGroupedType","parseLiteralAtNode","createIdentifier","flowParsePostfixType","seenOptionalIndexedAccess","objectType","indexType","flowParsePrefixType","flowParseAnonFunctionWithoutParens","param","flowParseIntersectionType","flowParseUnionType","allowPrimitiveOverride","typeCastToParameter","allowExpressionBody","forwardNoArrowParamsConversionAt","parseFunctionBodyAndFinish","parseStatementLike","flowParseEnumDeclaration","parseExpressionStatement","expr","shouldParseExportDeclaration","isExportDefaultSpecifier","parseExportDefaultExpression","parseConditional","setOptionalParametersError","originalNoArrowAt","consequent","failed","tryParseConditionalConsequent","valid","getArrowLikeExpressions","alternate","parseMaybeAssign","parseMaybeAssignAllowIn","disallowInvalid","arrows","finishArrowValidation","every","_node$extra","toAssignableList","trailingCommaLoc","checkParams","result","parseParenItem","typeCastNode","assertModuleNodeAllowed","parseExportDeclaration","declarationNode","parseExportSpecifiers","parseExportFrom","eatExportStar","maybeParseExportNamespaceSpecifier","hasNamespace","parseClassId","isStatement","optionalId","parseClassMember","classBody","member","parseClassMemberFromModifier","isIterator","readIterator","fullWord","left","exprList","toReferencedList","isParenthesizedExpr","_expr$extra","parseArrayLike","close","canBePattern","isTuple","isParenthesized","isClassMethod","isClassProperty","isNonstaticConstructor","pushClassMethod","allowsDirectSuper","isThisParam","pushClassPrivateMethod","parseClassSuper","superTypeParameters","implemented","checkGetterSetterParams","parsePropertyNamePrefixOperator","parseObjPropValue","parseFunctionParamType","parseMaybeDefault","checkImportReflection","module","parseImportSpecifierLocal","specifier","local","finishImportSpecifier","isPotentialImportPhase","isExport","applyImportPhase","parseImportSpecifier","importedIsString","isInTypeOnlyImport","isMaybeTypeOnly","firstIdent","imported","specifierTypeKind","as_ident","specifierIsTypeImport","checkReservedWord","parseBindingAtom","parseFunctionParams","parseVarId","decl","parseAsyncArrowFromCallExpression","call","shouldParseAsyncArrow","afterLeftParse","_jsx","jsx","currentContext","_jsx2","_jsx3","abort","_arrowExpression$extr","arrowExpression","maybeUnwrapTypeCastExpression","async","parseArrow","shouldParseArrow","setArrowFunctionParameters","allowDuplicates","isArrowFunction","strictModeChanged","parseParenAndDistinguishExpression","canBeArrow","parseSubscripts","parseCallExpressionArguments","parseAsyncArrowWithTypeParameters","subscriptState","isLookaheadToken_lt","typeArguments","parseNewCallee","targs","parseArrowExpression","parseTopLevel","program","fileNode","skipFlowComment","hasFlowCommentCompletion","commentSkip","shiftToFirstNonWhiteSpace","ch2","ch3","flowEnumErrorBooleanMemberNotInitialized","flowEnumErrorInvalidMemberInitializer","enumContext","flowEnumErrorNumberMemberNotInitialized","flowEnumErrorStringMemberInconsistentlyInitialized","flowEnumMemberInit","endOfInit","literal","flowEnumMemberRaw","flowEnumCheckExplicitTypeMismatch","expectedType","flowEnumMembers","seenNames","booleanMembers","numberMembers","stringMembers","defaultedMembers","hasUnknownMembers","memberNode","toUpperCase","flowEnumStringMembers","initializedMembers","flowEnumParseExplicitType","flowEnumBody","nameLoc","empty","boolsLen","numsLen","strsLen","defaultedLen","jsxParseOpeningElementAfterName","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","jsxReadToken","jsxReadEntity","jsxReadNewLine","normalizeCRLF","jsxReadString","codePoint","count","desc","entity","XHTMLEntities","jsxReadWord","jsxParseIdentifier","jsxParseNamespacedName","jsxParseElementName","jsxParseAttributeValue","setContext","jsxParseExpressionContainer","jsxParseEmptyExpression","jsxParseSpreadChild","previousContext","jsxParseAttribute","jsxParseOpeningElementAt","selfClosing","jsxParseClosingElementAt","jsxParseElementAt","children","openingElement","closingElement","contents","openingFragment","closingFragment","jsxParseElement","newContext","TypeScriptScope","tsNames","TypeScriptScopeHandler","importsStack","hasImport","allowShadow","isConst","wasConst","unwrapParenthesizedExpression","LValParser","_node$extra3","last","_node$extra2","operator","arg","checkToRestConversion","elt","element","toReferencedListDeep","parseSpread","parseRestBinding","parseBindingList","ParseBindingListFlags","parseObjectLike","closeCharCode","allowEmpty","elts","checkCommaAfterRest","parseDecorator","parseAssignableListItem","parseBindingRestProperty","parseBindingProperty","parsePropertyName","_left","checkLVal","checkClashes","hasParenthesizedAncestor","_expression$extra","checkIdentifier","validity","ParseErrorClass","isParenthesizedExpression","nextAncestor","child","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","tsIsIdentifier","tsTokenCanFollowModifier","tsNextTokenOnSameLineAndCanFollowModifier","tsNextTokenCanFollowModifier","tsParseModifier","stopOnStartOfClassStaticBlock","tsIsStartOfStaticBlocks","tsTryParse","modified","enforceOrder","before","after","incompatible","mod1","mod2","accessibility","hasOwnProperty","tsIsListTerminator","tsParseList","parseElement","tsParseDelimitedList","refTrailingCommaPos","tsParseDelimitedListWorker","expectSuccess","trailingCommaPos","tsParseBracketedList","bracket","skipFirstToken","tsParseImportType","qualifier","tsParseEntityName","tsParseEntityNameFlags","tsParseTypeArguments","tsParseTypeReference","typeName","tsParseThisTypePredicate","lhs","parameterName","tsParseTypeAnnotation","asserts","tsParseThisTypeNode","tsParseTypeQuery","exprName","tsParseTypeParameter","parseModifiers","tsParseTypeParameterName","constraint","tsEatThenParseType","tsTryParseTypeParameters","tsParseTypeParameters","tsFillSignature","returnToken","signature","returnTokenRequired","paramsKey","returnTypeKey","tsParseBindingListForSignature","tsParseTypeOrTypePredicateAnnotation","tsParseTypeMemberSemicolon","tsParseSignatureMember","tsIsUnambiguouslyIndexSignature","tsTryParseIndexSignature","tsLookAhead","parameters","tsTryParseTypeAnnotation","tsParsePropertyOrMethodSignature","readonly","nodeAny","firstParameter","tsParseTypeMember","idx","tsParseTypeLiteral","tsParseObjectTypeMembers","tsIsStartOfMappedType","tsParseMappedType","tsExpectThenParseType","nameType","tsParseType","tsTryParseType","tsParseTupleType","elementTypes","tsParseTupleElementType","seenOptionalElement","elementNode","labeled","chAfterWord","wordName","typeOrLabel","tsParseNonArrayType","labeledNode","optionalTypeNode","restNode","tsParseParenthesizedType","tsParseFunctionOrConstructorType","abstract","tsInAllowConditionalTypesContext","tsParseLiteralTypeNode","tsParseTemplateLiteralType","parseTemplate","parseTemplateSubstitution","tsParseThisTypeOrThisTypePredicate","thisKeyword","parseMaybeUnary","nodeType","tsParseArrayTypeOrHigher","tsParseTypeOperator","tsParseTypeOperatorOrHigher","tsCheckTypeAnnotationForReadOnly","tsParseInferType","tsParseConstraintForInferType","tsInDisallowConditionalTypesContext","tsParseUnionOrIntersectionType","parseConstituentType","hasLeadingOperator","tsParseIntersectionTypeOrHigher","tsParseUnionTypeOrHigher","tsIsStartOfFunctionType","tsIsUnambiguouslyStartOfFunctionType","tsSkipParameterStart","previousErrorCount","tsInType","t","tsParseTypePredicateAsserts","thisTypePredicate","typePredicateVariable","tsParseTypePredicatePrefix","tsTryParseTypeOrTypePredicateAnnotation","eatColon","tsParseNonConditionalType","checkType","extendsType","trueType","falseType","isAbstractConstructorSignature","tsParseTypeAssertion","tsParseHeritageClause","originalStartLoc","delimitedList","tsParseInterfaceDeclaration","tsParseTypeAliasDeclaration","tsInTopLevelContext","oldInDisallowConditionalTypesContext","tsNextThenParseType","tsParseEnumMember","initializer","tsParseEnumDeclaration","tsParseEnumBody","tsParseModuleBlock","parseBlockOrModuleBlockBody","tsParseModuleOrNamespaceDeclaration","nested","inner","tsParseAmbientExternalModuleDeclaration","global","tsParseImportEqualsDeclaration","maybeDefaultIdentifier","moduleReference","tsParseModuleReference","tsIsExternalModuleReference","tsParseExternalModuleReference","f","tsTryParseAndCatch","tsTryParseDeclare","nany","startType","tsInAmbientContext","parseFunctionStatement","parseClass","parseVarStatement","tsParseDeclaration","tsTryParseExportDeclaration","tsParseExpressionStatement","mod","tsCheckLineTerminator","tsParseAbstractDeclaration","tsTryParseGenericAsyncArrowFunction","oldMaybeInArrowParameters","tsParseTypeArgumentsInExpression","tsIsDeclarationStart","override","pp","parameter","isSimpleParameter","tsDisallowOptionalPattern","bodilessType","registerFunctionStatementId","tsCheckForInvalidTypeCasts","items","isInParens","nonNullExpression","isOptionalCall","missingParenErrorLoc","atPossibleAsyncArrow","asyncArrowFn","parseTaggedTemplateExpression","tokenType","_callee$extra","parseExprOp","leftStartLoc","minPrec","isSatisfies","checkKeywords","checkDuplicateExports","importNode","parseMaybeImportPhase","parseImportSpecifiersAndAfter","nodeImportEquals","isAbstractClass","cls","allowMissingInitializer","declarations","isValidAmbientConstInitializer","parseStatementContent","parseAccessModifier","tsHasSomeModifiers","callParseClassMemberWithIsStatic","parseClassStaticBlock","parseClassMemberWithIsStatic","hadSuperClass","parsePostMemberNameModifiers","methodOrProp","isDeclare","parseClassPropertyAnnotation","definite","parseClassAccessorProperty","declareClassPrivateMethodInScope","_typeCast","_typeCast2","typeCast","_typeParameters","reportReservedArrowTypeParam","trailingComma","sawUnary","toAssignableParenthesizedExpression","parseMaybeDecoratorArguments","canHaveLeadingDecorator","getGetterSetterExpectedParamCount","baseCount","firstParam","parseCatchClauseParam","oldIsAmbientContext","oldStrict","oldInAbstractClass","maybeTakeDecorators","shouldParseAsAmbientContext","getExpression","parseExportSpecifier","isString","isInTypeExport","parseTypeOnlyImportExportSpecifier","isImport","isInTypeOnlyImportExport","leftOfAsKey","rightOfAsKey","leftOfAs","rightOfAs","hasTypeSpecifier","canParseAsKeyword","firstAs","secondAs","parseModuleExportName","kindKey","isPossiblyLiteralEnum","expressions","isUncomputedMemberExpressionChain","isNumber","isNegativeNumber","PlaceholderErrors","ClassNameIsRequired","UnexpectedSpace","placeholders","parsePlaceholder","assertNoSpace","finishPlaceholder","chStartsBindingIdentifier","verifyBreakContinue","isBreak","parseStatementOrSloppyAnnexBFunctionDeclaration","stmtPlaceholder","parseBlock","createNewLexicalScope","parseFunctionId","requireId","parseClassBody","startsWith","maybeParseExportDefaultSpecifier","_specifiers","checkExport","filter","maybeParseStarImportSpecifier","parseNamedImportSpecifiers","parseImportSource","v8intrinsic","parseV8Intrinsic","v8IntrinsicStartLoc","parseIdentifierName","PIPELINE_PROPOSALS","TOPIC_TOKENS","validatePlugins","pluginsMap","decoratorsBeforeExport","allowCallParenthesized","_pluginsMap$get","proposalList","p","tupleSyntaxIsHash","syntaxType","tokenList","version","deprecatedAssertSyntax","RECORD_AND_TUPLE_SYNTAX_TYPES","missingPlugins","mixinPlugins","mixinPluginNames","ExpressionParser","checkProto","isRecord","protoRef","used","shouldExitDescending","disallowIn","disallowInAnd","parseExpressionBase","allowInAnd","parseMaybeAssignDisallowIn","resultError","_resultError$loc","parseYield","ownExpressionErrors","parseMaybeConditional","parseExprOps","parseMaybeUnaryOrPrivate","op","prec","checkPipelineAtInfixOperator","logical","coalesce","parseExprOpRightExpr","finishedNode","nextOp","withTopicBindingContext","parseHackPipeBody","withSoloAwaitPermittingContext","parseFSharpPipelineBody","parseSmartPipelineBodyInStyle","parseExprOpBaseRightExpr","_body$extra","topicReferenceWasUsedInCurrentContext","checkExponentialAfterUnary","isAwait","recordAwaitIfAllowed","parseAwait","update","isDelete","parseUpdate","isAmbiguousAwait","updateExpressionNode","parseExprSubscripts","maybeAsyncArrow","parseBind","parseCoverCallAndAsyncArrowHead","parseMember","parseNoCallExpr","tag","quasi","allowPlaceholder","nodeForExtra","oldInFSharpPipelineDirectBody","addTrailingCommaExtraToNode","parseExprListItem","_call$extra","parseSuper","parseImportMetaProperty","parseImportCall","parseDo","parseFunctionOrFunctionSent","parseDecorators","parseNewOrNewTarget","parseTopicReferenceThenEqualsSign","parseTopicReference","pipeProposal","lookaheadCh","parseModuleExpression","parseAsyncFunctionExpression","parseAsyncArrowUnaryFunction","topicTokenType","topicTokenValue","finishTopicReference","testTopicReferenceConfiguration","topicReferenceIsAllowedInCurrentContext","registerTopicReference","meta","parseMetaProperty","parseFunction","isSource","innerStartLoc","spreadStartLoc","optionalCommaStartLoc","spreadNodeStartLoc","innerEndLoc","arrowNode","wrapParenthesis","parenExpression","metaProp","parseNew","parseExprList","parseTemplateElement","isTagged","elemStart","elem","isTail","endOffset","elemEnd","cooked","tail","curElt","quasis","substitutions","propHash","parsePropertyDefinition","maybeAsyncOrAccessorProp","keyName","_params","finishedProp","generator","isExpression","hasStrictModeDirective","nonSimple","isSimpleParamList","formalParameters","isAwaitAllowed","delegating","delegate","childExpr","isSimpleReference","checkSmartPipeTopicBodyEarlyErrors","callback","outerContextTopicState","withSmartMixTopicForbiddingContext","outerContextSoloAwaitState","ParamKind","ret","revertScopes","parseProgram","loopLabel","switchLabel","loneSurrogate","keywordRelationalOperator","babel7CompatTokens","hashEndPos","hashEndLoc","backquoteEnd","backquoteEndLoc","startToken","templateValue","templateElementEnd","templateElementEndLoc","endToken","StatementParser","interpreter","parseInterpreterDirective","finishedProgram","stmtToDirective","directiveLiteral","hasFollowingBindingAtom","endCh","chStartsBindingPattern","hasInLineFollowingBindingIdentifierOrBrace","startsUsingForOf","startsAwaitUsing","parseModuleItem","ParseStatementFlag","parseStatementListItem","allowLabeledFunction","parseStatement","allowDeclaration","allowFunctionDeclaration","parseBreakContinueStatement","parseDebuggerStatement","parseDoWhileStatement","parseForStatement","parseIfStatement","parseReturnStatement","parseSwitchStatement","parseThrowStatement","parseTryStatement","parseWhileStatement","parseWithStatement","parseEmptyStatement","nextTokenCharCode","isAsyncFunction","maybeName","parseLabeledStatement","decoratorsEnabledBeforeExport","maybeDecorators","classNode","exportNode","_classNode$decorators","allowExport","paramsStartLoc","lab","parseHeaderExpression","awaitAt","parseFor","startsWithLet","startsWithAwaitUsing","starsWithUsingDeclaration","isLetOrUsing","initNode","parseVar","isForIn","parseForIn","startsWithAsync","isForOf","isHangingDeclaration","ParseFunctionFlag","discriminant","cases","cur","sawDefault","isCase","block","handler","clause","finalizer","statementStart","parsedNonDirective","await","isFor","hangingDeclaration","isDeclaration","hadConstructor","publicMethod","privateMethod","publicProp","privateProp","accessorProp","publicMember","parseClassElementName","maybeContextualKw","isPrivate","maybeQuestionTokenStartLoc","pushClassPrivateProperty","pushClassProperty","pushClassAccessorProperty","_member$decorators","parseInitializer","hasDefault","parseAfterDefault","hasStar","parseAfterNamespace","isFromRequired","hasSpecifiers","maybeParseExportNamedSpecifiers","hasDeclaration","maybeParseExportDeclaration","_node2$declaration","_ref$specifiers","isTypeExport","assertions","nextType","hasFrom","nextAfterFrom","maybeParseImportAttributes","checkJSONModuleImport","checkNames","isDefault","isFrom","_node$specifiers","_declaration$extra","nodes","surrogate","isJSONModuleImport","singleBindingType","_node$assertions","nonDefaultNamedSpecifier","find","phaseIdentifier","isPrecedingIdImportPhase","parseImportSourceAndAttributes","parseNext","maybeParseDefaultImportSpecifier","parseImportAttributes","attrs","attrNames","parseModuleAttributes","useWith","importSpecifier","Parser","_options","getParser","ast","moduleError","generateExportedTokenTypes","internalTokenTypes","tokTypes","getParserClass","parserClassCache","pluginList","SaveStoryError","valueToAST","k","updateArgsInCsfFile","found","argsProperty","a","remainder","traverse","path","duplicateStoryWithNewName","csfFile","originalStoryName","newStoryName","parseArgs","_","removeExtraNewlines","anything","newline","closing","story","updatePlayInCsfFile","play","playProperty","playExpression","preparePlay","prepareLine","updateImportsInCsfFile","imports","packagesToImport","importString","importNodesBySource","existingImport","existingSpecifiers","existingSpecifierNames","s","generateStoryCode","csf","csfId","parsed","stories","componentId","storyId","existingStoryToUpdate","storyNameFromExport","newStoryId","toId","formatFileContent","printCsf","ADDON_ID","EVENTS","experimental_serverChannel","channel","payload","importPath","sourceFilePath","readCsf","userTitle","storyCode","resolve","STORY_RENDERED","writeFile"],"mappings":"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","file":"preset.cjs","sourcesContent":["export type Pos = {\n  start: number;\n};\n\n// These are used when `options.locations` is on, for the\n// `startLoc` and `endLoc` properties.\n\nexport class Position {\n  line: number;\n  column: number;\n  index: number;\n\n  constructor(line: number, col: number, index: number) {\n    this.line = line;\n    this.column = col;\n    this.index = index;\n  }\n}\n\nexport class SourceLocation {\n  start: Position;\n  end: Position;\n  filename: string;\n  identifierName: string | undefined | null;\n\n  constructor(start: Position, end?: Position) {\n    this.start = start;\n    // (may start as null, but initialized later)\n    this.end = end;\n  }\n}\n\n/**\n * creates a new position with a non-zero column offset from the given position.\n * This function should be only be used when we create AST node out of the token\n * boundaries, such as TemplateElement ends before tt.templateNonTail. This\n * function does not skip whitespaces.\n */\nexport function createPositionWithColumnOffset(\n  position: Position,\n  columnOffset: number,\n) {\n  const { line, column, index } = position;\n  return new Position(line, column + columnOffset, index + columnOffset);\n}\n","import type { ParseErrorTemplates } from \"../parse-error.ts\";\n\nconst code = \"BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED\";\n\nexport default {\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} satisfies ParseErrorTemplates;\n","const 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};\n\ntype NodeTypesWithDescriptions = keyof Omit<\n  typeof NodeDescriptions,\n  \"UpdateExpression\"\n>;\n\ntype NodeWithDescription =\n  | {\n      type: \"UpdateExpression\";\n      prefix: boolean;\n    }\n  | {\n      type: NodeTypesWithDescriptions;\n    };\n\nconst toNodeDescription = (node: NodeWithDescription) =>\n  node.type === \"UpdateExpression\"\n    ? NodeDescriptions.UpdateExpression[`${node.prefix}`]\n    : NodeDescriptions[node.type];\n\nexport default toNodeDescription;\n","import type { ParseErrorTemplates } from \"../parse-error.ts\";\nimport toNodeDescription from \"./to-node-description.ts\";\n\nexport type LValAncestor =\n  | { type: \"UpdateExpression\"; prefix: boolean }\n  | {\n      type:\n        | \"ArrayPattern\"\n        | \"AssignmentExpression\"\n        | \"CatchClause\"\n        | \"ForOfStatement\"\n        | \"FormalParameters\"\n        | \"ForInStatement\"\n        | \"ForStatement\"\n        | \"ImportSpecifier\"\n        | \"ImportNamespaceSpecifier\"\n        | \"ImportDefaultSpecifier\"\n        | \"ParenthesizedExpression\"\n        | \"ObjectPattern\"\n        | \"RestElement\"\n        | \"VariableDeclarator\";\n    };\n\nexport default {\n  AccessorIsGenerator: ({ kind }: { kind: \"get\" | \"set\" }) =>\n    `A ${kind}ter cannot be a generator.`,\n  ArgumentsInClass:\n    \"'arguments' is only allowed in functions and class methods.\",\n  AsyncFunctionInSingleStatementContext:\n    \"Async functions can only be declared at the top level or inside a block.\",\n  AwaitBindingIdentifier:\n    \"Can not use 'await' as identifier inside an async function.\",\n  AwaitBindingIdentifierInStaticBlock:\n    \"Can not use 'await' as identifier inside a static block.\",\n  AwaitExpressionFormalParameter:\n    \"'await' is not allowed in async function parameters.\",\n  AwaitUsingNotInAsyncContext:\n    \"'await using' is only allowed within async functions and at the top levels of modules.\",\n  AwaitNotInAsyncContext:\n    \"'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:\n    \"A 'set' accessor function argument must not be a rest parameter.\",\n  ConstructorClassField: \"Classes may not have a field named 'constructor'.\",\n  ConstructorClassPrivateField:\n    \"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  }: {\n    kind: \"await using\" | \"const\" | \"destructuring\" | \"using\";\n  }) => `Missing initializer in ${kind} declaration.`,\n  DecoratorArgumentsOutsideParentheses:\n    \"Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.\",\n  DecoratorBeforeExport:\n    \"Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.\",\n  DecoratorsBeforeAfterExport:\n    \"Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.\",\n  DecoratorConstructor:\n    \"Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?\",\n  DecoratorExportClass:\n    \"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:\n    'Only `import defer * as x from \"./module\"` is valid.',\n  DeletePrivateField: \"Deleting a private field is not allowed.\",\n  DestructureNamedImport:\n    \"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: ({ exportName }: { exportName: string }) =>\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: ({ phase }: { phase: string }) =>\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  }: {\n    localName: string;\n    exportName: string;\n  }) =>\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:\n    \"'from' is not allowed as an identifier after 'export default'.\",\n\n  ForInOfLoopInitializer: ({\n    type,\n  }: {\n    type: \"ForInStatement\" | \"ForOfStatement\";\n  }) =>\n    `'${\n      type === \"ForInStatement\" ? \"for-in\" : \"for-of\"\n    }' loop variable declaration may not have an initializer.`,\n  ForInUsing: \"For-in loop may not start with 'using' declaration.\",\n\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:\n    \"Generators can only be declared at the top level or inside a block.\",\n\n  IllegalBreakContinue: ({\n    type,\n  }: {\n    type: \"BreakStatement\" | \"ContinueStatement\";\n  }) => `Unsyntactic ${type === \"BreakStatement\" ? \"break\" : \"continue\"}.`,\n\n  IllegalLanguageModeDirective:\n    \"Illegal 'use strict' directive in function with non-simple parameter list.\",\n  IllegalReturn: \"'return' outside of function.\",\n  ImportAttributesUseAssert:\n    \"The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedImportAssert` parser plugin to suppress this error.\",\n  ImportBindingIsString: ({ importName }: { importName: string }) =>\n    `A string literal cannot be used as an imported binding.\\n- Did you mean \\`import { \"${importName}\" as foo }\\`?`,\n  ImportCallArity: `\\`import()\\` requires exactly one or two arguments.`,\n  ImportCallNotNewExpression: \"Cannot use new with import(...).\",\n  ImportCallSpreadArgument: \"`...` is not allowed in `import()`.\",\n  ImportJSONBindingNotDefault:\n    \"A JSON module can only be imported with `default`.\",\n  ImportReflectionHasAssertion: \"`import module x` cannot have assertions.\",\n  ImportReflectionNotBinding:\n    'Only `import module x from \"./module\"` is valid.',\n  IncompatibleRegExpUVFlags:\n    \"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: ({ radix }: { radix: number }) =>\n    `Expected number in radix ${radix}.`,\n  InvalidEscapeSequence: \"Bad character escape sequence.\",\n  InvalidEscapeSequenceTemplate: \"Invalid escape sequence in template.\",\n  InvalidEscapedReservedWord: ({ reservedWord }: { reservedWord: string }) =>\n    `Escape sequence in keyword ${reservedWord}.`,\n  InvalidIdentifier: ({ identifierName }: { identifierName: string }) =>\n    `Invalid identifier ${identifierName}.`,\n  InvalidLhs: ({ ancestor }: { ancestor: LValAncestor }) =>\n    `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,\n  InvalidLhsBinding: ({ ancestor }: { ancestor: LValAncestor }) =>\n    `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,\n  InvalidLhsOptionalChaining: ({ ancestor }: { ancestor: LValAncestor }) =>\n    `Invalid optional chaining in the left-hand side of ${toNodeDescription(\n      ancestor,\n    )}.`,\n  InvalidNumber: \"Invalid number.\",\n  InvalidOrMissingExponent:\n    \"Floating-point numbers require a valid exponent after the 'e'.\",\n  InvalidOrUnexpectedToken: ({ unexpected }: { unexpected: string }) =>\n    `Unexpected character '${unexpected}'.`,\n  InvalidParenthesizedAssignment: \"Invalid parenthesized assignment pattern.\",\n  InvalidPrivateFieldResolution: ({\n    identifierName,\n  }: {\n    identifierName: string;\n  }) => `Private name #${identifierName} is not defined.`,\n  InvalidPropertyBindingPattern: \"Binding member expression.\",\n  InvalidRecordProperty:\n    \"Only properties and spread elements are allowed in record definitions.\",\n  InvalidRestAssignmentPattern: \"Invalid rest operator's argument.\",\n  LabelRedeclaration: ({ labelName }: { labelName: string }) =>\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:\n    \"Only '=' operator can be used for specifying default value.\",\n  MissingSemicolon: \"Missing semicolon.\",\n  MissingPlugin: ({ missingPlugin }: { missingPlugin: [string] }) =>\n    `This experimental syntax requires enabling the parser plugin: ${missingPlugin\n      .map(name => JSON.stringify(name))\n      .join(\", \")}.`,\n  // FIXME: Would be nice to make this \"missingPlugins\" instead.\n  // Also, seems like we can drop the \"(s)\" from the message and just make it \"s\".\n  MissingOneOfPlugins: ({ missingPlugin }: { missingPlugin: string[] }) =>\n    `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin\n      .map(name => JSON.stringify(name))\n      .join(\", \")}.`,\n  MissingUnicodeEscape: \"Expecting Unicode escape sequence \\\\uXXXX.\",\n  MixingCoalesceWithLogical:\n    \"Nullish coalescing operator(??) requires parens when mixing with logical operators.\",\n  ModuleAttributeDifferentFromType:\n    \"The only accepted module attribute is `type`.\",\n  ModuleAttributeInvalidValue:\n    \"Only string literals are allowed as module attribute values.\",\n  ModuleAttributesWithDuplicateKeys: ({ key }: { key: string }) =>\n    `Duplicate key \"${key}\" is not allowed in module attributes.`,\n  ModuleExportNameHasLoneSurrogate: ({\n    surrogateCharCode,\n  }: {\n    surrogateCharCode: number;\n  }) =>\n    `An export name cannot include a lone surrogate, found '\\\\u${surrogateCharCode.toString(\n      16,\n    )}'.`,\n  ModuleExportUndefined: ({ localName }: { localName: string }) =>\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:\n    \"Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.\",\n  ObsoleteAwaitStar:\n    \"'await*' has been removed from the async functions proposal. Use Promise.all() instead.\",\n  OptionalChainingNoNew:\n    \"Constructors in/after an Optional Chain are not allowed.\",\n  OptionalChainingNoTemplate:\n    \"Tagged Template Literals are not allowed in optionalChain.\",\n  OverrideOnConstructor:\n    \"'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: ({ identifierName }: { identifierName: string }) =>\n    `Private names are only allowed in property accesses (\\`obj.#${identifierName}\\`) or in \\`in\\` expressions (\\`#${identifierName} in obj\\`).`,\n  PrivateNameRedeclaration: ({ identifierName }: { identifierName: string }) =>\n    `Duplicate private name #${identifierName}.`,\n  RecordExpressionBarIncorrectEndSyntaxType:\n    \"Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n  RecordExpressionBarIncorrectStartSyntaxType:\n    \"Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n  RecordExpressionHashIncorrectStartSyntaxType:\n    \"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:\n    \"In non-strict mode code, functions can only be declared at top level or inside a block.\",\n  SloppyFunctionAnnexB:\n    \"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:\n    'Only `import source x from \"./module\"` is valid.',\n  StaticPrototype: \"Classes may not have static property named prototype.\",\n  SuperNotAllowed:\n    \"`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:\n    \"Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n  TupleExpressionBarIncorrectStartSyntaxType:\n    \"Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n  TupleExpressionHashIncorrectStartSyntaxType:\n    \"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:\n    'Unexpected \"await\" after pipeline body; await must have parentheses in minimal proposal.',\n  UnexpectedDigitAfterHash: \"Unexpected digit after hash token.\",\n  UnexpectedImportExport:\n    \"'import' and 'export' may only appear at the top level.\",\n  UnexpectedKeyword: ({ keyword }: { keyword: string }) =>\n    `Unexpected keyword '${keyword}'.`,\n  UnexpectedLeadingDecorator:\n    \"Leading decorators must be attached to a class declaration.\",\n  UnexpectedLexicalDeclaration:\n    \"Lexical declaration cannot appear in a single-statement context.\",\n  UnexpectedNewTarget:\n    \"`new.target` can only be used in functions or class properties.\",\n  UnexpectedNumericSeparator:\n    \"A numeric separator is only allowed between two digits.\",\n  UnexpectedPrivateField: \"Unexpected private name.\",\n  UnexpectedReservedWord: ({ reservedWord }: { reservedWord: string }) =>\n    `Unexpected reserved word '${reservedWord}'.`,\n  UnexpectedSuper: \"'super' is only allowed in object methods and classes.\",\n  UnexpectedToken: ({\n    expected,\n    unexpected,\n  }: {\n    expected?: string | null;\n    unexpected?: string | null;\n  }) =>\n    `Unexpected token${unexpected ? ` '${unexpected}'.` : \"\"}${\n      expected ? `, expected \"${expected}\"` : \"\"\n    }`,\n  UnexpectedTokenUnaryExponentiation:\n    \"Illegal expression. Wrap left hand side or entire exponentiation in parentheses.\",\n  UnexpectedUsingDeclaration:\n    \"Using declaration cannot appear in the top level when source type is `script`.\",\n  UnsupportedBind: \"Binding should be performed on object property.\",\n  UnsupportedDecoratorExport:\n    \"A decorated export must export a class declaration.\",\n  UnsupportedDefaultExport:\n    \"Only expressions, functions or classes are allowed as the `default` export.\",\n  UnsupportedImport:\n    \"`import` can only be used in `import()` or `import.meta`.\",\n  UnsupportedMetaProperty: ({\n    target,\n    onlyValidPropertyName,\n  }: {\n    target: string;\n    onlyValidPropertyName: string;\n  }) =>\n    `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,\n  UnsupportedParameterDecorator:\n    \"Decorators cannot be used to decorate parameters.\",\n  UnsupportedPropertyDecorator:\n    \"Decorators cannot be used to decorate object literal properties.\",\n  UnsupportedSuper:\n    \"'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:\n    \"Using declaration cannot have destructuring patterns.\",\n  VarRedeclaration: ({ identifierName }: { identifierName: string }) =>\n    `Identifier '${identifierName}' has already been declared.`,\n  YieldBindingIdentifier:\n    \"Can not use 'yield' as identifier inside a generator.\",\n  YieldInParameter: \"Yield expression is not allowed in formal parameters.\",\n  ZeroDigitNumericSeparator:\n    \"Numeric separator can not be used after leading 0.\",\n} satisfies ParseErrorTemplates;\n","import type { ParseErrorTemplates } from \"../parse-error\";\n\nexport default {\n  StrictDelete: \"Deleting local variable in strict mode.\",\n\n  // `referenceName` is the StringValue[1] of an IdentifierReference[2], which\n  // is represented as just an `Identifier`[3] in the Babel AST.\n  // 1. https://tc39.es/ecma262/#sec-static-semantics-stringvalue\n  // 2. https://tc39.es/ecma262/#prod-IdentifierReference\n  // 3. https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md#identifier\n  StrictEvalArguments: ({ referenceName }: { referenceName: string }) =>\n    `Assigning to '${referenceName}' in strict mode.`,\n\n  // `bindingName` is the StringValue[1] of a BindingIdentifier[2], which is\n  // represented as just an `Identifier`[3] in the Babel AST.\n  // 1. https://tc39.es/ecma262/#sec-static-semantics-stringvalue\n  // 2. https://tc39.es/ecma262/#prod-BindingIdentifier\n  // 3. https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md#identifier\n  StrictEvalArgumentsBinding: ({ bindingName }: { bindingName: string }) =>\n    `Binding '${bindingName}' in strict mode.`,\n\n  StrictFunction:\n    \"In strict mode code, functions can only be declared at top level or inside a block.\",\n\n  StrictNumericEscape: \"The only valid numeric escape in strict mode is '\\\\0'.\",\n\n  StrictOctalLiteral: \"Legacy octal literals are not allowed in strict mode.\",\n\n  StrictWith: \"'with' in strict mode.\",\n} satisfies ParseErrorTemplates;\n","import type { ParseErrorTemplates } from \"../parse-error.ts\";\nimport toNodeDescription from \"./to-node-description.ts\";\n\nexport const UnparenthesizedPipeBodyDescriptions = new Set([\n  \"ArrowFunctionExpression\",\n  \"AssignmentExpression\",\n  \"ConditionalExpression\",\n  \"YieldExpression\",\n] as const);\n\ntype GetSetMemberType<T extends Set<any>> =\n  T extends Set<infer M> ? M : unknown;\n\nexport type UnparenthesizedPipeBodyTypes = GetSetMemberType<\n  typeof UnparenthesizedPipeBodyDescriptions\n>;\n\nexport default {\n  // This error is only used by the smart-mix proposal\n  PipeBodyIsTighter:\n    \"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: process.env.BABEL_8_BREAKING\n    ? 'Topic references are only supported when using the `\"proposal\": \"hack\"` version of the pipeline proposal.'\n    : 'Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.',\n  PipeTopicUnbound:\n    \"Topic reference is unbound; it must be inside a pipe body.\",\n  PipeTopicUnconfiguredToken: ({ token }: { token: string }) =>\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:\n    \"Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.\",\n  PipeUnparenthesizedBody: ({ type }: { type: UnparenthesizedPipeBodyTypes }) =>\n    `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({\n      type,\n    })}; please wrap it in parentheses.`,\n\n  ...(process.env.BABEL_8_BREAKING\n    ? {}\n    : {\n        // Messages whose codes start with “Pipeline” or “PrimaryTopic”\n        // are retained for backwards compatibility\n        // with the deprecated smart-mix pipe operator proposal plugin.\n        // They are subject to removal in a future major version.\n        PipelineBodyNoArrow:\n          'Unexpected arrow \"=>\" after pipeline body; arrow function in pipeline body must be parenthesized.',\n        PipelineBodySequenceExpression:\n          \"Pipeline body may not be a comma-separated sequence expression.\",\n        PipelineHeadSequenceExpression:\n          \"Pipeline head should not be a comma-separated sequence expression.\",\n        PipelineTopicUnused:\n          \"Pipeline is in topic style but does not use topic reference.\",\n        PrimaryTopicNotAllowed:\n          \"Topic reference was used in a lexical context without topic binding.\",\n        PrimaryTopicRequiresSmartPipeline:\n          'Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.',\n      }),\n} satisfies ParseErrorTemplates;\n","import { Position } from \"./util/location.ts\";\n\ntype SyntaxPlugin =\n  | \"flow\"\n  | \"typescript\"\n  | \"jsx\"\n  | \"pipelineOperator\"\n  | \"placeholders\";\n\ntype ParseErrorCode =\n  | \"BABEL_PARSER_SYNTAX_ERROR\"\n  | \"BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED\";\n\n// Babel uses \"normal\" SyntaxErrors for it's errors, but adds some extra\n// functionality. This functionality is defined in the\n// `ParseErrorSpecification` interface below. We may choose to change to someday\n// give our errors their own full-blown class, but until then this allow us to\n// keep all the desirable properties of SyntaxErrors (like their name in stack\n// traces, etc.), and also allows us to punt on any publicly facing\n// class-hierarchy decisions until Babel 8.\ninterface ParseErrorSpecification<ErrorDetails> {\n  // Look, these *could* be readonly, but then Flow complains when we initially\n  // set them. We could do a whole dance and make a special interface that's not\n  // readonly for when we create the error, then cast it to the readonly\n  // interface for public use, but the previous implementation didn't have them\n  // as readonly, so let's just not worry about it for now.\n  code: ParseErrorCode;\n  reasonCode: string;\n  syntaxPlugin?: SyntaxPlugin;\n  missingPlugin?: string | string[];\n  loc: Position;\n  details: ErrorDetails;\n\n  // We should consider removing this as it now just contains the same\n  // information as `loc.index`.\n  pos: number;\n}\n\nexport type ParseError<ErrorDetails> = SyntaxError &\n  ParseErrorSpecification<ErrorDetails>;\n\n// By `ParseErrorConstructor`, we mean something like the new-less style\n// `ErrorConstructor`[1], since `ParseError`'s are not themselves actually\n// separate classes from `SyntaxError`'s.\n//\n// 1. https://github.com/microsoft/TypeScript/blob/v4.5.5/lib/lib.es5.d.ts#L1027\nexport type ParseErrorConstructor<ErrorDetails> = (\n  loc: Position,\n  details: ErrorDetails,\n) => ParseError<ErrorDetails>;\n\ntype ToMessage<ErrorDetails> = (self: ErrorDetails) => string;\n\ntype ParseErrorCredentials<ErrorDetails> = {\n  code: string;\n  reasonCode: string;\n  syntaxPlugin?: SyntaxPlugin;\n  toMessage: ToMessage<ErrorDetails>;\n};\n\nfunction defineHidden(obj: object, key: string, value: unknown) {\n  Object.defineProperty(obj, key, {\n    enumerable: false,\n    configurable: true,\n    value,\n  });\n}\n\nfunction toParseErrorConstructor<ErrorDetails extends object>({\n  toMessage,\n  code,\n  reasonCode,\n  syntaxPlugin,\n}: ParseErrorCredentials<ErrorDetails>): ParseErrorConstructor<ErrorDetails> {\n  const hasMissingPlugin =\n    reasonCode === \"MissingPlugin\" || reasonCode === \"MissingOneOfPlugins\";\n\n  if (!process.env.BABEL_8_BREAKING) {\n    const oldReasonCodes: Record<string, string> = {\n      AccessorCannotDeclareThisParameter: \"AccesorCannotDeclareThisParameter\",\n      AccessorCannotHaveTypeParameters: \"AccesorCannotHaveTypeParameters\",\n      ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference:\n        \"ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference\",\n      SetAccessorCannotHaveOptionalParameter:\n        \"SetAccesorCannotHaveOptionalParameter\",\n      SetAccessorCannotHaveRestParameter: \"SetAccesorCannotHaveRestParameter\",\n      SetAccessorCannotHaveReturnType: \"SetAccesorCannotHaveReturnType\",\n    };\n    if (oldReasonCodes[reasonCode]) {\n      reasonCode = oldReasonCodes[reasonCode];\n    }\n  }\n\n  return function constructor(loc: Position, details: ErrorDetails) {\n    const error: ParseError<ErrorDetails> = new SyntaxError() as any;\n\n    error.code = code as ParseErrorCode;\n    error.reasonCode = reasonCode;\n    error.loc = loc;\n    error.pos = loc.index;\n\n    error.syntaxPlugin = syntaxPlugin;\n    if (hasMissingPlugin) {\n      error.missingPlugin = (details as any).missingPlugin;\n    }\n\n    type Overrides = {\n      loc?: Position;\n      details?: ErrorDetails;\n    };\n    defineHidden(error, \"clone\", function clone(overrides: Overrides = {}) {\n      const { line, column, index } = overrides.loc ?? loc;\n      return constructor(new Position(line, column, index), {\n        ...details,\n        ...overrides.details,\n      });\n    });\n\n    defineHidden(error, \"details\", details);\n\n    Object.defineProperty(error, \"message\", {\n      configurable: true,\n      get(this: ParseError<ErrorDetails>): string {\n        const message = `${toMessage(details)} (${loc.line}:${loc.column})`;\n        this.message = message;\n        return message;\n      },\n      set(value: string) {\n        Object.defineProperty(this, \"message\", { value, writable: true });\n      },\n    });\n\n    return error;\n  };\n}\n\ntype ParseErrorTemplate =\n  | string\n  | ToMessage<any>\n  | { message: string | ToMessage<any>; code?: ParseErrorCode };\n\nexport type ParseErrorTemplates = { [reasonCode: string]: ParseErrorTemplate };\n\n// This is the templated form of `ParseErrorEnum`.\n//\n// Note: We could factor out the return type calculation into something like\n// `ParseErrorConstructor<T extends ParseErrorTemplates>`, and then we could\n// reuse it in the non-templated form of `ParseErrorEnum`, but TypeScript\n// doesn't seem to drill down that far when showing you the computed type of\n// an object in an editor, so we'll leave it inlined for now.\nexport function ParseErrorEnum(a: TemplateStringsArray): <\n  T extends ParseErrorTemplates,\n>(\n  parseErrorTemplates: T,\n) => {\n  [K in keyof T]: ParseErrorConstructor<\n    T[K] extends { message: string | ToMessage<any> }\n      ? T[K][\"message\"] extends ToMessage<any>\n        ? Parameters<T[K][\"message\"]>[0]\n        : object\n      : T[K] extends ToMessage<any>\n        ? Parameters<T[K]>[0]\n        : object\n  >;\n};\n\nexport function ParseErrorEnum<T extends ParseErrorTemplates>(\n  parseErrorTemplates: T,\n  syntaxPlugin?: SyntaxPlugin,\n): {\n  [K in keyof T]: ParseErrorConstructor<\n    T[K] extends { message: string | ToMessage<any> }\n      ? T[K][\"message\"] extends ToMessage<any>\n        ? Parameters<T[K][\"message\"]>[0]\n        : object\n      : T[K] extends ToMessage<any>\n        ? Parameters<T[K]>[0]\n        : object\n  >;\n};\n\n// You call `ParseErrorEnum` with a mapping from `ReasonCode`'s to either:\n//\n// 1. a static error message,\n// 2. `toMessage` functions that define additional necessary `details` needed by\n//    the `ParseError`, or\n// 3. Objects that contain a `message` of one of the above and overridden `code`\n//    and/or `reasonCode`:\n//\n// ParseErrorEnum `optionalSyntaxPlugin` ({\n//   ErrorWithStaticMessage: \"message\",\n//   ErrorWithDynamicMessage: ({ type } : { type: string }) => `${type}`),\n//   ErrorWithOverriddenCodeAndOrReasonCode: {\n//     message: ({ type }: { type: string }) => `${type}`),\n//     code: \"AN_ERROR_CODE\",\n//     ...(BABEL_8_BREAKING ? { } : { reasonCode: \"CustomErrorReasonCode\" })\n//   }\n// });\n//\nexport function ParseErrorEnum(\n  argument: TemplateStringsArray | ParseErrorTemplates,\n  syntaxPlugin?: SyntaxPlugin,\n) {\n  // If the first parameter is an array, that means we were called with a tagged\n  // template literal. Extract the syntaxPlugin from this, and call again in\n  // the \"normalized\" form.\n  if (Array.isArray(argument)) {\n    return (parseErrorTemplates: ParseErrorTemplates) =>\n      ParseErrorEnum(parseErrorTemplates, argument[0]);\n  }\n\n  const ParseErrorConstructors = {} as Record<\n    string,\n    ParseErrorConstructor<unknown>\n  >;\n\n  for (const reasonCode of Object.keys(argument)) {\n    const template = (argument as ParseErrorTemplates)[reasonCode];\n    const { message, ...rest } =\n      typeof template === \"string\"\n        ? { message: () => template }\n        : typeof template === \"function\"\n          ? { message: template }\n          : template;\n    const toMessage = typeof message === \"string\" ? () => message : message;\n\n    ParseErrorConstructors[reasonCode] = toParseErrorConstructor({\n      code: \"BABEL_PARSER_SYNTAX_ERROR\",\n      reasonCode,\n      toMessage,\n      ...(syntaxPlugin ? { syntaxPlugin } : {}),\n      ...rest,\n    });\n  }\n\n  return ParseErrorConstructors;\n}\n\nimport ModuleErrors from \"./parse-error/module-errors.ts\";\nimport StandardErrors from \"./parse-error/standard-errors.ts\";\nimport StrictModeErrors from \"./parse-error/strict-mode-errors.ts\";\nimport PipelineOperatorErrors from \"./parse-error/pipeline-operator-errors.ts\";\n\nexport const Errors = {\n  ...ParseErrorEnum(ModuleErrors),\n  ...ParseErrorEnum(StandardErrors),\n  ...ParseErrorEnum(StrictModeErrors),\n  ...ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors),\n};\n\nexport type { LValAncestor } from \"./parse-error/standard-errors.ts\";\n","import type { PluginList } from \"./plugin-utils.ts\";\n\n// A second optional argument can be given to further configure\n// the parser process. These options are recognized:\n\nexport type SourceType = \"script\" | \"module\" | \"unambiguous\";\n\nexport interface Options {\n  sourceType?: SourceType;\n  sourceFilename?: string;\n  startIndex?: number;\n  startColumn?: number;\n  startLine?: number;\n  allowAwaitOutsideFunction?: boolean;\n  allowReturnOutsideFunction?: boolean;\n  allowNewTargetOutsideFunction?: boolean;\n  allowImportExportEverywhere?: boolean;\n  allowSuperOutsideMethod?: boolean;\n  allowUndeclaredExports?: boolean;\n  plugins?: PluginList;\n  strictMode?: boolean | undefined | null;\n  ranges?: boolean;\n  tokens?: boolean;\n  createImportExpressions?: boolean;\n  createParenthesizedExpressions?: boolean;\n  errorRecovery?: boolean;\n  attachComment?: boolean;\n  annexB?: boolean;\n}\n\nexport const enum OptionFlags {\n  AllowAwaitOutsideFunction = 1 << 0,\n  AllowReturnOutsideFunction = 1 << 1,\n  AllowNewTargetOutsideFunction = 1 << 2,\n  AllowImportExportEverywhere = 1 << 3,\n  AllowSuperOutsideMethod = 1 << 4,\n  AllowUndeclaredExports = 1 << 5,\n  Ranges = 1 << 6,\n  Tokens = 1 << 7,\n  CreateImportExpressions = 1 << 8,\n  CreateParenthesizedExpressions = 1 << 9,\n  ErrorRecovery = 1 << 10,\n  AttachComment = 1 << 11,\n  AnnexB = 1 << 12,\n}\n\ntype OptionsWithDefaults = { [P in keyof Options]-?: Options[P] };\n\nfunction createDefaultOptions(): OptionsWithDefaults {\n  return {\n    // Source type (\"script\" or \"module\") for different semantics\n    sourceType: \"script\",\n    // Source filename.\n    sourceFilename: undefined,\n    // Index (0-based) from which to start counting source. Useful for\n    // integration with other tools.\n    startIndex: 0,\n    // Column (0-based) from which to start counting source. Useful for\n    // integration with other tools.\n    startColumn: 0,\n    // Line (1-based) from which to start counting source. Useful for\n    // integration with other tools.\n    startLine: 1,\n    // When enabled, await at the top level is not considered an\n    // error.\n    allowAwaitOutsideFunction: false,\n    // When enabled, a return at the top level is not considered an\n    // error.\n    allowReturnOutsideFunction: false,\n    // When enabled, new.target outside a function or class is not\n    // considered an error.\n    allowNewTargetOutsideFunction: false,\n    // When enabled, import/export statements are not constrained to\n    // appearing at the top of the program.\n    allowImportExportEverywhere: false,\n    // TODO\n    allowSuperOutsideMethod: false,\n    // When enabled, export statements can reference undeclared variables.\n    allowUndeclaredExports: false,\n    // An array of plugins to enable\n    plugins: [],\n    // TODO\n    strictMode: null,\n    // Nodes have their start and end characters offsets recorded in\n    // `start` and `end` properties (directly on the node, rather than\n    // the `loc` object, which holds line/column data. To also add a\n    // [semi-standardized][range] `range` property holding a `[start,\n    // end]` array with the same numbers, set the `ranges` option to\n    // `true`.\n    //\n    // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678\n    ranges: false,\n    // Adds all parsed tokens to a `tokens` property on the `File` node\n    tokens: false,\n    // Whether to create ImportExpression AST nodes (if false\n    // `import(foo)` will be parsed as CallExpression(Import, [Identifier(foo)])\n    createImportExpressions: process.env.BABEL_8_BREAKING ? true : false,\n    // Whether to create ParenthesizedExpression AST nodes (if false\n    // the parser sets extra.parenthesized on the expression nodes instead).\n    createParenthesizedExpressions: false,\n    // When enabled, errors are attached to the AST instead of being directly thrown.\n    // Some errors will still throw, because @babel/parser can't always recover.\n    errorRecovery: false,\n    // When enabled, comments will be attached to adjacent AST nodes as one of\n    // `leadingComments`, `trailingComments` and `innerComments`. The comment attachment\n    // is vital to preserve comments after transform. If you don't print AST back,\n    // consider set this option to `false` for performance\n    attachComment: true,\n    // When enabled, the parser will support Annex B syntax.\n    // https://tc39.es/ecma262/#sec-additional-ecmascript-features-for-web-browsers\n    annexB: true,\n  };\n}\n\n// Interpret and default an options object\n\nexport function getOptions(opts?: Options | null): OptionsWithDefaults {\n  // https://github.com/babel/babel/pull/16918\n  // `options` is accessed frequently, please make sure it is a fast object.\n  // `%ToFastProperties` can make it a fast object, but the performance is the same as the slow object.\n  const options: any = createDefaultOptions();\n\n  if (opts == null) {\n    return options;\n  }\n  if (opts.annexB != null && opts.annexB !== false) {\n    throw new Error(\"The `annexB` option can only be set to `false`.\");\n  }\n\n  for (const key of Object.keys(options) as (keyof Options)[]) {\n    if (opts[key] != null) options[key] = opts[key];\n  }\n\n  if (options.startLine === 1) {\n    if (opts.startIndex == null && options.startColumn > 0) {\n      options.startIndex = options.startColumn;\n    } else if (opts.startColumn == null && options.startIndex > 0) {\n      options.startColumn = options.startIndex;\n    }\n  } else if (opts.startColumn == null || opts.startIndex == null) {\n    if (opts.startIndex != null || process.env.BABEL_8_BREAKING) {\n      throw new Error(\n        \"With a `startLine > 1` you must also specify `startIndex` and `startColumn`.\",\n      );\n    }\n  }\n\n  return options;\n}\n","import type { TokenType } from \"../tokenizer/types.ts\";\nimport type Parser from \"../parser/index.ts\";\nimport type { ExpressionErrors } from \"../parser/util.ts\";\nimport type * as N from \"../types.ts\";\nimport type { Node as NodeType, NodeBase, File } from \"../types.ts\";\nimport type { Position } from \"../util/location.ts\";\nimport { Errors } from \"../parse-error.ts\";\nimport type { Undone } from \"../parser/node.ts\";\nimport type { BindingFlag } from \"../util/scopeflags.ts\";\nimport { OptionFlags } from \"../options.ts\";\n\nconst { defineProperty } = Object;\nconst toUnenumerable = (object: any, key: string) => {\n  if (object) {\n    defineProperty(object, key, { enumerable: false, value: object[key] });\n  }\n};\n\nfunction toESTreeLocation(node: any) {\n  toUnenumerable(node.loc.start, \"index\");\n  toUnenumerable(node.loc.end, \"index\");\n\n  return node;\n}\n\nexport default (superClass: typeof Parser) =>\n  class ESTreeParserMixin extends superClass implements Parser {\n    parse(): File {\n      const file = toESTreeLocation(super.parse());\n\n      if (this.optionFlags & OptionFlags.Tokens) {\n        file.tokens = file.tokens.map(toESTreeLocation);\n      }\n\n      return file;\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    parseRegExpLiteral({ pattern, flags }): N.EstreeRegExpLiteral {\n      let regex: RegExp | null = null;\n      try {\n        regex = new RegExp(pattern, flags);\n      } catch (_) {\n        // In environments that don't support these flags value will\n        // be null as the regex can't be represented natively.\n      }\n      const node = this.estreeParseLiteral<N.EstreeRegExpLiteral>(regex);\n      node.regex = { pattern, flags };\n\n      return node;\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    parseBigIntLiteral(value: any): N.Node {\n      // https://github.com/estree/estree/blob/master/es2020.md#bigintliteral\n      let bigInt: bigint | null;\n      try {\n        bigInt = BigInt(value);\n      } catch {\n        bigInt = null;\n      }\n      const node = this.estreeParseLiteral<N.EstreeBigIntLiteral>(bigInt);\n      node.bigint = String(node.value || value);\n\n      return node;\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    parseDecimalLiteral(value: any): N.Node {\n      // https://github.com/estree/estree/blob/master/experimental/decimal.md\n      // todo: use BigDecimal when node supports it.\n      const decimal: null = null;\n      const node = this.estreeParseLiteral(decimal);\n      node.decimal = String(node.value || value);\n\n      return node;\n    }\n\n    estreeParseLiteral<T extends N.EstreeLiteral>(value: any) {\n      // @ts-expect-error ESTree plugin changes node types\n      return this.parseLiteral<T>(value, \"Literal\");\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    parseStringLiteral(value: any): N.Node {\n      return this.estreeParseLiteral(value);\n    }\n\n    parseNumericLiteral(value: any): any {\n      return this.estreeParseLiteral(value);\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    parseNullLiteral(): N.Node {\n      return this.estreeParseLiteral(null);\n    }\n\n    parseBooleanLiteral(value: boolean): N.BooleanLiteral {\n      // @ts-expect-error ESTree plugin changes node types\n      return this.estreeParseLiteral(value);\n    }\n\n    // Cast a Directive to an ExpressionStatement. Mutates the input Directive.\n    directiveToStmt(directive: N.Directive): N.ExpressionStatement {\n      const expression = directive.value as any as N.EstreeLiteral;\n      delete directive.value;\n\n      expression.type = \"Literal\";\n      // @ts-expect-error N.EstreeLiteral.raw is not defined.\n      expression.raw = expression.extra.raw;\n      expression.value = expression.extra.expressionValue;\n\n      const stmt = directive as any as N.ExpressionStatement;\n      stmt.type = \"ExpressionStatement\";\n      stmt.expression = expression;\n      // @ts-expect-error N.ExpressionStatement.directive is not defined\n      stmt.directive = expression.extra.rawValue;\n\n      delete expression.extra;\n\n      return stmt;\n    }\n\n    // ==================================\n    // Overrides\n    // ==================================\n\n    initFunction(node: N.BodilessFunctionOrMethodBase, isAsync: boolean): void {\n      super.initFunction(node, isAsync);\n      node.expression = false;\n    }\n\n    checkDeclaration(node: N.Pattern | N.ObjectProperty): void {\n      if (node != null && this.isObjectProperty(node)) {\n        // @ts-expect-error plugin typings\n        this.checkDeclaration((node as unknown as N.EstreeProperty).value);\n      } else {\n        super.checkDeclaration(node);\n      }\n    }\n\n    getObjectOrClassMethodParams(method: N.ObjectMethod | N.ClassMethod) {\n      return (method as unknown as N.EstreeMethodDefinition).value.params;\n    }\n\n    isValidDirective(stmt: N.Statement): boolean {\n      return (\n        stmt.type === \"ExpressionStatement\" &&\n        stmt.expression.type === \"Literal\" &&\n        typeof stmt.expression.value === \"string\" &&\n        !stmt.expression.extra?.parenthesized\n      );\n    }\n\n    parseBlockBody(\n      node: N.BlockStatementLike,\n      allowDirectives: boolean | undefined | null,\n      topLevel: boolean,\n      end: TokenType,\n      afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n    ): void {\n      super.parseBlockBody(\n        node,\n        allowDirectives,\n        topLevel,\n        end,\n        afterBlockParse,\n      );\n\n      const directiveStatements = node.directives.map(d =>\n        this.directiveToStmt(d),\n      );\n      // @ts-expect-error estree plugin typings\n      node.body = directiveStatements.concat(node.body);\n      delete node.directives;\n    }\n\n    parsePrivateName(): any {\n      const node = super.parsePrivateName();\n      if (!process.env.BABEL_8_BREAKING) {\n        if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n          return node;\n        }\n      }\n      return this.convertPrivateNameToPrivateIdentifier(node);\n    }\n\n    convertPrivateNameToPrivateIdentifier(\n      node: N.PrivateName,\n    ): N.EstreePrivateIdentifier {\n      const name = super.getPrivateNameSV(node);\n      node = node as any;\n      delete node.id;\n      // @ts-expect-error mutate AST types\n      node.name = name;\n      // @ts-expect-error mutate AST types\n      node.type = \"PrivateIdentifier\";\n      return node as unknown as N.EstreePrivateIdentifier;\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    isPrivateName(node: N.Node): node is N.EstreePrivateIdentifier {\n      if (!process.env.BABEL_8_BREAKING) {\n        if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n          return super.isPrivateName(node);\n        }\n      }\n      return node.type === \"PrivateIdentifier\";\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    getPrivateNameSV(node: N.EstreePrivateIdentifier): string {\n      if (!process.env.BABEL_8_BREAKING) {\n        if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n          return super.getPrivateNameSV(node as unknown as N.PrivateName);\n        }\n      }\n      return node.name;\n    }\n\n    // @ts-expect-error plugin may override interfaces\n    parseLiteral<T extends N.Literal>(value: any, type: T[\"type\"]): T {\n      const node = super.parseLiteral<T>(value, type);\n      // @ts-expect-error mutating AST types\n      node.raw = node.extra.raw;\n      delete node.extra;\n\n      return node;\n    }\n\n    parseFunctionBody(\n      node: N.Function,\n      allowExpression?: boolean | null,\n      isMethod: boolean = false,\n    ): void {\n      super.parseFunctionBody(node, allowExpression, isMethod);\n      node.expression = node.body.type !== \"BlockStatement\";\n    }\n\n    // @ts-expect-error plugin may override interfaces\n    parseMethod<\n      T extends N.ClassPrivateMethod | N.ObjectMethod | N.ClassMethod,\n    >(\n      node: Undone<T>,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isConstructor: boolean,\n      allowDirectSuper: boolean,\n      type: T[\"type\"],\n      inClassScope: boolean = false,\n    ): N.EstreeMethodDefinition | N.EstreeTSAbstractMethodDefinition {\n      let funcNode = this.startNode<N.MethodLike>();\n      funcNode.kind = node.kind; // provide kind, so super method correctly sets state\n      funcNode = super.parseMethod(\n        // @ts-expect-error todo(flow->ts)\n        funcNode,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowDirectSuper,\n        type,\n        inClassScope,\n      );\n      // @ts-expect-error mutate AST types\n      funcNode.type = \"FunctionExpression\";\n      delete funcNode.kind;\n      // @ts-expect-error mutate AST types\n      node.value = funcNode;\n      const { typeParameters } = node;\n      if (typeParameters) {\n        delete node.typeParameters;\n        funcNode.typeParameters = typeParameters;\n        this.resetStartLocationFromNode(funcNode, typeParameters);\n      }\n      if (type === \"ClassPrivateMethod\") {\n        node.computed = false;\n      }\n      if (process.env.BABEL_8_BREAKING && this.hasPlugin(\"typescript\")) {\n        if (!funcNode.body) {\n          (funcNode as unknown as N.EstreeTSEmptyBodyFunctionExpression).type =\n            \"TSEmptyBodyFunctionExpression\";\n        }\n        // @ts-expect-error todo(flow->ts) property not defined for all types in union\n        if (node.abstract) {\n          return this.finishNode(\n            // @ts-expect-error cast methods to estree types\n            node as Undone<N.EstreeTSAbstractMethodDefinition>,\n            \"TSAbstractMethodDefinition\",\n          );\n        }\n      }\n      return this.finishNode(\n        // @ts-expect-error cast methods to estree types\n        node as Undone<N.EstreeMethodDefinition>,\n        \"MethodDefinition\",\n      );\n    }\n\n    nameIsConstructor(key: N.Expression | N.PrivateName): boolean {\n      if (key.type === \"Literal\") return key.value === \"constructor\";\n      return super.nameIsConstructor(key);\n    }\n\n    parseClassProperty(...args: [N.ClassProperty]): any {\n      const propertyNode = super.parseClassProperty(...args);\n      if (!process.env.BABEL_8_BREAKING) {\n        if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n          return propertyNode as unknown as N.EstreePropertyDefinition;\n        }\n      }\n      if (\n        process.env.BABEL_8_BREAKING &&\n        propertyNode.abstract &&\n        this.hasPlugin(\"typescript\")\n      ) {\n        (propertyNode as unknown as N.EstreeTSAbstractPropertyDefinition).type =\n          \"TSAbstractPropertyDefinition\";\n      } else {\n        (propertyNode as unknown as N.EstreePropertyDefinition).type =\n          \"PropertyDefinition\";\n      }\n      return propertyNode;\n    }\n\n    parseClassPrivateProperty(...args: [N.ClassPrivateProperty]): any {\n      const propertyNode = super.parseClassPrivateProperty(...args);\n      if (!process.env.BABEL_8_BREAKING) {\n        if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n          return propertyNode as unknown as N.EstreePropertyDefinition;\n        }\n      }\n      if (\n        process.env.BABEL_8_BREAKING &&\n        propertyNode.abstract &&\n        this.hasPlugin(\"typescript\")\n      ) {\n        (propertyNode as unknown as N.EstreeTSAbstractPropertyDefinition).type =\n          \"TSAbstractPropertyDefinition\";\n      } else {\n        (propertyNode as unknown as N.EstreePropertyDefinition).type =\n          \"PropertyDefinition\";\n      }\n      propertyNode.computed = false;\n      return propertyNode;\n    }\n\n    parseObjectMethod(\n      prop: N.ObjectMethod,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isPattern: boolean,\n      isAccessor: boolean,\n    ): N.ObjectMethod | undefined | null {\n      const node: N.EstreeProperty = super.parseObjectMethod(\n        prop,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n      ) as any;\n\n      if (node) {\n        node.type = \"Property\";\n        if ((node as any as N.ClassMethod).kind === \"method\") {\n          node.kind = \"init\";\n        }\n        node.shorthand = false;\n      }\n\n      return node as any;\n    }\n\n    parseObjectProperty(\n      prop: N.ObjectProperty,\n      startLoc: Position | undefined | null,\n      isPattern: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ObjectProperty | undefined | null {\n      const node: N.EstreeProperty = super.parseObjectProperty(\n        prop,\n        startLoc,\n        isPattern,\n        refExpressionErrors,\n      ) as any;\n\n      if (node) {\n        node.kind = \"init\";\n        node.type = \"Property\";\n      }\n\n      return node as any;\n    }\n\n    isValidLVal(\n      type: string,\n      isUnparenthesizedInAssign: boolean,\n      binding: BindingFlag,\n    ) {\n      return type === \"Property\"\n        ? \"value\"\n        : super.isValidLVal(type, isUnparenthesizedInAssign, binding);\n    }\n\n    isAssignable(node: N.Node, isBinding?: boolean): boolean {\n      if (node != null && this.isObjectProperty(node)) {\n        return this.isAssignable(node.value, isBinding);\n      }\n      return super.isAssignable(node, isBinding);\n    }\n\n    toAssignable(node: N.Node, isLHS: boolean = false): void {\n      if (node != null && this.isObjectProperty(node)) {\n        const { key, value } = node;\n        if (this.isPrivateName(key)) {\n          this.classScope.usePrivateName(\n            this.getPrivateNameSV(key),\n            key.loc.start,\n          );\n        }\n        this.toAssignable(value, isLHS);\n      } else {\n        super.toAssignable(node, isLHS);\n      }\n    }\n\n    toAssignableObjectExpressionProp(\n      prop: N.Node,\n      isLast: boolean,\n      isLHS: boolean,\n    ) {\n      if (\n        prop.type === \"Property\" &&\n        (prop.kind === \"get\" || prop.kind === \"set\")\n      ) {\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\n    finishCallExpression<T extends N.CallExpression | N.OptionalCallExpression>(\n      unfinished: Undone<T>,\n      optional: boolean,\n    ): T {\n      const node = super.finishCallExpression(unfinished, optional);\n\n      if (node.callee.type === \"Import\") {\n        (node as N.Node as N.EstreeImportExpression).type = \"ImportExpression\";\n        (node as N.Node as N.EstreeImportExpression).source = node\n          .arguments[0] as N.Expression;\n        (node as N.Node as N.EstreeImportExpression).options =\n          (node.arguments[1] as N.Expression) ?? null;\n        // compatibility with previous ESTree AST\n        // TODO(Babel 8): Remove this\n        (node as N.Node as N.EstreeImportExpression).attributes =\n          (node.arguments[1] as N.Expression) ?? null;\n        // arguments isn't optional in the type definition\n        delete node.arguments;\n        // callee isn't optional in the type definition\n        delete node.callee;\n      }\n\n      return node;\n    }\n\n    toReferencedArguments(\n      node:\n        | N.CallExpression\n        | N.OptionalCallExpression\n        | N.EstreeImportExpression,\n      /* isParenthesizedExpr?: boolean, */\n    ) {\n      // ImportExpressions do not have an arguments array.\n      if (node.type === \"ImportExpression\") {\n        return;\n      }\n\n      super.toReferencedArguments(node);\n    }\n\n    parseExport(\n      unfinished: Undone<N.AnyExport>,\n      decorators: N.Decorator[] | null,\n    ) {\n      const exportStartLoc = this.state.lastTokStartLoc;\n      const node = super.parseExport(unfinished, decorators);\n\n      switch (node.type) {\n        case \"ExportAllDeclaration\":\n          // @ts-expect-error mutating AST types\n          node.exported = null;\n          break;\n\n        case \"ExportNamedDeclaration\":\n          if (\n            node.specifiers.length === 1 &&\n            node.specifiers[0].type === \"ExportNamespaceSpecifier\"\n          ) {\n            // @ts-expect-error mutating AST types\n            node.type = \"ExportAllDeclaration\";\n            // @ts-expect-error mutating AST types\n            node.exported = node.specifiers[0].exported;\n            delete node.specifiers;\n          }\n\n        // fallthrough\n        case \"ExportDefaultDeclaration\":\n          {\n            const { declaration } = node;\n            if (\n              declaration?.type === \"ClassDeclaration\" &&\n              declaration.decorators?.length > 0 &&\n              // decorator comes before export\n              declaration.start === node.start\n            ) {\n              this.resetStartLocation(\n                node,\n                // For compatibility with ESLint's keyword-spacing rule, which assumes that an\n                // export declaration must start with export.\n                // https://github.com/babel/babel/issues/15085\n                // Here we reset export declaration's start to be the start of the export token\n                exportStartLoc,\n              );\n            }\n          }\n\n          break;\n      }\n\n      return node;\n    }\n\n    parseSubscript(\n      base: N.Expression,\n      startLoc: Position,\n      noCalls: boolean | undefined | null,\n      state: N.ParseSubscriptState,\n    ): N.Expression {\n      const node = super.parseSubscript(base, startLoc, noCalls, state);\n\n      if (state.optionalChainMember) {\n        // https://github.com/estree/estree/blob/master/es2020.md#chainexpression\n        if (\n          node.type === \"OptionalMemberExpression\" ||\n          node.type === \"OptionalCallExpression\"\n        ) {\n          // strip Optional prefix\n          (node as unknown as N.CallExpression | N.MemberExpression).type =\n            node.type.substring(8) as \"CallExpression\" | \"MemberExpression\";\n        }\n        if (state.stop) {\n          const chain = this.startNodeAtNode<N.EstreeChainExpression>(node);\n          chain.expression = node;\n          return this.finishNode(chain, \"ChainExpression\");\n        }\n      } else if (\n        node.type === \"MemberExpression\" ||\n        node.type === \"CallExpression\"\n      ) {\n        // @ts-expect-error not in the type definitions\n        node.optional = false;\n      }\n\n      return node;\n    }\n\n    isOptionalMemberExpression(node: N.Node) {\n      if (node.type === \"ChainExpression\") {\n        return node.expression.type === \"MemberExpression\";\n      }\n      return super.isOptionalMemberExpression(node);\n    }\n\n    hasPropertyAsPrivateName(node: N.Node): boolean {\n      if (node.type === \"ChainExpression\") {\n        node = node.expression;\n      }\n      return super.hasPropertyAsPrivateName(node);\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    isObjectProperty(node: N.Node): node is N.EstreeProperty {\n      return node.type === \"Property\" && node.kind === \"init\" && !node.method;\n    }\n\n    // @ts-expect-error ESTree plugin changes node types\n    isObjectMethod(node: N.Node): node is N.EstreeProperty {\n      return (\n        node.type === \"Property\" &&\n        (node.method || node.kind === \"get\" || node.kind === \"set\")\n      );\n    }\n\n    finishNodeAt<T extends NodeType>(\n      node: Undone<T>,\n      type: T[\"type\"],\n      endLoc: Position,\n    ): T {\n      return toESTreeLocation(super.finishNodeAt(node, type, endLoc));\n    }\n\n    resetStartLocation(node: N.Node, startLoc: Position) {\n      super.resetStartLocation(node, startLoc);\n      toESTreeLocation(node);\n    }\n\n    resetEndLocation(\n      node: NodeBase,\n      endLoc: Position = this.state.lastTokEndLoc,\n    ): void {\n      super.resetEndLocation(node, endLoc);\n      toESTreeLocation(node);\n    }\n  };\n","// The token context is used in JSX plugin to track\n// jsx tag / jsx text / normal JavaScript expression\n\nexport class TokContext {\n  constructor(token: string, preserveSpace?: boolean) {\n    this.token = token;\n    this.preserveSpace = !!preserveSpace;\n  }\n\n  token: string;\n  preserveSpace: boolean;\n}\n\nconst types: {\n  [key: string]: TokContext;\n} = {\n  brace: new TokContext(\"{\"), // normal JavaScript expression\n  j_oTag: new TokContext(\"<tag\"), // JSX opening tag\n  j_cTag: new TokContext(\"</tag\"), // JSX closing tag\n  j_expr: new TokContext(\"<tag>...</tag>\", true), // JSX expressions\n};\n\nif (!process.env.BABEL_8_BREAKING) {\n  types.template = new TokContext(\"`\", true);\n}\n\nexport { types };\n","import { types as tc, type TokContext } from \"./context.ts\";\n// ## Token types\n\n// The assignment of fine-grained, information-carrying type objects\n// allows the tokenizer to store the information it has about a\n// token in a way that is very cheap for the parser to look up.\n\n// All token type variables start with an underscore, to make them\n// easy to recognize.\n\n// The `beforeExpr` property is used to disambiguate between 1) binary\n// expression (<) and JSX Tag start (<name>); 2) object literal and JSX\n// texts. It is set on the `updateContext` function in the JSX plugin.\n\n// The `startsExpr` property is used to determine whether an expression\n// may be the “argument” subexpression of a `yield` expression or\n// `yield` statement. It is set on all token types that may be at the\n// start of a subexpression.\n\n// `isLoop` marks a keyword as starting a loop, which is important\n// to know when parsing a label, in order to allow or disallow\n// continue jumps to that label.\n\nconst beforeExpr = true;\nconst startsExpr = true;\nconst isLoop = true;\nconst isAssign = true;\nconst prefix = true;\nconst postfix = true;\n\ntype TokenOptions = {\n  keyword?: string;\n  beforeExpr?: boolean;\n  startsExpr?: boolean;\n  rightAssociative?: boolean;\n  isLoop?: boolean;\n  isAssign?: boolean;\n  prefix?: boolean;\n  postfix?: boolean;\n  binop?: number | null;\n};\n\n// Internally the tokenizer stores token as a number\nexport type TokenType = number;\n\n// The `ExportedTokenType` is exported via `tokTypes` and accessible\n// when `tokens: true` is enabled. Unlike internal token type, it provides\n// metadata of the tokens.\nexport class ExportedTokenType {\n  label: string;\n  keyword: string | undefined | null;\n  beforeExpr: boolean;\n  startsExpr: boolean;\n  rightAssociative: boolean;\n  isLoop: boolean;\n  isAssign: boolean;\n  prefix: boolean;\n  postfix: boolean;\n  binop: number | undefined | null;\n  // todo(Babel 8): remove updateContext from exposed token layout\n  declare updateContext:\n    | ((context: Array<TokContext>) => void)\n    | undefined\n    | null;\n\n  constructor(label: string, conf: TokenOptions = {}) {\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    if (!process.env.BABEL_8_BREAKING) {\n      this.updateContext = null;\n    }\n  }\n}\n\n// A map from keyword/keyword-like string value to the token type\nexport const keywords = new Map<string, TokenType>();\n\nfunction createKeyword(name: string, options: TokenOptions = {}): TokenType {\n  options.keyword = name;\n  const token = createToken(name, options);\n  keywords.set(name, token);\n  return token;\n}\n\nfunction createBinop(name: string, binop: number) {\n  return createToken(name, { beforeExpr, binop });\n}\n\nlet tokenTypeCounter = -1;\nexport const tokenTypes: ExportedTokenType[] = [];\nconst tokenLabels: string[] = [];\nconst tokenBinops: number[] = [];\nconst tokenBeforeExprs: boolean[] = [];\nconst tokenStartsExprs: boolean[] = [];\nconst tokenPrefixes: boolean[] = [];\n\nfunction createToken(name: string, options: TokenOptions = {}): TokenType {\n  ++tokenTypeCounter;\n  tokenLabels.push(name);\n  tokenBinops.push(options.binop ?? -1);\n  tokenBeforeExprs.push(options.beforeExpr ?? false);\n  tokenStartsExprs.push(options.startsExpr ?? false);\n  tokenPrefixes.push(options.prefix ?? false);\n  tokenTypes.push(new ExportedTokenType(name, options));\n\n  return tokenTypeCounter;\n}\n\nfunction createKeywordLike(\n  name: string,\n  options: TokenOptions = {},\n): TokenType {\n  ++tokenTypeCounter;\n  keywords.set(name, tokenTypeCounter);\n  tokenLabels.push(name);\n  tokenBinops.push(options.binop ?? -1);\n  tokenBeforeExprs.push(options.beforeExpr ?? false);\n  tokenStartsExprs.push(options.startsExpr ?? false);\n  tokenPrefixes.push(options.prefix ?? false);\n  // In the exported token type, we set the label as \"name\" for backward compatibility with Babel 7\n  tokenTypes.push(new ExportedTokenType(\"name\", options));\n\n  return tokenTypeCounter;\n}\n\n// For performance the token type helpers depend on the following declarations order.\n// When adding new token types, please also check if the token helpers need update.\n\nexport type InternalTokenTypes = typeof tt;\n\nexport const tt = {\n  // Punctuation token types.\n  bracketL: createToken(\"[\", { beforeExpr, startsExpr }),\n  bracketHashL: createToken(\"#[\", { beforeExpr, startsExpr }),\n  bracketBarL: createToken(\"[|\", { beforeExpr, startsExpr }),\n  bracketR: createToken(\"]\"),\n  bracketBarR: createToken(\"|]\"),\n  braceL: createToken(\"{\", { beforeExpr, startsExpr }),\n  braceBarL: createToken(\"{|\", { beforeExpr, startsExpr }),\n  braceHashL: createToken(\"#{\", { beforeExpr, startsExpr }),\n  braceR: createToken(\"}\"),\n  braceBarR: createToken(\"|}\"),\n  parenL: createToken(\"(\", { beforeExpr, startsExpr }),\n  parenR: createToken(\")\"),\n  comma: createToken(\",\", { beforeExpr }),\n  semi: createToken(\";\", { beforeExpr }),\n  colon: createToken(\":\", { beforeExpr }),\n  doubleColon: createToken(\"::\", { beforeExpr }),\n  dot: createToken(\".\"),\n  question: createToken(\"?\", { beforeExpr }),\n  questionDot: createToken(\"?.\"),\n  arrow: createToken(\"=>\", { beforeExpr }),\n  template: createToken(\"template\"),\n  ellipsis: createToken(\"...\", { beforeExpr }),\n  backQuote: createToken(\"`\", { startsExpr }),\n  dollarBraceL: createToken(\"${\", { beforeExpr, startsExpr }),\n  // start: isTemplate\n  templateTail: createToken(\"...`\", { startsExpr }),\n  templateNonTail: createToken(\"...${\", { beforeExpr, startsExpr }),\n  // end: isTemplate\n  at: createToken(\"@\"),\n  hash: createToken(\"#\", { startsExpr }),\n\n  // Special hashbang token.\n  interpreterDirective: createToken(\"#!...\"),\n\n  // Operators. These carry several kinds of properties to help the\n  // parser use them properly (the presence of these properties is\n  // what categorizes them as operators).\n  //\n  // `binop`, when present, specifies that this operator is a binary\n  // operator, and will refer to its precedence.\n  //\n  // `prefix` and `postfix` mark the operator as a prefix or postfix\n  // unary operator.\n  //\n  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as\n  // binary operators with a very low precedence, that should result\n  // in AssignmentExpression nodes.\n\n  // start: isAssign\n  eq: createToken(\"=\", { beforeExpr, isAssign }),\n  assign: createToken(\"_=\", { beforeExpr, isAssign }),\n  slashAssign: createToken(\"_=\", { beforeExpr, isAssign }),\n  // These are only needed to support % and ^ as a Hack-pipe topic token.\n  // When the proposal settles on a token, the others can be merged with\n  // tt.assign.\n  xorAssign: createToken(\"_=\", { beforeExpr, isAssign }),\n  moduloAssign: createToken(\"_=\", { beforeExpr, isAssign }),\n  // end: isAssign\n\n  incDec: createToken(\"++/--\", { prefix, postfix, startsExpr }),\n  bang: createToken(\"!\", { beforeExpr, prefix, startsExpr }),\n  tilde: createToken(\"~\", { beforeExpr, prefix, startsExpr }),\n\n  // More possible topic tokens.\n  // When the proposal settles on a token, at least one of these may be removed.\n  doubleCaret: createToken(\"^^\", { startsExpr }),\n  doubleAt: createToken(\"@@\", { startsExpr }),\n\n  // start: isBinop\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(\"+/-\", { beforeExpr, binop: 9, prefix, startsExpr }),\n  // startsExpr: required by v8intrinsic plugin\n  modulo: createToken(\"%\", { binop: 10, startsExpr }),\n  // unset `beforeExpr` as it can be `function *`\n  star: createToken(\"*\", { binop: 10 }),\n  slash: createBinop(\"/\", 10),\n  exponent: createToken(\"**\", {\n    beforeExpr,\n    binop: 11,\n    rightAssociative: true,\n  }),\n\n  // Keywords\n  // Don't forget to update packages/babel-helper-validator-identifier/src/keyword.js\n  // when new keywords are added\n  // start: isLiteralPropertyName\n  // start: isKeyword\n  _in: createKeyword(\"in\", { beforeExpr, binop: 7 }),\n  _instanceof: createKeyword(\"instanceof\", { beforeExpr, binop: 7 }),\n  // end: isBinop\n  _break: createKeyword(\"break\"),\n  _case: createKeyword(\"case\", { beforeExpr }),\n  _catch: createKeyword(\"catch\"),\n  _continue: createKeyword(\"continue\"),\n  _debugger: createKeyword(\"debugger\"),\n  _default: createKeyword(\"default\", { beforeExpr }),\n  _else: createKeyword(\"else\", { beforeExpr }),\n  _finally: createKeyword(\"finally\"),\n  _function: createKeyword(\"function\", { startsExpr }),\n  _if: createKeyword(\"if\"),\n  _return: createKeyword(\"return\", { beforeExpr }),\n  _switch: createKeyword(\"switch\"),\n  _throw: createKeyword(\"throw\", { beforeExpr, prefix, startsExpr }),\n  _try: createKeyword(\"try\"),\n  _var: createKeyword(\"var\"),\n  _const: createKeyword(\"const\"),\n  _with: createKeyword(\"with\"),\n  _new: createKeyword(\"new\", { beforeExpr, startsExpr }),\n  _this: createKeyword(\"this\", { startsExpr }),\n  _super: createKeyword(\"super\", { startsExpr }),\n  _class: createKeyword(\"class\", { startsExpr }),\n  _extends: createKeyword(\"extends\", { beforeExpr }),\n  _export: createKeyword(\"export\"),\n  _import: createKeyword(\"import\", { startsExpr }),\n  _null: createKeyword(\"null\", { startsExpr }),\n  _true: createKeyword(\"true\", { startsExpr }),\n  _false: createKeyword(\"false\", { startsExpr }),\n  _typeof: createKeyword(\"typeof\", { beforeExpr, prefix, startsExpr }),\n  _void: createKeyword(\"void\", { beforeExpr, prefix, startsExpr }),\n  _delete: createKeyword(\"delete\", { beforeExpr, prefix, startsExpr }),\n  // start: isLoop\n  _do: createKeyword(\"do\", { isLoop, beforeExpr }),\n  _for: createKeyword(\"for\", { isLoop }),\n  _while: createKeyword(\"while\", { isLoop }),\n  // end: isLoop\n  // end: isKeyword\n\n  // Primary literals\n  // start: isIdentifier\n  _as: createKeywordLike(\"as\", { startsExpr }),\n  _assert: createKeywordLike(\"assert\", { startsExpr }),\n  _async: createKeywordLike(\"async\", { startsExpr }),\n  _await: createKeywordLike(\"await\", { startsExpr }),\n  _defer: createKeywordLike(\"defer\", { startsExpr }),\n  _from: createKeywordLike(\"from\", { startsExpr }),\n  _get: createKeywordLike(\"get\", { startsExpr }),\n  _let: createKeywordLike(\"let\", { startsExpr }),\n  _meta: createKeywordLike(\"meta\", { startsExpr }),\n  _of: createKeywordLike(\"of\", { startsExpr }),\n  _sent: createKeywordLike(\"sent\", { startsExpr }),\n  _set: createKeywordLike(\"set\", { startsExpr }),\n  _source: createKeywordLike(\"source\", { startsExpr }),\n  _static: createKeywordLike(\"static\", { startsExpr }),\n  _using: createKeywordLike(\"using\", { startsExpr }),\n  _yield: createKeywordLike(\"yield\", { startsExpr }),\n\n  // Flow and TypeScript Keywordlike\n  _asserts: createKeywordLike(\"asserts\", { startsExpr }),\n  _checks: createKeywordLike(\"checks\", { startsExpr }),\n  _exports: createKeywordLike(\"exports\", { startsExpr }),\n  _global: createKeywordLike(\"global\", { startsExpr }),\n  _implements: createKeywordLike(\"implements\", { startsExpr }),\n  _intrinsic: createKeywordLike(\"intrinsic\", { startsExpr }),\n  _infer: createKeywordLike(\"infer\", { startsExpr }),\n  _is: createKeywordLike(\"is\", { startsExpr }),\n  _mixins: createKeywordLike(\"mixins\", { startsExpr }),\n  _proto: createKeywordLike(\"proto\", { startsExpr }),\n  _require: createKeywordLike(\"require\", { startsExpr }),\n  _satisfies: createKeywordLike(\"satisfies\", { startsExpr }),\n  // start: isTSTypeOperator\n  _keyof: createKeywordLike(\"keyof\", { startsExpr }),\n  _readonly: createKeywordLike(\"readonly\", { startsExpr }),\n  _unique: createKeywordLike(\"unique\", { startsExpr }),\n  // end: isTSTypeOperator\n  // start: isTSDeclarationStart\n  _abstract: createKeywordLike(\"abstract\", { startsExpr }),\n  _declare: createKeywordLike(\"declare\", { startsExpr }),\n  _enum: createKeywordLike(\"enum\", { startsExpr }),\n  _module: createKeywordLike(\"module\", { startsExpr }),\n  _namespace: createKeywordLike(\"namespace\", { startsExpr }),\n  // start: isFlowInterfaceOrTypeOrOpaque\n  _interface: createKeywordLike(\"interface\", { startsExpr }),\n  _type: createKeywordLike(\"type\", { startsExpr }),\n  // end: isTSDeclarationStart\n  _opaque: createKeywordLike(\"opaque\", { startsExpr }),\n  // end: isFlowInterfaceOrTypeOrOpaque\n  name: createToken(\"name\", { startsExpr }),\n\n  // placeholder plugin\n  placeholder: createToken(\"%%\", { startsExpr: true }),\n  // end: isIdentifier\n\n  string: createToken(\"string\", { startsExpr }),\n  num: createToken(\"num\", { startsExpr }),\n  bigint: createToken(\"bigint\", { startsExpr }),\n  // TODO: Remove this in Babel 8\n  decimal: createToken(\"decimal\", { startsExpr }),\n  // end: isLiteralPropertyName\n  regexp: createToken(\"regexp\", { startsExpr }),\n  privateName: createToken(\"#name\", { startsExpr }),\n  eof: createToken(\"eof\"),\n\n  // jsx plugin\n  jsxName: createToken(\"jsxName\"),\n  jsxText: createToken(\"jsxText\", { beforeExpr: true }),\n  jsxTagStart: createToken(\"jsxTagStart\", { startsExpr: true }),\n  jsxTagEnd: createToken(\"jsxTagEnd\"),\n} as const;\n\nexport function tokenIsIdentifier(token: TokenType): boolean {\n  return token >= tt._as && token <= tt.placeholder;\n}\n\nexport function tokenKeywordOrIdentifierIsKeyword(token: TokenType): boolean {\n  // we can remove the token >= tt._in check when we\n  // know a token is either keyword or identifier\n  return token <= tt._while;\n}\n\nexport function tokenIsKeywordOrIdentifier(token: TokenType): boolean {\n  return token >= tt._in && token <= tt.placeholder;\n}\n\nexport function tokenIsLiteralPropertyName(token: TokenType): boolean {\n  return token >= tt._in && token <= tt.decimal;\n}\n\nexport function tokenComesBeforeExpression(token: TokenType): boolean {\n  return tokenBeforeExprs[token];\n}\n\nexport function tokenCanStartExpression(token: TokenType): boolean {\n  return tokenStartsExprs[token];\n}\n\nexport function tokenIsAssignment(token: TokenType): boolean {\n  return token >= tt.eq && token <= tt.moduloAssign;\n}\n\nexport function tokenIsFlowInterfaceOrTypeOrOpaque(token: TokenType): boolean {\n  return token >= tt._interface && token <= tt._opaque;\n}\n\nexport function tokenIsLoop(token: TokenType): boolean {\n  return token >= tt._do && token <= tt._while;\n}\n\nexport function tokenIsKeyword(token: TokenType): boolean {\n  return token >= tt._in && token <= tt._while;\n}\n\nexport function tokenIsOperator(token: TokenType): boolean {\n  return token >= tt.pipeline && token <= tt._instanceof;\n}\n\nexport function tokenIsPostfix(token: TokenType): boolean {\n  return token === tt.incDec;\n}\n\nexport function tokenIsPrefix(token: TokenType): boolean {\n  return tokenPrefixes[token];\n}\n\nexport function tokenIsTSTypeOperator(token: TokenType): boolean {\n  return token >= tt._keyof && token <= tt._unique;\n}\n\nexport function tokenIsTSDeclarationStart(token: TokenType): boolean {\n  return token >= tt._abstract && token <= tt._type;\n}\n\nexport function tokenLabelName(token: TokenType): string {\n  return tokenLabels[token];\n}\n\nexport function tokenOperatorPrecedence(token: TokenType): number {\n  return tokenBinops[token];\n}\n\nexport function tokenIsBinaryOperator(token: TokenType): boolean {\n  return tokenBinops[token] !== -1;\n}\n\nexport function tokenIsRightAssociative(token: TokenType): boolean {\n  return token === tt.exponent;\n}\n\nexport function tokenIsTemplate(token: TokenType): boolean {\n  return token >= tt.templateTail && token <= tt.templateNonTail;\n}\n\nexport function getExportedToken(token: TokenType): ExportedTokenType {\n  return tokenTypes[token];\n}\n\nexport function isTokenType(obj: any): boolean {\n  return typeof obj === \"number\";\n}\n\nif (!process.env.BABEL_8_BREAKING) {\n  tokenTypes[tt.braceR].updateContext = context => {\n    context.pop();\n  };\n\n  tokenTypes[tt.braceL].updateContext =\n    tokenTypes[tt.braceHashL].updateContext =\n    tokenTypes[tt.dollarBraceL].updateContext =\n      context => {\n        context.push(tc.brace);\n      };\n\n  tokenTypes[tt.backQuote].updateContext = context => {\n    if (context[context.length - 1] === tc.template) {\n      context.pop();\n    } else {\n      context.push(tc.template);\n    }\n  };\n\n  tokenTypes[tt.jsxTagStart].updateContext = context => {\n    context.push(tc.j_expr, tc.j_oTag);\n  };\n}\n","// We inline this package\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as charCodes from \"charcodes\";\n\n// ## Character categories\n\n// Big ugly regular expressions that match characters in the\n// whitespace, identifier, and identifier-start categories. These\n// are only applied when a character is found to actually have a\n// code point between 0x80 and 0xffff.\n// Generated by `scripts/generate-identifier-regex.cjs`.\n\n/* prettier-ignore */\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-\\u1c8a\\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-\\ua7cd\\ua7d0\\ua7d1\\ua7d3\\ua7d5-\\ua7dc\\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\";\n/* prettier-ignore */\nlet nonASCIIidentifierChars = \"\\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\\u0897-\\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\";\n\nconst nonASCIIidentifierStart = new RegExp(\n  \"[\" + nonASCIIidentifierStartChars + \"]\",\n);\nconst nonASCIIidentifier = new RegExp(\n  \"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\",\n);\n\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null;\n\n// These are a run-length and offset-encoded representation of the\n// >0xffff code points that are a valid part of identifiers. The\n// offset starts at 0x10000, and each pair of numbers represents an\n// offset to the next range, and then a size of the range. They were\n// generated by `scripts/generate-identifier-regex.cjs`.\n/* prettier-ignore */\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,4,51,13,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,39,27,10,22,251,41,7,1,17,2,60,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,31,9,2,0,3,0,2,37,2,0,26,0,2,0,45,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,200,32,32,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,26,3994,6,582,6842,29,1763,568,8,30,18,78,18,29,19,47,17,3,32,20,6,18,433,44,212,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,1237,42,9,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,229,29,3,0,496,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];\n/* prettier-ignore */\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,7,9,32,4,318,1,80,3,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,68,8,2,0,3,0,2,3,2,4,2,0,15,1,83,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,7,19,58,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,343,9,54,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,10,5350,0,7,14,11465,27,2343,9,87,9,39,4,60,6,26,9,535,9,470,0,2,54,8,3,82,0,12,1,19628,1,4178,9,519,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,245,1,2,9,726,6,110,6,6,9,4759,9,787719,239];\n\n// This has a complexity linear to the value of the code. The\n// assumption is that looking up astral identifier characters is\n// rare.\nfunction isInAstralSet(code: number, set: readonly number[]): boolean {\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\n    pos += set[i + 1];\n    if (pos >= code) return true;\n  }\n  return false;\n}\n\n// Test whether a given character code starts an identifier.\n\nexport function isIdentifierStart(code: number): boolean {\n  if (code < charCodes.uppercaseA) return code === charCodes.dollarSign;\n  if (code <= charCodes.uppercaseZ) return true;\n  if (code < charCodes.lowercaseA) return code === charCodes.underscore;\n  if (code <= charCodes.lowercaseZ) return true;\n  if (code <= 0xffff) {\n    return (\n      code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code))\n    );\n  }\n  return isInAstralSet(code, astralIdentifierStartCodes);\n}\n\n// Test whether a given character is part of an identifier.\n\nexport function isIdentifierChar(code: number): boolean {\n  if (code < charCodes.digit0) return code === charCodes.dollarSign;\n  if (code < charCodes.colon) return true;\n  if (code < charCodes.uppercaseA) return false;\n  if (code <= charCodes.uppercaseZ) return true;\n  if (code < charCodes.lowercaseA) return code === charCodes.underscore;\n  if (code <= charCodes.lowercaseZ) return true;\n  if (code <= 0xffff) {\n    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));\n  }\n  return (\n    isInAstralSet(code, astralIdentifierStartCodes) ||\n    isInAstralSet(code, astralIdentifierCodes)\n  );\n}\n\n// Test whether a given string is a valid identifier name\n\nexport function isIdentifierName(name: string): boolean {\n  let isFirst = true;\n  for (let i = 0; i < name.length; i++) {\n    // The implementation is based on\n    // https://source.chromium.org/chromium/chromium/src/+/master:v8/src/builtins/builtins-string-gen.cc;l=1455;drc=221e331b49dfefadbc6fa40b0c68e6f97606d0b3;bpv=0;bpt=1\n    // We reimplement `codePointAt` because `codePointAt` is a V8 builtin which is not inlined by TurboFan (as of M91)\n    // since `name` is mostly ASCII, an inlined `charCodeAt` wins here\n    let cp = name.charCodeAt(i);\n    if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {\n      const trail = name.charCodeAt(++i);\n      if ((trail & 0xfc00) === 0xdc00) {\n        cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);\n      }\n    }\n    if (isFirst) {\n      isFirst = false;\n      if (!isIdentifierStart(cp)) {\n        return false;\n      }\n    } else if (!isIdentifierChar(cp)) {\n      return false;\n    }\n  }\n  return !isFirst;\n}\n","const reservedWords = {\n  keyword: [\n    \"break\",\n    \"case\",\n    \"catch\",\n    \"continue\",\n    \"debugger\",\n    \"default\",\n    \"do\",\n    \"else\",\n    \"finally\",\n    \"for\",\n    \"function\",\n    \"if\",\n    \"return\",\n    \"switch\",\n    \"throw\",\n    \"try\",\n    \"var\",\n    \"const\",\n    \"while\",\n    \"with\",\n    \"new\",\n    \"this\",\n    \"super\",\n    \"class\",\n    \"extends\",\n    \"export\",\n    \"import\",\n    \"null\",\n    \"true\",\n    \"false\",\n    \"in\",\n    \"instanceof\",\n    \"typeof\",\n    \"void\",\n    \"delete\",\n  ],\n  strict: [\n    \"implements\",\n    \"interface\",\n    \"let\",\n    \"package\",\n    \"private\",\n    \"protected\",\n    \"public\",\n    \"static\",\n    \"yield\",\n  ],\n  strictBind: [\"eval\", \"arguments\"],\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\n\n/**\n * Checks if word is a reserved word in non-strict mode\n */\nexport function isReservedWord(word: string, inModule: boolean): boolean {\n  return (inModule && word === \"await\") || word === \"enum\";\n}\n\n/**\n * Checks if word is a reserved word in non-binding strict mode\n *\n * Includes non-strict reserved words\n */\nexport function isStrictReservedWord(word: string, inModule: boolean): boolean {\n  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode, but it is allowed as\n * a normal identifier.\n */\nexport function isStrictBindOnlyReservedWord(word: string): boolean {\n  return reservedWordsStrictBindSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode\n *\n * Includes non-strict reserved words and non-binding strict reserved words\n */\nexport function isStrictBindReservedWord(\n  word: string,\n  inModule: boolean,\n): boolean {\n  return (\n    isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word)\n  );\n}\n\nexport function isKeyword(word: string): boolean {\n  return keywords.has(word);\n}\n","import * as charCodes from \"charcodes\";\nimport { isIdentifierStart } from \"@babel/helper-validator-identifier\";\n\nexport {\n  isIdentifierStart,\n  isIdentifierChar,\n  isReservedWord,\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n  isStrictReservedWord,\n  isKeyword,\n} from \"@babel/helper-validator-identifier\";\n\nexport const keywordRelationalOperator = /^in(stanceof)?$/;\n\n// Test whether a current state character code and next character code is @\n\nexport function isIteratorStart(\n  current: number,\n  next: number,\n  next2: number,\n): boolean {\n  return (\n    current === charCodes.atSign &&\n    next === charCodes.atSign &&\n    isIdentifierStart(next2)\n  );\n}\n\n// This is the comprehensive set of JavaScript reserved words\n// If a word is in this set, it could be a reserved word,\n// depending on sourceType/strictMode/binding info. In other words\n// if a word is not in this set, it is not a reserved word under\n// any circumstance.\nconst reservedWordLikeSet = new Set([\n  \"break\",\n  \"case\",\n  \"catch\",\n  \"continue\",\n  \"debugger\",\n  \"default\",\n  \"do\",\n  \"else\",\n  \"finally\",\n  \"for\",\n  \"function\",\n  \"if\",\n  \"return\",\n  \"switch\",\n  \"throw\",\n  \"try\",\n  \"var\",\n  \"const\",\n  \"while\",\n  \"with\",\n  \"new\",\n  \"this\",\n  \"super\",\n  \"class\",\n  \"extends\",\n  \"export\",\n  \"import\",\n  \"null\",\n  \"true\",\n  \"false\",\n  \"in\",\n  \"instanceof\",\n  \"typeof\",\n  \"void\",\n  \"delete\",\n  // strict\n  \"implements\",\n  \"interface\",\n  \"let\",\n  \"package\",\n  \"private\",\n  \"protected\",\n  \"public\",\n  \"static\",\n  \"yield\",\n  // strictBind\n  \"eval\",\n  \"arguments\",\n  // reservedWorkLike\n  \"enum\",\n  \"await\",\n]);\n\nexport function canBeReservedWord(word: string): boolean {\n  return reservedWordLikeSet.has(word);\n}\n","import { ScopeFlag, BindingFlag } from \"./scopeflags.ts\";\nimport type { Position } from \"./location.ts\";\nimport type * as N from \"../types.ts\";\nimport { Errors } from \"../parse-error.ts\";\nimport type Tokenizer from \"../tokenizer/index.ts\";\n\nexport const enum NameType {\n  // var-declared names in the current lexical scope\n  Var = 1 << 0,\n  // lexically-declared names in the current lexical scope\n  Lexical = 1 << 1,\n  // lexically-declared FunctionDeclaration names in the current lexical scope\n  Function = 1 << 2,\n}\n\n// Start an AST node, attaching a start offset.\nexport class Scope {\n  flags: ScopeFlag = 0;\n  names: Map<string, NameType> = new Map();\n  firstLexicalName = \"\";\n\n  constructor(flags: ScopeFlag) {\n    this.flags = flags;\n  }\n}\n\n// The functions in this module keep track of declared variables in the\n// current scope in order to detect duplicate variable names.\nexport default class ScopeHandler<IScope extends Scope = Scope> {\n  parser: Tokenizer;\n  scopeStack: Array<IScope> = [];\n  inModule: boolean;\n  undefinedExports: Map<string, Position> = new Map();\n\n  constructor(parser: Tokenizer, inModule: boolean) {\n    this.parser = parser;\n    this.inModule = inModule;\n  }\n\n  get inTopLevel() {\n    return (this.currentScope().flags & ScopeFlag.PROGRAM) > 0;\n  }\n  get inFunction() {\n    return (this.currentVarScopeFlags() & ScopeFlag.FUNCTION) > 0;\n  }\n  get allowSuper() {\n    return (this.currentThisScopeFlags() & ScopeFlag.SUPER) > 0;\n  }\n  get allowDirectSuper() {\n    return (this.currentThisScopeFlags() & ScopeFlag.DIRECT_SUPER) > 0;\n  }\n  get inClass() {\n    return (this.currentThisScopeFlags() & ScopeFlag.CLASS) > 0;\n  }\n  get inClassAndNotInNonArrowFunction() {\n    const flags = this.currentThisScopeFlags();\n    return (flags & ScopeFlag.CLASS) > 0 && (flags & ScopeFlag.FUNCTION) === 0;\n  }\n  get inStaticBlock() {\n    for (let i = this.scopeStack.length - 1; ; i--) {\n      const { flags } = this.scopeStack[i];\n      if (flags & ScopeFlag.STATIC_BLOCK) {\n        return true;\n      }\n      if (flags & (ScopeFlag.VAR | ScopeFlag.CLASS)) {\n        // function body, module body, class property initializers\n        return false;\n      }\n    }\n  }\n  get inNonArrowFunction() {\n    return (this.currentThisScopeFlags() & ScopeFlag.FUNCTION) > 0;\n  }\n  get treatFunctionsAsVar() {\n    return this.treatFunctionsAsVarInScope(this.currentScope());\n  }\n\n  createScope(flags: ScopeFlag): Scope {\n    return new Scope(flags);\n  }\n\n  enter(flags: ScopeFlag) {\n    /*:: +createScope: (flags:ScopeFlag) => IScope; */\n    // @ts-expect-error This method will be overwritten by subclasses\n    this.scopeStack.push(this.createScope(flags));\n  }\n\n  exit(): ScopeFlag {\n    const scope = this.scopeStack.pop();\n    return scope.flags;\n  }\n\n  // The spec says:\n  // > At the top level of a function, or script, function declarations are\n  // > treated like var declarations rather than like lexical declarations.\n  treatFunctionsAsVarInScope(scope: IScope): boolean {\n    return !!(\n      scope.flags & (ScopeFlag.FUNCTION | ScopeFlag.STATIC_BLOCK) ||\n      (!this.parser.inModule && scope.flags & ScopeFlag.PROGRAM)\n    );\n  }\n\n  declareName(name: string, bindingType: BindingFlag, loc: Position) {\n    let scope = this.currentScope();\n    if (\n      bindingType & BindingFlag.SCOPE_LEXICAL ||\n      bindingType & BindingFlag.SCOPE_FUNCTION\n    ) {\n      this.checkRedeclarationInScope(scope, name, bindingType, loc);\n\n      let type = scope.names.get(name) || 0;\n\n      if (bindingType & BindingFlag.SCOPE_FUNCTION) {\n        type = type | NameType.Function;\n      } else {\n        if (!scope.firstLexicalName) {\n          scope.firstLexicalName = name;\n        }\n        type = type | NameType.Lexical;\n      }\n\n      scope.names.set(name, type);\n\n      if (bindingType & BindingFlag.SCOPE_LEXICAL) {\n        this.maybeExportDefined(scope, name);\n      }\n    } else if (bindingType & BindingFlag.SCOPE_VAR) {\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) | NameType.Var);\n        this.maybeExportDefined(scope, name);\n\n        if (scope.flags & ScopeFlag.VAR) break;\n      }\n    }\n    if (this.parser.inModule && scope.flags & ScopeFlag.PROGRAM) {\n      this.undefinedExports.delete(name);\n    }\n  }\n\n  maybeExportDefined(scope: IScope, name: string) {\n    if (this.parser.inModule && scope.flags & ScopeFlag.PROGRAM) {\n      this.undefinedExports.delete(name);\n    }\n  }\n\n  checkRedeclarationInScope(\n    scope: IScope,\n    name: string,\n    bindingType: BindingFlag,\n    loc: Position,\n  ) {\n    if (this.isRedeclaredInScope(scope, name, bindingType)) {\n      this.parser.raise(Errors.VarRedeclaration, loc, {\n        identifierName: name,\n      });\n    }\n  }\n\n  isRedeclaredInScope(\n    scope: IScope,\n    name: string,\n    bindingType: BindingFlag,\n  ): boolean {\n    if (!(bindingType & BindingFlag.KIND_VALUE)) return false;\n\n    if (bindingType & BindingFlag.SCOPE_LEXICAL) {\n      return scope.names.has(name);\n    }\n\n    const type = scope.names.get(name);\n\n    if (bindingType & BindingFlag.SCOPE_FUNCTION) {\n      return (\n        (type & NameType.Lexical) > 0 ||\n        (!this.treatFunctionsAsVarInScope(scope) && (type & NameType.Var) > 0)\n      );\n    }\n\n    return (\n      ((type & NameType.Lexical) > 0 &&\n        // Annex B.3.4\n        // https://tc39.es/ecma262/#sec-variablestatements-in-catch-blocks\n        !(\n          scope.flags & ScopeFlag.SIMPLE_CATCH &&\n          scope.firstLexicalName === name\n        )) ||\n      (!this.treatFunctionsAsVarInScope(scope) &&\n        (type & NameType.Function) > 0)\n    );\n  }\n\n  checkLocalExport(id: N.Identifier) {\n    const { name } = id;\n    const topLevelScope = this.scopeStack[0];\n    if (!topLevelScope.names.has(name)) {\n      this.undefinedExports.set(name, id.loc.start);\n    }\n  }\n\n  currentScope(): IScope {\n    return this.scopeStack[this.scopeStack.length - 1];\n  }\n\n  currentVarScopeFlags(): ScopeFlag {\n    for (let i = this.scopeStack.length - 1; ; i--) {\n      const { flags } = this.scopeStack[i];\n      if (flags & ScopeFlag.VAR) {\n        return flags;\n      }\n    }\n  }\n\n  // Could be useful for `arguments`, `this`, `new.target`, `super()`, `super.property`, and `super[property]`.\n  currentThisScopeFlags(): ScopeFlag {\n    for (let i = this.scopeStack.length - 1; ; i--) {\n      const { flags } = this.scopeStack[i];\n      if (\n        flags & (ScopeFlag.VAR | ScopeFlag.CLASS) &&\n        !(flags & ScopeFlag.ARROW)\n      ) {\n        return flags;\n      }\n    }\n  }\n}\n","import type { Position } from \"../../util/location.ts\";\nimport ScopeHandler, { NameType, Scope } from \"../../util/scope.ts\";\nimport { BindingFlag, type ScopeFlag } from \"../../util/scopeflags.ts\";\nimport type * as N from \"../../types.ts\";\n\n// Reference implementation: https://github.com/facebook/flow/blob/23aeb2a2ef6eb4241ce178fde5d8f17c5f747fb5/src/typing/env.ml#L536-L584\nclass FlowScope extends Scope {\n  // declare function foo(): type;\n  declareFunctions: Set<string> = new Set();\n}\n\nexport default class FlowScopeHandler extends ScopeHandler<FlowScope> {\n  createScope(flags: ScopeFlag): FlowScope {\n    return new FlowScope(flags);\n  }\n\n  declareName(name: string, bindingType: BindingFlag, loc: Position) {\n    const scope = this.currentScope();\n    if (bindingType & BindingFlag.FLAG_FLOW_DECLARE_FN) {\n      this.checkRedeclarationInScope(scope, name, bindingType, loc);\n      this.maybeExportDefined(scope, name);\n      scope.declareFunctions.add(name);\n      return;\n    }\n\n    super.declareName(name, bindingType, loc);\n  }\n\n  isRedeclaredInScope(\n    scope: FlowScope,\n    name: string,\n    bindingType: BindingFlag,\n  ): boolean {\n    if (super.isRedeclaredInScope(scope, name, bindingType)) return true;\n\n    if (\n      bindingType & BindingFlag.FLAG_FLOW_DECLARE_FN &&\n      !scope.declareFunctions.has(name)\n    ) {\n      const type = scope.names.get(name);\n      return (type & NameType.Function) > 0 || (type & NameType.Lexical) > 0;\n    }\n\n    return false;\n  }\n\n  checkLocalExport(id: N.Identifier) {\n    if (!this.scopeStack[0].declareFunctions.has(id.name)) {\n      super.checkLocalExport(id);\n    }\n  }\n}\n","import type { OptionFlags, Options } from \"../options.ts\";\nimport type State from \"../tokenizer/state.ts\";\nimport type { PluginsMap } from \"./index.ts\";\nimport type ScopeHandler from \"../util/scope.ts\";\nimport type ExpressionScopeHandler from \"../util/expression-scope.ts\";\nimport type ClassScopeHandler from \"../util/class-scope.ts\";\nimport type ProductionParameterHandler from \"../util/production-parameter.ts\";\nimport type {\n  ParserPluginWithOptions,\n  PluginConfig,\n  PluginOptions,\n} from \"../typings.ts\";\nimport type * as N from \"../types.ts\";\n\nexport default class BaseParser {\n  // Properties set by constructor in index.js\n  declare options: Options;\n  declare optionFlags: OptionFlags;\n  declare inModule: boolean;\n  declare scope: ScopeHandler<any>;\n  declare classScope: ClassScopeHandler;\n  declare prodParam: ProductionParameterHandler;\n  declare expressionScope: ExpressionScopeHandler;\n  declare plugins: PluginsMap;\n  declare filename: string | undefined | null;\n  declare startIndex: number;\n  // Names of exports store. `default` is stored as a name for both\n  // `export default foo;` and `export { foo as default };`.\n  declare exportedIdentifiers: Set<string>;\n  sawUnambiguousESM: boolean = false;\n  ambiguousScriptDifferentAst: boolean = false;\n\n  // Initialized by Tokenizer\n  declare state: State;\n  // input and length are not in state as they are constant and we do\n  // not want to ever copy them, which happens if state gets cloned\n  declare input: string;\n  declare length: number;\n  // Comment store for Program.comments\n  declare comments: Array<N.Comment>;\n\n  sourceToOffsetPos(sourcePos: number) {\n    return sourcePos + this.startIndex;\n  }\n\n  offsetToSourcePos(offsetPos: number) {\n    return offsetPos - this.startIndex;\n  }\n\n  // This method accepts either a string (plugin name) or an array pair\n  // (plugin name and options object). If an options object is given,\n  // then each value is non-recursively checked for identity with that\n  // plugin’s actual option value.\n  hasPlugin(pluginConfig: PluginConfig): boolean {\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(\n        pluginOptions,\n      ) as (keyof typeof pluginOptions)[]) {\n        if (actualOptions?.[key] !== pluginOptions[key]) {\n          return false;\n        }\n      }\n      return true;\n    }\n  }\n\n  getPluginOption<\n    PluginName extends ParserPluginWithOptions[0],\n    OptionName extends keyof PluginOptions<PluginName>,\n  >(plugin: PluginName, name: OptionName) {\n    return (this.plugins.get(plugin) as null | PluginOptions<PluginName>)?.[\n      name\n    ];\n  }\n}\n","/*:: declare var invariant; */\n\nimport BaseParser from \"./base.ts\";\nimport type { Comment, Node, Identifier } from \"../types.ts\";\nimport * as charCodes from \"charcodes\";\nimport type { Undone } from \"./node.ts\";\n\n/**\n * A whitespace token containing comments\n */\nexport type CommentWhitespace = {\n  /**\n   * the start of the whitespace token.\n   */\n  start: number;\n  /**\n   * the end of the whitespace token.\n   */\n  end: number;\n  /**\n   * the containing comments\n   */\n  comments: Array<Comment>;\n  /**\n   * the immediately preceding AST node of the whitespace token\n   */\n  leadingNode: Node | null;\n  /**\n   * the immediately following AST node of the whitespace token\n   */\n  trailingNode: Node | null;\n  /**\n   * the innermost AST node containing the whitespace with minimal size (|end - start|)\n   */\n  containingNode: Node | null;\n};\n\n/**\n * Merge comments with node's trailingComments or assign comments to be\n * trailingComments. New comments will be placed before old comments\n * because the commentStack is enumerated reversely.\n */\nfunction setTrailingComments(node: Undone<Node>, comments: Array<Comment>) {\n  if (node.trailingComments === undefined) {\n    node.trailingComments = comments;\n  } else {\n    node.trailingComments.unshift(...comments);\n  }\n}\n\n/**\n * Merge comments with node's leadingComments or assign comments to be\n * leadingComments. New comments will be placed before old comments\n * because the commentStack is enumerated reversely.\n */\nfunction setLeadingComments(node: Undone<Node>, comments: Array<Comment>) {\n  if (node.leadingComments === undefined) {\n    node.leadingComments = comments;\n  } else {\n    node.leadingComments.unshift(...comments);\n  }\n}\n\n/**\n * Merge comments with node's innerComments or assign comments to be\n * innerComments. New comments will be placed before old comments\n * because the commentStack is enumerated reversely.\n */\nexport function setInnerComments(\n  node: Undone<Node>,\n  comments?: Array<Comment>,\n) {\n  if (node.innerComments === undefined) {\n    node.innerComments = comments;\n  } else {\n    node.innerComments.unshift(...comments);\n  }\n}\n\n/**\n * Given node and elements array, if elements has non-null element,\n * merge comments to its trailingComments, otherwise merge comments\n * to node's innerComments\n */\nfunction adjustInnerComments(\n  node: Undone<Node>,\n  elements: Array<Node>,\n  commentWS: CommentWhitespace,\n) {\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}\n\nexport default class CommentsParser extends BaseParser {\n  addComment(comment: Comment): void {\n    if (this.filename) comment.loc.filename = this.filename;\n    const { commentsLen } = 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\n  /**\n   * Given a newly created AST node _n_, attach _n_ to a comment whitespace _w_ if applicable\n   * {@see {@link CommentWhitespace}}\n   */\n  processComment(node: Node): void {\n    const { commentStack } = this.state;\n    const commentStackLength = commentStack.length;\n    if (commentStackLength === 0) return;\n    let i = commentStackLength - 1;\n    const lastCommentWS = commentStack[i];\n\n    if (lastCommentWS.start === node.end) {\n      lastCommentWS.leadingNode = node;\n      i--;\n    }\n\n    const { start: nodeStart } = node;\n    // invariant: for all 0 <= j <= i, let c = commentStack[j], c must satisfy c.end < node.end\n    for (; i >= 0; i--) {\n      const commentWS = commentStack[i];\n      const commentEnd = commentWS.end;\n      if (commentEnd > nodeStart) {\n        // by definition of commentWhiteSpace, this implies commentWS.start > nodeStart\n        // so node can be a containingNode candidate. At this time we can finalize the comment\n        // whitespace, because\n        // 1) its leadingNode or trailingNode, if exists, will not change\n        // 2) its containingNode have been assigned and will not change because it is the\n        //    innermost minimal-sized AST node\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        // stop the loop when commentEnd <= nodeStart\n        break;\n      }\n    }\n  }\n\n  /**\n   * Assign the comments of comment whitespaces to related AST nodes.\n   * Also adjust innerComments following trailing comma.\n   */\n  finalizeComment(commentWS: CommentWhitespace) {\n    const { comments } = 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      /*:: invariant(commentWS.containingNode !== null) */\n      const { containingNode: node, start: commentStart } = commentWS;\n      if (\n        this.input.charCodeAt(this.offsetToSourcePos(commentStart) - 1) ===\n        charCodes.comma\n      ) {\n        // If a commentWhitespace follows a comma and the containingNode allows\n        // list structures with trailing comma, merge it to the trailingComment\n        // of the last non-null list element\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          case \"TSEnumDeclaration\":\n            if (!process.env.BABEL_8_BREAKING) {\n              adjustInnerComments(node, node.members, commentWS);\n            } else {\n              setInnerComments(node, comments);\n            }\n            break;\n          case \"TSEnumBody\":\n            adjustInnerComments(node, node.members, commentWS);\n            break;\n          default: {\n            setInnerComments(node, comments);\n          }\n        }\n      } else {\n        setInnerComments(node, comments);\n      }\n    }\n  }\n\n  /**\n   * Drains remaining commentStack and applies finalizeComment\n   * to each comment whitespace. Used only in parseExpression\n   * where the top level AST node is _not_ Program\n   * {@see {@link CommentsParser#finalizeComment}}\n   */\n  finalizeRemainingComments() {\n    const { commentStack } = this.state;\n    for (let i = commentStack.length - 1; i >= 0; i--) {\n      this.finalizeComment(commentStack[i]);\n    }\n    this.state.commentStack = [];\n  }\n\n  /* eslint-disable no-irregular-whitespace */\n  /**\n   * Reset previous node trailing comments. Used in object / class\n   * property parsing. We parse `async`, `static`, `set` and `get`\n   * as an identifier but may reinterpret it into an async/static/accessor\n   * method later. In this case the identifier is not part of the AST and we\n   * should sync the knowledge to commentStacks\n   *\n   * For example, when parsing\n   * ```\n   * async /* 1 *​/ function f() {}\n   * ```\n   * the comment whitespace `/* 1 *​/` has leading node Identifier(async). When\n   * we see the function token, we create a Function node and mark `/* 1 *​/` as\n   * inner comments. So `/* 1 *​/` should be detached from the Identifier node.\n   *\n   * @param node the last finished AST node _before_ current token\n   */\n  /* eslint-enable no-irregular-whitespace */\n  resetPreviousNodeTrailingComments(node: Node) {\n    const { commentStack } = this.state;\n    const { length } = commentStack;\n    if (length === 0) return;\n    const commentWS = commentStack[length - 1];\n    if (commentWS.leadingNode === node) {\n      commentWS.leadingNode = null;\n    }\n  }\n\n  /* eslint-disable no-irregular-whitespace */\n  /**\n   * Reset previous node leading comments, assuming that `node` is a\n   * single-token node. Used in import phase modifiers parsing. We parse\n   * `module` in `import module foo from ...` as an identifier but may\n   * reinterpret it into a phase modifier later. In this case the identifier is\n   * not part of the AST and we should sync the knowledge to commentStacks\n   *\n   * For example, when parsing\n   * ```\n   * import /* 1 *​/ module a from \"a\";\n   * ```\n   * the comment whitespace `/* 1 *​/` has trailing node Identifier(module). When\n   * we see that `module` is not a default import binding, we mark `/* 1 *​/` as\n   * inner comments of the ImportDeclaration. So `/* 1 *​/` should be detached from\n   * the Identifier node.\n   *\n   * @param node the last finished AST node _before_ current token\n   */\n  /* eslint-enable no-irregular-whitespace */\n  resetPreviousIdentifierLeadingComments(node: Identifier) {\n    const { commentStack } = this.state;\n    const { length } = commentStack;\n    if (length === 0) return;\n\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\n  /**\n   * Attach a node to the comment whitespaces right before/after\n   * the given range.\n   *\n   * This is used to properly attach comments around parenthesized\n   * expressions as leading/trailing comments of the inner expression.\n   */\n  takeSurroundingComments(node: Node, start: number, end: number) {\n    const { commentStack } = this.state;\n    const commentStackLength = commentStack.length;\n    if (commentStackLength === 0) return;\n    let i = commentStackLength - 1;\n\n    for (; i >= 0; i--) {\n      const commentWS = commentStack[i];\n      const commentEnd = commentWS.end;\n      const commentStart = commentWS.start;\n\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}\n","import * as charCodes from \"charcodes\";\n\n// Matches a whole line break (where CRLF is considered a single\n// line break). Used to count lines.\nexport const lineBreak = /\\r\\n|[\\r\\n\\u2028\\u2029]/;\nexport const lineBreakG = new RegExp(lineBreak.source, \"g\");\n\n// https://tc39.github.io/ecma262/#sec-line-terminators\nexport function isNewLine(code: number): boolean {\n  switch (code) {\n    case charCodes.lineFeed:\n    case charCodes.carriageReturn:\n    case charCodes.lineSeparator:\n    case charCodes.paragraphSeparator:\n      return true;\n\n    default:\n      return false;\n  }\n}\n\nexport function hasNewLine(input: string, start: number, end: number): boolean {\n  for (let i = start; i < end; i++) {\n    if (isNewLine(input.charCodeAt(i))) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport const skipWhiteSpace = /(?:\\s|\\/\\/.*|\\/\\*[^]*?\\*\\/)*/g;\n\nexport const skipWhiteSpaceInLine =\n  /(?:[^\\S\\n\\r\\u2028\\u2029]|\\/\\/.*|\\/\\*.*?\\*\\/)*/g;\n\n// https://tc39.github.io/ecma262/#sec-white-space\nexport function isWhitespace(code: number): boolean {\n  switch (code) {\n    case 0x0009: // CHARACTER TABULATION\n    case 0x000b: // LINE TABULATION\n    case 0x000c: // FORM FEED\n    case charCodes.space:\n    case charCodes.nonBreakingSpace:\n    case charCodes.oghamSpaceMark:\n    case 0x2000: // EN QUAD\n    case 0x2001: // EM QUAD\n    case 0x2002: // EN SPACE\n    case 0x2003: // EM SPACE\n    case 0x2004: // THREE-PER-EM SPACE\n    case 0x2005: // FOUR-PER-EM SPACE\n    case 0x2006: // SIX-PER-EM SPACE\n    case 0x2007: // FIGURE SPACE\n    case 0x2008: // PUNCTUATION SPACE\n    case 0x2009: // THIN SPACE\n    case 0x200a: // HAIR SPACE\n    case 0x202f: // NARROW NO-BREAK SPACE\n    case 0x205f: // MEDIUM MATHEMATICAL SPACE\n    case 0x3000: // IDEOGRAPHIC SPACE\n    case 0xfeff: // ZERO WIDTH NO-BREAK SPACE\n      return true;\n\n    default:\n      return false;\n  }\n}\n","import type { Options } from \"../options.ts\";\nimport type { CommentWhitespace } from \"../parser/comments\";\nimport { Position } from \"../util/location.ts\";\n\nimport { types as ct, type TokContext } from \"./context.ts\";\nimport { tt, type TokenType } from \"./types.ts\";\nimport type { Errors } from \"../parse-error.ts\";\nimport type { ParseError } from \"../parse-error.ts\";\n\nexport type DeferredStrictError =\n  | typeof Errors.StrictNumericEscape\n  | typeof Errors.StrictOctalLiteral;\n\ntype TopicContextState = {\n  // When a topic binding has been currently established,\n  // then this is 1. Otherwise, it is 0. This is forwards compatible\n  // with a future plugin for multiple lexical topics.\n  maxNumOfResolvableTopics: number;\n  // When a topic binding has been currently established, and if that binding\n  // has been used as a topic reference `#`, then this is 0. Otherwise, it is\n  // `null`. This is forwards compatible with a future plugin for multiple\n  // lexical topics.\n  maxTopicIndex: null | 0;\n};\n\nexport const enum LoopLabelKind {\n  Loop = 1,\n  Switch = 2,\n}\n\ndeclare const bit: import(\"../../../../scripts/babel-plugin-bit-decorator/types.d.ts\").BitDecorator<State>;\n\nexport default class State {\n  @bit.storage flags: number;\n\n  @bit accessor strict = false;\n\n  startIndex: number;\n  curLine: number;\n  lineStart: number;\n\n  // And, if locations are used, the {line, column} object\n  // corresponding to those offsets\n  startLoc: Position;\n  endLoc: Position;\n\n  init({\n    strictMode,\n    sourceType,\n    startIndex,\n    startLine,\n    startColumn,\n  }: Options): void {\n    this.strict =\n      strictMode === false\n        ? false\n        : strictMode === true\n          ? true\n          : sourceType === \"module\";\n\n    this.startIndex = startIndex;\n    this.curLine = startLine;\n    this.lineStart = -startColumn;\n    this.startLoc = this.endLoc = new Position(\n      startLine,\n      startColumn,\n      startIndex,\n    );\n  }\n\n  errors: ParseError<any>[] = [];\n\n  // Used to signify the start of a potential arrow function\n  potentialArrowAt: number = -1;\n\n  // Used to signify the start of an expression which looks like a\n  // typed arrow function, but it isn't\n  // e.g. a ? (b) : c => d\n  //          ^\n  noArrowAt: number[] = [];\n\n  // Used to signify the start of an expression whose params, if it looks like\n  // an arrow function, shouldn't be converted to assignable nodes.\n  // This is used to defer the validation of typed arrow functions inside\n  // conditional expressions.\n  // e.g. a ? (b) : c => d\n  //          ^\n  noArrowParamsConversionAt: number[] = [];\n\n  // Flags to track\n  @bit accessor maybeInArrowParameters = false;\n  @bit accessor inType = false;\n  @bit accessor noAnonFunctionType = false;\n  @bit accessor hasFlowComment = false;\n  @bit accessor isAmbientContext = false;\n  @bit accessor inAbstractClass = false;\n  @bit accessor inDisallowConditionalTypesContext = false;\n\n  // For the Hack-style pipelines plugin\n  topicContext: TopicContextState = {\n    maxNumOfResolvableTopics: 0,\n    maxTopicIndex: null,\n  };\n\n  // For the F#-style pipelines plugin\n  @bit accessor soloAwait = false;\n  @bit accessor inFSharpPipelineDirectBody = false;\n\n  // Labels in scope.\n  labels: Array<{\n    kind: LoopLabelKind;\n    name?: string | null;\n    statementStart?: number;\n  }> = [];\n\n  commentsLen = 0;\n  // Comment attachment store\n  commentStack: Array<CommentWhitespace> = [];\n\n  // The current position of the tokenizer in the input.\n  pos: number = 0;\n\n  // Properties of the current token:\n  // Its type\n  type: TokenType = tt.eof;\n\n  // For tokens that include more information than their type, the value\n  value: any = null;\n\n  // Its start and end offset\n  start: number = 0;\n  end: number = 0;\n\n  // Position information for the previous token\n  // this is initialized when generating the second token.\n  lastTokEndLoc: Position = null;\n  // this is initialized when generating the second token.\n  lastTokStartLoc: Position = null;\n\n  // The context stack is used to track whether the apostrophe \"`\" starts\n  // or ends a string template\n  context: Array<TokContext> = [ct.brace];\n\n  // Used to track whether a JSX element is allowed to form\n  @bit accessor canStartJSXElement = true;\n\n  // Used to signal to callers of `readWord1` whether the word\n  // contained any escape sequences. This is needed because words with\n  // escape sequences must not be interpreted as keywords.\n  @bit accessor containsEsc = false;\n\n  // Used to track invalid escape sequences in template literals,\n  // that must be reported if the template is not tagged.\n  firstInvalidTemplateEscapePos: null | Position = null;\n\n  @bit accessor hasTopLevelAwait = false;\n\n  // This property is used to track the following errors\n  // - StrictNumericEscape\n  // - StrictOctalLiteral\n  //\n  // in a literal that occurs prior to/immediately after a \"use strict\" directive.\n\n  // todo(JLHwung): set strictErrors to null and avoid recording string errors\n  // after a non-directive is parsed\n  strictErrors: Map<number, [DeferredStrictError, Position]> = new Map();\n\n  // Tokens length in token store\n  tokensLength: number = 0;\n\n  /**\n   * When we add a new property, we must manually update the `clone` method\n   * @see State#clone\n   */\n\n  curPosition(): Position {\n    return new Position(\n      this.curLine,\n      this.pos - this.lineStart,\n      this.pos + this.startIndex,\n    );\n  }\n\n  clone(): State {\n    const state = new State();\n    state.flags = this.flags;\n    state.startIndex = this.startIndex;\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\n    return state;\n  }\n}\n\nexport type LookaheadState = {\n  pos: number;\n  value: any;\n  type: TokenType;\n  start: number;\n  end: number;\n  context: TokContext[];\n  startLoc: Position;\n  lastTokEndLoc: Position;\n  curLine: number;\n  lineStart: number;\n  curPosition: State[\"curPosition\"];\n  /* Used only in readToken_mult_modulo */\n  inType: boolean;\n  // These boolean properties are not initialized in createLookaheadState()\n  // instead they will only be set by the tokenizer\n  containsEsc?: boolean;\n};\n","// We inline this package\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as charCodes from \"charcodes\";\n\n// The following character codes are forbidden from being\n// an immediate sibling of NumericLiteralSeparator _\nconst forbiddenNumericSeparatorSiblings = {\n  decBinOct: new Set<number>([\n    charCodes.dot,\n    charCodes.uppercaseB,\n    charCodes.uppercaseE,\n    charCodes.uppercaseO,\n    charCodes.underscore, // multiple separators are not allowed\n    charCodes.lowercaseB,\n    charCodes.lowercaseE,\n    charCodes.lowercaseO,\n  ]),\n  hex: new Set<number>([\n    charCodes.dot,\n    charCodes.uppercaseX,\n    charCodes.underscore, // multiple separators are not allowed\n    charCodes.lowercaseX,\n  ]),\n};\n\nconst isAllowedNumericSeparatorSibling = {\n  // 0 - 1\n  bin: (ch: number) => ch === charCodes.digit0 || ch === charCodes.digit1,\n\n  // 0 - 7\n  oct: (ch: number) => ch >= charCodes.digit0 && ch <= charCodes.digit7,\n\n  // 0 - 9\n  dec: (ch: number) => ch >= charCodes.digit0 && ch <= charCodes.digit9,\n\n  // 0 - 9, A - F, a - f,\n  hex: (ch: number) =>\n    (ch >= charCodes.digit0 && ch <= charCodes.digit9) ||\n    (ch >= charCodes.uppercaseA && ch <= charCodes.uppercaseF) ||\n    (ch >= charCodes.lowercaseA && ch <= charCodes.lowercaseF),\n};\n\nexport type StringContentsErrorHandlers = EscapedCharErrorHandlers & {\n  unterminated(\n    initialPos: number,\n    initialLineStart: number,\n    initialCurLine: number,\n  ): void;\n};\n\nexport function readStringContents(\n  type: \"single\" | \"double\" | \"template\",\n  input: string,\n  pos: number,\n  lineStart: number,\n  curLine: number,\n  errors: StringContentsErrorHandlers,\n) {\n  const initialPos = pos;\n  const initialLineStart = lineStart;\n  const initialCurLine = curLine;\n\n  let out = \"\";\n  let firstInvalidLoc = null;\n  let chunkStart = pos;\n  const { length } = 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 === charCodes.backslash) {\n      out += input.slice(chunkStart, pos);\n      const res = readEscapedChar(\n        input,\n        pos,\n        lineStart,\n        curLine,\n        type === \"template\",\n        errors,\n      );\n      if (res.ch === null && !firstInvalidLoc) {\n        firstInvalidLoc = { pos, lineStart, curLine };\n      } else {\n        out += res.ch;\n      }\n      ({ pos, lineStart, curLine } = res);\n      chunkStart = pos;\n    } else if (\n      ch === charCodes.lineSeparator ||\n      ch === charCodes.paragraphSeparator\n    ) {\n      ++pos;\n      ++curLine;\n      lineStart = pos;\n    } else if (ch === charCodes.lineFeed || ch === charCodes.carriageReturn) {\n      if (type === \"template\") {\n        out += input.slice(chunkStart, pos) + \"\\n\";\n        ++pos;\n        if (\n          ch === charCodes.carriageReturn &&\n          input.charCodeAt(pos) === charCodes.lineFeed\n        ) {\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 process.env.BABEL_8_BREAKING\n    ? { pos, str: out, firstInvalidLoc, lineStart, curLine }\n    : {\n        pos,\n        str: out,\n        firstInvalidLoc,\n        lineStart,\n        curLine,\n        containsInvalid: !!firstInvalidLoc,\n      };\n}\n\nfunction isStringEnd(\n  type: \"single\" | \"double\" | \"template\",\n  ch: number,\n  input: string,\n  pos: number,\n) {\n  if (type === \"template\") {\n    return (\n      ch === charCodes.graveAccent ||\n      (ch === charCodes.dollarSign &&\n        input.charCodeAt(pos + 1) === charCodes.leftCurlyBrace)\n    );\n  }\n  return (\n    ch === (type === \"double\" ? charCodes.quotationMark : charCodes.apostrophe)\n  );\n}\n\ntype EscapedCharErrorHandlers = HexCharErrorHandlers &\n  CodePointErrorHandlers & {\n    strictNumericEscape(pos: number, lineStart: number, curLine: number): void;\n  };\n\nfunction readEscapedChar(\n  input: string,\n  pos: number,\n  lineStart: number,\n  curLine: number,\n  inTemplate: boolean,\n  errors: EscapedCharErrorHandlers,\n) {\n  const throwOnInvalid = !inTemplate;\n  pos++; // skip '\\'\n\n  const res = (ch: string | null) => ({ pos, ch, lineStart, curLine });\n\n  const ch = input.charCodeAt(pos++);\n  switch (ch) {\n    case charCodes.lowercaseN:\n      return res(\"\\n\");\n    case charCodes.lowercaseR:\n      return res(\"\\r\");\n    case charCodes.lowercaseX: {\n      let code;\n      ({ code, pos } = readHexChar(\n        input,\n        pos,\n        lineStart,\n        curLine,\n        2,\n        false,\n        throwOnInvalid,\n        errors,\n      ));\n      return res(code === null ? null : String.fromCharCode(code));\n    }\n    case charCodes.lowercaseU: {\n      let code;\n      ({ code, pos } = readCodePoint(\n        input,\n        pos,\n        lineStart,\n        curLine,\n        throwOnInvalid,\n        errors,\n      ));\n      return res(code === null ? null : String.fromCodePoint(code));\n    }\n    case charCodes.lowercaseT:\n      return res(\"\\t\");\n    case charCodes.lowercaseB:\n      return res(\"\\b\");\n    case charCodes.lowercaseV:\n      return res(\"\\u000b\");\n    case charCodes.lowercaseF:\n      return res(\"\\f\");\n    case charCodes.carriageReturn:\n      if (input.charCodeAt(pos) === charCodes.lineFeed) {\n        ++pos;\n      }\n    // fall through\n    case charCodes.lineFeed:\n      lineStart = pos;\n      ++curLine;\n    // fall through\n    case charCodes.lineSeparator:\n    case charCodes.paragraphSeparator:\n      return res(\"\");\n    case charCodes.digit8:\n    case charCodes.digit9:\n      if (inTemplate) {\n        return res(null);\n      } else {\n        errors.strictNumericEscape(pos - 1, lineStart, curLine);\n      }\n    // fall through\n    default:\n      if (ch >= charCodes.digit0 && ch <= charCodes.digit7) {\n        const startPos = pos - 1;\n        const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));\n\n        let octalStr = match[0];\n\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 (\n          octalStr !== \"0\" ||\n          next === charCodes.digit8 ||\n          next === charCodes.digit9\n        ) {\n          if (inTemplate) {\n            return res(null);\n          } else {\n            errors.strictNumericEscape(startPos, lineStart, curLine);\n          }\n        }\n\n        return res(String.fromCharCode(octal));\n      }\n\n      return res(String.fromCharCode(ch));\n  }\n}\n\ntype HexCharErrorHandlers = IntErrorHandlers & {\n  invalidEscapeSequence(pos: number, lineStart: number, curLine: number): void;\n};\n\n// Used to read character escape sequences ('\\x', '\\u').\nfunction readHexChar(\n  input: string,\n  pos: number,\n  lineStart: number,\n  curLine: number,\n  len: number,\n  forceLen: boolean,\n  throwOnInvalid: boolean,\n  errors: HexCharErrorHandlers,\n) {\n  const initialPos = pos;\n  let n;\n  ({ n, pos } = readInt(\n    input,\n    pos,\n    lineStart,\n    curLine,\n    16,\n    len,\n    forceLen,\n    false,\n    errors,\n    /* bailOnError */ !throwOnInvalid,\n  ));\n  if (n === null) {\n    if (throwOnInvalid) {\n      errors.invalidEscapeSequence(initialPos, lineStart, curLine);\n    } else {\n      pos = initialPos - 1;\n    }\n  }\n  return { code: n, pos };\n}\n\nexport type IntErrorHandlers = {\n  numericSeparatorInEscapeSequence(\n    pos: number,\n    lineStart: number,\n    curLine: number,\n  ): void;\n  unexpectedNumericSeparator(\n    pos: number,\n    lineStart: number,\n    curLine: number,\n  ): void;\n  // It can return \"true\" to indicate that the error was handled\n  // and the int parsing should continue.\n  invalidDigit(\n    pos: number,\n    lineStart: number,\n    curLine: number,\n    radix: number,\n  ): boolean;\n};\n\nexport function readInt(\n  input: string,\n  pos: number,\n  lineStart: number,\n  curLine: number,\n  radix: number,\n  len: number | undefined,\n  forceLen: boolean,\n  allowNumSeparator: boolean | \"bail\",\n  errors: IntErrorHandlers,\n  bailOnError: boolean,\n) {\n  const start = pos;\n  const forbiddenSiblings =\n    radix === 16\n      ? forbiddenNumericSeparatorSiblings.hex\n      : forbiddenNumericSeparatorSiblings.decBinOct;\n  const isAllowedSibling =\n    radix === 16\n      ? isAllowedNumericSeparatorSibling.hex\n      : radix === 10\n        ? isAllowedNumericSeparatorSibling.dec\n        : radix === 8\n          ? isAllowedNumericSeparatorSibling.oct\n          : isAllowedNumericSeparatorSibling.bin;\n\n  let invalid = false;\n  let total = 0;\n\n  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {\n    const code = input.charCodeAt(pos);\n    let val;\n\n    if (code === charCodes.underscore && allowNumSeparator !== \"bail\") {\n      const prev = input.charCodeAt(pos - 1);\n      const next = input.charCodeAt(pos + 1);\n\n      if (!allowNumSeparator) {\n        if (bailOnError) return { n: null, pos };\n        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);\n      } else if (\n        Number.isNaN(next) ||\n        !isAllowedSibling(next) ||\n        forbiddenSiblings.has(prev) ||\n        forbiddenSiblings.has(next)\n      ) {\n        if (bailOnError) return { n: null, pos };\n        errors.unexpectedNumericSeparator(pos, lineStart, curLine);\n      }\n\n      // Ignore this _ character\n      ++pos;\n      continue;\n    }\n\n    if (code >= charCodes.lowercaseA) {\n      val = code - charCodes.lowercaseA + charCodes.lineFeed;\n    } else if (code >= charCodes.uppercaseA) {\n      val = code - charCodes.uppercaseA + charCodes.lineFeed;\n    } else if (charCodes.isDigit(code)) {\n      val = code - charCodes.digit0; // 0-9\n    } else {\n      val = Infinity;\n    }\n    if (val >= radix) {\n      // If we found a digit which is too big, errors.invalidDigit can return true to avoid\n      // breaking the loop (this is used for error recovery).\n      if (val <= 9 && bailOnError) {\n        return { n: null, pos };\n      } else if (\n        val <= 9 &&\n        errors.invalidDigit(pos, lineStart, curLine, radix)\n      ) {\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: null, pos };\n  }\n\n  return { n: total, pos };\n}\n\nexport type CodePointErrorHandlers = HexCharErrorHandlers & {\n  invalidCodePoint(pos: number, lineStart: number, curLine: number): void;\n};\n\nexport function readCodePoint(\n  input: string,\n  pos: number,\n  lineStart: number,\n  curLine: number,\n  throwOnInvalid: boolean,\n  errors: CodePointErrorHandlers,\n) {\n  const ch = input.charCodeAt(pos);\n  let code;\n\n  if (ch === charCodes.leftCurlyBrace) {\n    ++pos;\n    ({ code, pos } = readHexChar(\n      input,\n      pos,\n      lineStart,\n      curLine,\n      input.indexOf(\"}\", pos) - pos,\n      true,\n      throwOnInvalid,\n      errors,\n    ));\n    ++pos;\n    if (code !== null && code > 0x10ffff) {\n      if (throwOnInvalid) {\n        errors.invalidCodePoint(pos, lineStart, curLine);\n      } else {\n        return { code: null, pos };\n      }\n    }\n  } else {\n    ({ code, pos } = readHexChar(\n      input,\n      pos,\n      lineStart,\n      curLine,\n      4,\n      false,\n      throwOnInvalid,\n      errors,\n    ));\n  }\n  return { code, pos };\n}\n","/*:: declare var invariant; */\n\nimport { OptionFlags, type Options } from \"../options.ts\";\nimport {\n  Position,\n  SourceLocation,\n  createPositionWithColumnOffset,\n} from \"../util/location.ts\";\nimport CommentsParser, { type CommentWhitespace } from \"../parser/comments.ts\";\nimport type * as N from \"../types.ts\";\nimport * as charCodes from \"charcodes\";\nimport { isIdentifierStart, isIdentifierChar } from \"../util/identifier.ts\";\nimport {\n  tokenIsKeyword,\n  tokenLabelName,\n  tt,\n  keywords as keywordTypes,\n  type TokenType,\n} from \"./types.ts\";\nimport type { TokContext } from \"./context.ts\";\nimport {\n  Errors,\n  type ParseError,\n  type ParseErrorConstructor,\n} from \"../parse-error.ts\";\nimport {\n  lineBreakG,\n  isNewLine,\n  isWhitespace,\n  skipWhiteSpace,\n  skipWhiteSpaceInLine,\n} from \"../util/whitespace.ts\";\nimport State from \"./state.ts\";\nimport type { LookaheadState, DeferredStrictError } from \"./state.ts\";\nimport type { Undone } from \"../parser/node.ts\";\nimport type { Node } from \"../types.ts\";\n\nimport {\n  readInt,\n  readCodePoint,\n  readStringContents,\n  type IntErrorHandlers,\n  type CodePointErrorHandlers,\n  type StringContentsErrorHandlers,\n} from \"@babel/helper-string-parser\";\n\nimport type { Plugin } from \"../typings.ts\";\n\nfunction buildPosition(pos: number, lineStart: number, curLine: number) {\n  return new Position(curLine, pos - lineStart, pos);\n}\n\nconst VALID_REGEX_FLAGS = new Set([\n  charCodes.lowercaseG,\n  charCodes.lowercaseM,\n  charCodes.lowercaseS,\n  charCodes.lowercaseI,\n  charCodes.lowercaseY,\n  charCodes.lowercaseU,\n  charCodes.lowercaseD,\n  charCodes.lowercaseV,\n]);\n\n// Object type used to represent tokens. Note that normally, tokens\n// simply exist as properties on the parser object. This is only\n// used for the onToken callback and the external tokenizer.\n\nexport class Token {\n  constructor(state: State) {\n    const startIndex = state.startIndex || 0;\n    this.type = state.type;\n    this.value = state.value;\n    this.start = startIndex + state.start;\n    this.end = startIndex + state.end;\n    this.loc = new SourceLocation(state.startLoc, state.endLoc);\n  }\n\n  declare type: TokenType;\n  declare value: any;\n  declare start: number;\n  declare end: number;\n  declare loc: SourceLocation;\n}\n\n// ## Tokenizer\n\nexport default abstract class Tokenizer extends CommentsParser {\n  isLookahead: boolean;\n\n  // Token store.\n  tokens: Array<Token | N.Comment> = [];\n\n  constructor(options: Options, input: string) {\n    super();\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\n  pushToken(token: Token | N.Comment) {\n    // Pop out invalid tokens trapped by try-catch parsing.\n    // Those parsing branches are mainly created by typescript and flow plugins.\n    this.tokens.length = this.state.tokensLength;\n    this.tokens.push(token);\n    ++this.state.tokensLength;\n  }\n\n  // Move to the next token\n\n  next(): void {\n    this.checkKeywordEscapes();\n    if (this.optionFlags & OptionFlags.Tokens) {\n      this.pushToken(new Token(this.state));\n    }\n\n    this.state.lastTokEndLoc = this.state.endLoc;\n    this.state.lastTokStartLoc = this.state.startLoc;\n    this.nextToken();\n  }\n\n  eat(type: TokenType): boolean {\n    if (this.match(type)) {\n      this.next();\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Whether current token matches given type\n   */\n  match(type: TokenType): boolean {\n    return this.state.type === type;\n  }\n\n  /**\n   * Create a LookaheadState from current parser state\n   */\n  createLookaheadState(state: State): LookaheadState {\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\n  /**\n   * lookahead peeks the next token, skipping changes to token context and\n   * comment stack. For performance it returns a limited LookaheadState\n   * instead of full parser state.\n   *\n   * The { column, line } Loc info is not included in lookahead since such usage\n   * is rare. Although it may return other location properties e.g. `curLine` and\n   * `lineStart`, these properties are not listed in the LookaheadState interface\n   * and thus the returned value is _NOT_ reliable.\n   *\n   * The tokenizer should make best efforts to avoid using any parser state\n   * other than those defined in LookaheadState\n   */\n  lookahead(): LookaheadState {\n    const old = this.state;\n    // @ts-expect-error For performance we use a simplified tokenizer state structure\n    this.state = this.createLookaheadState(old);\n\n    this.isLookahead = true;\n    this.nextToken();\n    this.isLookahead = false;\n\n    const curr = this.state;\n    this.state = old;\n    return curr;\n  }\n\n  nextTokenStart(): number {\n    return this.nextTokenStartSince(this.state.pos);\n  }\n\n  nextTokenStartSince(pos: number): number {\n    skipWhiteSpace.lastIndex = pos;\n    return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos;\n  }\n\n  lookaheadCharCode(): number {\n    return this.input.charCodeAt(this.nextTokenStart());\n  }\n\n  /**\n   * Similar to nextToken, but it will stop at line break when it is seen before the next token\n   *\n   * @returns {number} position of the next token start or line break, whichever is seen first.\n   * @memberof Tokenizer\n   */\n  nextTokenInLineStart(): number {\n    return this.nextTokenInLineStartSince(this.state.pos);\n  }\n\n  nextTokenInLineStartSince(pos: number): number {\n    skipWhiteSpaceInLine.lastIndex = pos;\n    return skipWhiteSpaceInLine.test(this.input)\n      ? skipWhiteSpaceInLine.lastIndex\n      : pos;\n  }\n\n  /**\n   * Similar to lookaheadCharCode, but it will return the char code of line break if it is\n   * seen before the next token\n   *\n   * @returns {number} char code of the next token start or line break, whichever is seen first.\n   * @memberof Tokenizer\n   */\n  lookaheadInLineCharCode(): number {\n    return this.input.charCodeAt(this.nextTokenInLineStart());\n  }\n\n  codePointAtPos(pos: number): number {\n    // The implementation is based on\n    // https://source.chromium.org/chromium/chromium/src/+/master:v8/src/builtins/builtins-string-gen.cc;l=1455;drc=221e331b49dfefadbc6fa40b0c68e6f97606d0b3;bpv=0;bpt=1\n    // We reimplement `codePointAt` because `codePointAt` is a V8 builtin which is not inlined by TurboFan (as of M91)\n    // since `input` is mostly ASCII, an inlined `charCodeAt` wins here\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\n  // Toggle strict mode. Re-reads the next number or string to please\n  // pedantic tests (`\"use strict\"; 010;` should fail).\n\n  setStrict(strict: boolean): void {\n    this.state.strict = strict;\n    if (strict) {\n      // Throw an error for any string decimal escape found before/immediately\n      // after a \"use strict\" directive. Strict mode will be set at parse\n      // time for any literals that occur after the next node of the strict\n      // directive.\n      this.state.strictErrors.forEach(([toParseError, at]) =>\n        this.raise(toParseError, at),\n      );\n      this.state.strictErrors.clear();\n    }\n  }\n\n  curContext(): TokContext {\n    return this.state.context[this.state.context.length - 1];\n  }\n\n  // Read a single token, updating the parser object's token-related properties.\n  nextToken(): void {\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(tt.eof);\n      return;\n    }\n\n    this.getTokenFromCode(this.codePointAtPos(this.state.pos));\n  }\n\n  // Skips a block comment, whose end is marked by commentEnd.\n  // *-/ is used by the Flow plugin, when parsing block comments nested\n  // inside Flow comments.\n  skipBlockComment(commentEnd: \"*/\" | \"*-/\"): N.CommentBlock | undefined {\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      // We have to call this again here because startLoc may not be set...\n      // This seems to be for performance reasons:\n      // https://github.com/babel/babel/commit/acf2a10899f696a8aaf34df78bf9725b5ea7f2da\n      throw this.raise(Errors.UnterminatedComment, this.state.curPosition());\n    }\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\n    // If we are doing a lookahead right now we need to advance the position (above code)\n    // but we do not want to push the comment to the state.\n    if (this.isLookahead) return;\n    /*:: invariant(startLoc) */\n\n    const comment: N.CommentBlock = {\n      type: \"CommentBlock\",\n      value: this.input.slice(start + 2, end),\n      start: this.sourceToOffsetPos(start),\n      end: this.sourceToOffsetPos(end + commentEnd.length),\n      loc: new SourceLocation(startLoc, this.state.curPosition()),\n    };\n    if (this.optionFlags & OptionFlags.Tokens) this.pushToken(comment);\n    return comment;\n  }\n\n  skipLineComment(startSkip: number): N.CommentLine | undefined {\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\n    // If we are doing a lookahead right now we need to advance the position (above code)\n    // but we do not want to push the comment to the state.\n    if (this.isLookahead) return;\n\n    const end = this.state.pos;\n    const value = this.input.slice(start + startSkip, end);\n\n    const comment: N.CommentLine = {\n      type: \"CommentLine\",\n      value,\n      start: this.sourceToOffsetPos(start),\n      end: this.sourceToOffsetPos(end),\n      loc: new SourceLocation(startLoc, this.state.curPosition()),\n    };\n    if (this.optionFlags & OptionFlags.Tokens) this.pushToken(comment);\n    return comment;\n  }\n\n  // Called at the start of the parse and after every token. Skips\n  // whitespace and comments, and.\n\n  skipSpace(): void {\n    const spaceStart = this.state.pos;\n    const comments: N.Comment[] =\n      this.optionFlags & OptionFlags.AttachComment ? [] : null;\n    loop: while (this.state.pos < this.length) {\n      const ch = this.input.charCodeAt(this.state.pos);\n      switch (ch) {\n        case charCodes.space:\n        case charCodes.nonBreakingSpace:\n        case charCodes.tab:\n          ++this.state.pos;\n          break;\n        case charCodes.carriageReturn:\n          if (\n            this.input.charCodeAt(this.state.pos + 1) === charCodes.lineFeed\n          ) {\n            ++this.state.pos;\n          }\n        // fall through\n        case charCodes.lineFeed:\n        case charCodes.lineSeparator:\n        case charCodes.paragraphSeparator:\n          ++this.state.pos;\n          ++this.state.curLine;\n          this.state.lineStart = this.state.pos;\n          break;\n\n        case charCodes.slash:\n          switch (this.input.charCodeAt(this.state.pos + 1)) {\n            case charCodes.asterisk: {\n              const comment = this.skipBlockComment(\"*/\");\n              if (comment !== undefined) {\n                this.addComment(comment);\n                comments?.push(comment);\n              }\n              break;\n            }\n\n            case charCodes.slash: {\n              const comment = this.skipLineComment(2);\n              if (comment !== undefined) {\n                this.addComment(comment);\n                comments?.push(comment);\n              }\n              break;\n            }\n\n            default:\n              break loop;\n          }\n          break;\n\n        default:\n          if (isWhitespace(ch)) {\n            ++this.state.pos;\n          } else if (\n            ch === charCodes.dash &&\n            !this.inModule &&\n            this.optionFlags & OptionFlags.AnnexB\n          ) {\n            const pos = this.state.pos;\n            if (\n              this.input.charCodeAt(pos + 1) === charCodes.dash &&\n              this.input.charCodeAt(pos + 2) === charCodes.greaterThan &&\n              (spaceStart === 0 || this.state.lineStart > spaceStart)\n            ) {\n              // A `-->` line comment\n              const comment = this.skipLineComment(3);\n              if (comment !== undefined) {\n                this.addComment(comment);\n                comments?.push(comment);\n              }\n            } else {\n              break loop;\n            }\n          } else if (\n            ch === charCodes.lessThan &&\n            !this.inModule &&\n            this.optionFlags & OptionFlags.AnnexB\n          ) {\n            const pos = this.state.pos;\n            if (\n              this.input.charCodeAt(pos + 1) === charCodes.exclamationMark &&\n              this.input.charCodeAt(pos + 2) === charCodes.dash &&\n              this.input.charCodeAt(pos + 3) === charCodes.dash\n            ) {\n              // `<!--`, an XML-style comment that should be interpreted as a line comment\n              const comment = this.skipLineComment(4);\n              if (comment !== undefined) {\n                this.addComment(comment);\n                comments?.push(comment);\n              }\n            } else {\n              break loop;\n            }\n          } else {\n            break loop;\n          }\n      }\n    }\n\n    if (comments?.length > 0) {\n      const end = this.state.pos;\n      const commentWhitespace: CommentWhitespace = {\n        start: this.sourceToOffsetPos(spaceStart),\n        end: this.sourceToOffsetPos(end),\n        comments,\n        leadingNode: null,\n        trailingNode: null,\n        containingNode: null,\n      };\n      this.state.commentStack.push(commentWhitespace);\n    }\n  }\n\n  // Called at the end of every token. Sets `end`, `val`, and\n  // maintains `context` and `canStartJSXElement`, and skips the space after\n  // the token, so that the next one's `start` will point at the\n  // right position.\n\n  finishToken(type: TokenType, val?: any): void {\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\n    if (!this.isLookahead) {\n      this.updateContext(prevType);\n    }\n  }\n\n  replaceToken(type: TokenType): void {\n    this.state.type = type;\n    // @ts-expect-error the prevType of updateContext is required\n    // only when the new type is tt.slash/tt.jsxTagEnd\n    this.updateContext();\n  }\n\n  // ### Token reading\n\n  // This is the function that is called to fetch the next token. It\n  // is somewhat obscure, because it works in character codes rather\n  // than characters, and because operator parsing has been inlined\n  // into it.\n  //\n  // All in the name of speed.\n\n  // number sign is \"#\"\n  readToken_numberSign(): void {\n    if (this.state.pos === 0 && this.readToken_interpreter()) {\n      return;\n    }\n\n    const nextPos = this.state.pos + 1;\n    const next = this.codePointAtPos(nextPos);\n    if (next >= charCodes.digit0 && next <= charCodes.digit9) {\n      throw this.raise(\n        Errors.UnexpectedDigitAfterHash,\n        this.state.curPosition(),\n      );\n    }\n\n    if (\n      next === charCodes.leftCurlyBrace ||\n      (next === charCodes.leftSquareBracket && this.hasPlugin(\"recordAndTuple\"))\n    ) {\n      // When we see `#{`, it is likely to be a hash record.\n      // However we don't yell at `#[` since users may intend to use \"computed private fields\",\n      // which is not allowed in the spec. Throwing expecting recordAndTuple is\n      // misleading\n      this.expectPlugin(\"recordAndTuple\");\n      if (\n        !process.env.BABEL_8_BREAKING &&\n        this.getPluginOption(\"recordAndTuple\", \"syntaxType\") === \"bar\"\n      ) {\n        throw this.raise(\n          next === charCodes.leftCurlyBrace\n            ? Errors.RecordExpressionHashIncorrectStartSyntaxType\n            : Errors.TupleExpressionHashIncorrectStartSyntaxType,\n          this.state.curPosition(),\n        );\n      }\n\n      this.state.pos += 2;\n      if (next === charCodes.leftCurlyBrace) {\n        // #{\n        this.finishToken(tt.braceHashL);\n      } else {\n        // #[\n        this.finishToken(tt.bracketHashL);\n      }\n    } else if (isIdentifierStart(next)) {\n      ++this.state.pos;\n      this.finishToken(tt.privateName, this.readWord1(next));\n    } else if (next === charCodes.backslash) {\n      ++this.state.pos;\n      this.finishToken(tt.privateName, this.readWord1());\n    } else {\n      this.finishOp(tt.hash, 1);\n    }\n  }\n\n  readToken_dot(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next >= charCodes.digit0 && next <= charCodes.digit9) {\n      this.readNumber(true);\n      return;\n    }\n\n    if (\n      next === charCodes.dot &&\n      this.input.charCodeAt(this.state.pos + 2) === charCodes.dot\n    ) {\n      this.state.pos += 3;\n      this.finishToken(tt.ellipsis);\n    } else {\n      ++this.state.pos;\n      this.finishToken(tt.dot);\n    }\n  }\n\n  readToken_slash(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === charCodes.equalsTo) {\n      this.finishOp(tt.slashAssign, 2);\n    } else {\n      this.finishOp(tt.slash, 1);\n    }\n  }\n\n  readToken_interpreter(): boolean {\n    if (this.state.pos !== 0 || this.length < 2) return false;\n\n    let ch = this.input.charCodeAt(this.state.pos + 1);\n    if (ch !== charCodes.exclamationMark) return false;\n\n    const start = this.state.pos;\n    this.state.pos += 1;\n\n    while (!isNewLine(ch) && ++this.state.pos < this.length) {\n      ch = this.input.charCodeAt(this.state.pos);\n    }\n\n    const value = this.input.slice(start + 2, this.state.pos);\n\n    this.finishToken(tt.interpreterDirective, value);\n\n    return true;\n  }\n\n  readToken_mult_modulo(code: number): void {\n    // '%' or '*'\n    let type = code === charCodes.asterisk ? tt.star : tt.modulo;\n    let width = 1;\n    let next = this.input.charCodeAt(this.state.pos + 1);\n\n    // Exponentiation operator '**'\n    if (code === charCodes.asterisk && next === charCodes.asterisk) {\n      width++;\n      next = this.input.charCodeAt(this.state.pos + 2);\n      type = tt.exponent;\n    }\n\n    // '%=' or '*='\n    if (next === charCodes.equalsTo && !this.state.inType) {\n      width++;\n      // `tt.moduloAssign` is only needed to support % as a Hack-pipe topic token.\n      // If the proposal ends up choosing a different token,\n      // it can be merged with tt.assign.\n      type = code === charCodes.percentSign ? tt.moduloAssign : tt.assign;\n    }\n\n    this.finishOp(type, width);\n  }\n\n  readToken_pipe_amp(code: number): void {\n    // '||' '&&' '||=' '&&='\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    if (next === code) {\n      if (this.input.charCodeAt(this.state.pos + 2) === charCodes.equalsTo) {\n        this.finishOp(tt.assign, 3);\n      } else {\n        this.finishOp(\n          code === charCodes.verticalBar ? tt.logicalOR : tt.logicalAND,\n          2,\n        );\n      }\n      return;\n    }\n\n    if (code === charCodes.verticalBar) {\n      // '|>'\n      if (next === charCodes.greaterThan) {\n        this.finishOp(tt.pipeline, 2);\n        return;\n      }\n      // '|}'\n      if (\n        !process.env.BABEL_8_BREAKING &&\n        this.hasPlugin(\"recordAndTuple\") &&\n        next === charCodes.rightCurlyBrace\n      ) {\n        if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n          throw this.raise(\n            Errors.RecordExpressionBarIncorrectEndSyntaxType,\n            this.state.curPosition(),\n          );\n        }\n        this.state.pos += 2;\n        this.finishToken(tt.braceBarR);\n        return;\n      }\n\n      // '|]'\n      if (\n        !process.env.BABEL_8_BREAKING &&\n        this.hasPlugin(\"recordAndTuple\") &&\n        next === charCodes.rightSquareBracket\n      ) {\n        if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n          throw this.raise(\n            Errors.TupleExpressionBarIncorrectEndSyntaxType,\n            this.state.curPosition(),\n          );\n        }\n        this.state.pos += 2;\n        this.finishToken(tt.bracketBarR);\n        return;\n      }\n    }\n\n    if (next === charCodes.equalsTo) {\n      this.finishOp(tt.assign, 2);\n      return;\n    }\n\n    this.finishOp(\n      code === charCodes.verticalBar ? tt.bitwiseOR : tt.bitwiseAND,\n      1,\n    );\n  }\n\n  readToken_caret(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    // '^='\n    if (next === charCodes.equalsTo && !this.state.inType) {\n      // `tt.xorAssign` is only needed to support ^ as a Hack-pipe topic token.\n      // If the proposal ends up choosing a different token,\n      // it can be merged with tt.assign.\n      this.finishOp(tt.xorAssign, 2);\n    }\n    // '^^'\n    else if (\n      next === charCodes.caret &&\n      // If the ^^ token is not enabled, we don't throw but parse two single ^s\n      // because it could be a ^ hack token followed by a ^ binary operator.\n      this.hasPlugin([\n        \"pipelineOperator\",\n        { proposal: \"hack\", topicToken: \"^^\" },\n      ])\n    ) {\n      this.finishOp(tt.doubleCaret, 2);\n\n      // `^^^` is forbidden and must be separated by a space.\n      const lookaheadCh = this.input.codePointAt(this.state.pos);\n      if (lookaheadCh === charCodes.caret) {\n        this.unexpected();\n      }\n    }\n    // '^'\n    else {\n      this.finishOp(tt.bitwiseXOR, 1);\n    }\n  }\n\n  readToken_atSign(): void {\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    // '@@'\n    if (\n      next === charCodes.atSign &&\n      this.hasPlugin([\n        \"pipelineOperator\",\n        { proposal: \"hack\", topicToken: \"@@\" },\n      ])\n    ) {\n      this.finishOp(tt.doubleAt, 2);\n    }\n    // '@'\n    else {\n      this.finishOp(tt.at, 1);\n    }\n  }\n\n  readToken_plus_min(code: number): void {\n    // '+-'\n    const next = this.input.charCodeAt(this.state.pos + 1);\n\n    if (next === code) {\n      this.finishOp(tt.incDec, 2);\n      return;\n    }\n\n    if (next === charCodes.equalsTo) {\n      this.finishOp(tt.assign, 2);\n    } else {\n      this.finishOp(tt.plusMin, 1);\n    }\n  }\n\n  readToken_lt(): void {\n    // '<'\n    const { pos } = this.state;\n    const next = this.input.charCodeAt(pos + 1);\n\n    if (next === charCodes.lessThan) {\n      if (this.input.charCodeAt(pos + 2) === charCodes.equalsTo) {\n        this.finishOp(tt.assign, 3);\n        return;\n      }\n      this.finishOp(tt.bitShiftL, 2);\n      return;\n    }\n\n    if (next === charCodes.equalsTo) {\n      // <=\n      this.finishOp(tt.relational, 2);\n      return;\n    }\n\n    this.finishOp(tt.lt, 1);\n  }\n\n  readToken_gt(): void {\n    // '>'\n    const { pos } = this.state;\n    const next = this.input.charCodeAt(pos + 1);\n\n    if (next === charCodes.greaterThan) {\n      const size =\n        this.input.charCodeAt(pos + 2) === charCodes.greaterThan ? 3 : 2;\n      if (this.input.charCodeAt(pos + size) === charCodes.equalsTo) {\n        this.finishOp(tt.assign, size + 1);\n        return;\n      }\n      this.finishOp(tt.bitShiftR, size);\n      return;\n    }\n\n    if (next === charCodes.equalsTo) {\n      // <= | >=\n      this.finishOp(tt.relational, 2);\n      return;\n    }\n\n    this.finishOp(tt.gt, 1);\n  }\n\n  readToken_eq_excl(code: number): void {\n    // '=!'\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    if (next === charCodes.equalsTo) {\n      this.finishOp(\n        tt.equality,\n        this.input.charCodeAt(this.state.pos + 2) === charCodes.equalsTo\n          ? 3\n          : 2,\n      );\n      return;\n    }\n    if (code === charCodes.equalsTo && next === charCodes.greaterThan) {\n      // '=>'\n      this.state.pos += 2;\n      this.finishToken(tt.arrow);\n      return;\n    }\n    this.finishOp(code === charCodes.equalsTo ? tt.eq : tt.bang, 1);\n  }\n\n  readToken_question(): void {\n    // '?'\n    const next = this.input.charCodeAt(this.state.pos + 1);\n    const next2 = this.input.charCodeAt(this.state.pos + 2);\n    if (next === charCodes.questionMark) {\n      if (next2 === charCodes.equalsTo) {\n        // '??='\n        this.finishOp(tt.assign, 3);\n      } else {\n        // '??'\n        this.finishOp(tt.nullishCoalescing, 2);\n      }\n    } else if (\n      next === charCodes.dot &&\n      !(next2 >= charCodes.digit0 && next2 <= charCodes.digit9)\n    ) {\n      // '.' not followed by a number\n      this.state.pos += 2;\n      this.finishToken(tt.questionDot);\n    } else {\n      ++this.state.pos;\n      this.finishToken(tt.question);\n    }\n  }\n\n  getTokenFromCode(code: number): void {\n    switch (code) {\n      // The interpretation of a dot depends on whether it is followed\n      // by a digit or another two dots.\n\n      case charCodes.dot:\n        this.readToken_dot();\n        return;\n      // Punctuation tokens.\n      case charCodes.leftParenthesis:\n        ++this.state.pos;\n        this.finishToken(tt.parenL);\n        return;\n      case charCodes.rightParenthesis:\n        ++this.state.pos;\n        this.finishToken(tt.parenR);\n        return;\n      case charCodes.semicolon:\n        ++this.state.pos;\n        this.finishToken(tt.semi);\n        return;\n      case charCodes.comma:\n        ++this.state.pos;\n        this.finishToken(tt.comma);\n        return;\n      case charCodes.leftSquareBracket:\n        if (\n          !process.env.BABEL_8_BREAKING &&\n          this.hasPlugin(\"recordAndTuple\") &&\n          this.input.charCodeAt(this.state.pos + 1) === charCodes.verticalBar\n        ) {\n          if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n            throw this.raise(\n              Errors.TupleExpressionBarIncorrectStartSyntaxType,\n              this.state.curPosition(),\n            );\n          }\n\n          // [|\n          this.state.pos += 2;\n          this.finishToken(tt.bracketBarL);\n        } else {\n          ++this.state.pos;\n          this.finishToken(tt.bracketL);\n        }\n        return;\n      case charCodes.rightSquareBracket:\n        ++this.state.pos;\n        this.finishToken(tt.bracketR);\n        return;\n      case charCodes.leftCurlyBrace:\n        if (\n          !process.env.BABEL_8_BREAKING &&\n          this.hasPlugin(\"recordAndTuple\") &&\n          this.input.charCodeAt(this.state.pos + 1) === charCodes.verticalBar\n        ) {\n          if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n            throw this.raise(\n              Errors.RecordExpressionBarIncorrectStartSyntaxType,\n              this.state.curPosition(),\n            );\n          }\n\n          // {|\n          this.state.pos += 2;\n          this.finishToken(tt.braceBarL);\n        } else {\n          ++this.state.pos;\n          this.finishToken(tt.braceL);\n        }\n        return;\n      case charCodes.rightCurlyBrace:\n        ++this.state.pos;\n        this.finishToken(tt.braceR);\n        return;\n\n      case charCodes.colon:\n        if (\n          this.hasPlugin(\"functionBind\") &&\n          this.input.charCodeAt(this.state.pos + 1) === charCodes.colon\n        ) {\n          this.finishOp(tt.doubleColon, 2);\n        } else {\n          ++this.state.pos;\n          this.finishToken(tt.colon);\n        }\n        return;\n\n      case charCodes.questionMark:\n        this.readToken_question();\n        return;\n\n      case charCodes.graveAccent:\n        this.readTemplateToken();\n        return;\n\n      case charCodes.digit0: {\n        const next = this.input.charCodeAt(this.state.pos + 1);\n        // '0x', '0X' - hex number\n        if (next === charCodes.lowercaseX || next === charCodes.uppercaseX) {\n          this.readRadixNumber(16);\n          return;\n        }\n        // '0o', '0O' - octal number\n        if (next === charCodes.lowercaseO || next === charCodes.uppercaseO) {\n          this.readRadixNumber(8);\n          return;\n        }\n        // '0b', '0B' - binary number\n        if (next === charCodes.lowercaseB || next === charCodes.uppercaseB) {\n          this.readRadixNumber(2);\n          return;\n        }\n      }\n      // Anything else beginning with a digit is an integer, octal\n      // number, or float. (fall through)\n      case charCodes.digit1:\n      case charCodes.digit2:\n      case charCodes.digit3:\n      case charCodes.digit4:\n      case charCodes.digit5:\n      case charCodes.digit6:\n      case charCodes.digit7:\n      case charCodes.digit8:\n      case charCodes.digit9:\n        this.readNumber(false);\n        return;\n\n      // Quotes produce strings.\n      case charCodes.quotationMark:\n      case charCodes.apostrophe:\n        this.readString(code);\n        return;\n\n      // Operators are parsed inline in tiny state machines. '=' (charCodes.equalsTo) is\n      // often referred to. `finishOp` simply skips the amount of\n      // characters it is given as second argument, and returns a token\n      // of the type given by its first argument.\n\n      case charCodes.slash:\n        this.readToken_slash();\n        return;\n\n      case charCodes.percentSign:\n      case charCodes.asterisk:\n        this.readToken_mult_modulo(code);\n        return;\n\n      case charCodes.verticalBar:\n      case charCodes.ampersand:\n        this.readToken_pipe_amp(code);\n        return;\n\n      case charCodes.caret:\n        this.readToken_caret();\n        return;\n\n      case charCodes.plusSign:\n      case charCodes.dash:\n        this.readToken_plus_min(code);\n        return;\n\n      case charCodes.lessThan:\n        this.readToken_lt();\n        return;\n\n      case charCodes.greaterThan:\n        this.readToken_gt();\n        return;\n\n      case charCodes.equalsTo:\n      case charCodes.exclamationMark:\n        this.readToken_eq_excl(code);\n        return;\n\n      case charCodes.tilde:\n        this.finishOp(tt.tilde, 1);\n        return;\n\n      case charCodes.atSign:\n        this.readToken_atSign();\n        return;\n\n      case charCodes.numberSign:\n        this.readToken_numberSign();\n        return;\n\n      case charCodes.backslash:\n        this.readWord();\n        return;\n\n      default:\n        if (isIdentifierStart(code)) {\n          this.readWord(code);\n          return;\n        }\n    }\n\n    throw this.raise(\n      Errors.InvalidOrUnexpectedToken,\n      this.state.curPosition(),\n      {\n        unexpected: String.fromCodePoint(code),\n      },\n    );\n  }\n\n  finishOp(type: TokenType, size: number): void {\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\n  readRegexp(): void {\n    const startLoc = this.state.startLoc;\n    const start = this.state.start + 1;\n    let escaped, inClass;\n    let { pos } = this.state;\n    for (; ; ++pos) {\n      if (pos >= this.length) {\n        // FIXME: explain\n        throw this.raise(\n          Errors.UnterminatedRegExp,\n          createPositionWithColumnOffset(startLoc, 1),\n        );\n      }\n      const ch = this.input.charCodeAt(pos);\n      if (isNewLine(ch)) {\n        throw this.raise(\n          Errors.UnterminatedRegExp,\n          createPositionWithColumnOffset(startLoc, 1),\n        );\n      }\n      if (escaped) {\n        escaped = false;\n      } else {\n        if (ch === charCodes.leftSquareBracket) {\n          inClass = true;\n        } else if (ch === charCodes.rightSquareBracket && inClass) {\n          inClass = false;\n        } else if (ch === charCodes.slash && !inClass) {\n          break;\n        }\n        escaped = ch === charCodes.backslash;\n      }\n    }\n    const content = this.input.slice(start, pos);\n    ++pos;\n\n    let mods = \"\";\n\n    const nextPos = () =>\n      // (pos + 1) + 1 - start\n      createPositionWithColumnOffset(startLoc, pos + 2 - start);\n\n    while (pos < this.length) {\n      const cp = this.codePointAtPos(pos);\n      // It doesn't matter if cp > 0xffff, the loop will either throw or break because we check on cp\n      const char = String.fromCharCode(cp);\n\n      // @ts-expect-error VALID_REGEX_FLAGS.has should accept expanded type: number\n      if (VALID_REGEX_FLAGS.has(cp)) {\n        if (cp === charCodes.lowercaseV) {\n          if (mods.includes(\"u\")) {\n            this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());\n          }\n        } else if (cp === charCodes.lowercaseU) {\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 === charCodes.backslash) {\n        this.raise(Errors.MalformedRegExpFlags, nextPos());\n      } else {\n        break;\n      }\n\n      ++pos;\n      mods += char;\n    }\n    this.state.pos = pos;\n\n    this.finishToken(tt.regexp, {\n      pattern: content,\n      flags: mods,\n    });\n  }\n\n  // Read an integer in the given radix. Return null if zero digits\n  // were read, the integer value otherwise. When `len` is given, this\n  // will return `null` unless the integer has exactly `len` digits.\n  // When `forceLen` is `true`, it means that we already know that in case\n  // of a malformed number we have to skip `len` characters anyway, instead\n  // of bailing out early. For example, in \"\\u{123Z}\" we want to read up to }\n  // anyway, while in \"\\u00Z\" we will stop at Z instead of consuming four\n  // characters (and thus the closing quote).\n\n  readInt(\n    radix: number,\n    len?: number,\n    forceLen: boolean = false,\n    allowNumSeparator: boolean | \"bail\" = true,\n  ): number | null {\n    const { n, pos } = readInt(\n      this.input,\n      this.state.pos,\n      this.state.lineStart,\n      this.state.curLine,\n      radix,\n      len,\n      forceLen,\n      allowNumSeparator,\n      this.errorHandlers_readInt,\n      /* bailOnError */ false,\n    );\n    this.state.pos = pos;\n    return n;\n  }\n\n  readRadixNumber(radix: number): void {\n    const start = this.state.pos;\n    const startLoc = this.state.curPosition();\n    let isBigInt = false;\n\n    this.state.pos += 2; // 0x\n    const val = this.readInt(radix);\n    if (val == null) {\n      this.raise(\n        Errors.InvalidDigit,\n        // Numeric literals can't have newlines, so this is safe to do.\n        createPositionWithColumnOffset(startLoc, 2),\n        {\n          radix,\n        },\n      );\n    }\n    const next = this.input.charCodeAt(this.state.pos);\n\n    if (next === charCodes.lowercaseN) {\n      ++this.state.pos;\n      isBigInt = true;\n    } else if (next === charCodes.lowercaseM) {\n      throw this.raise(Errors.InvalidDecimal, startLoc);\n    }\n\n    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {\n      throw this.raise(Errors.NumberIdentifier, this.state.curPosition());\n    }\n\n    if (isBigInt) {\n      const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, \"\");\n      this.finishToken(tt.bigint, str);\n      return;\n    }\n\n    this.finishToken(tt.num, val);\n  }\n\n  // Read an integer, octal integer, or floating-point number.\n\n  readNumber(startsWithDot: boolean): void {\n    const start = this.state.pos;\n    const startLoc = this.state.curPosition();\n    let isFloat = false;\n    let isBigInt = false;\n    let hasExponent = false;\n    let isOctal = false;\n\n    if (!startsWithDot && this.readInt(10) === null) {\n      this.raise(Errors.InvalidNumber, this.state.curPosition());\n    }\n    const hasLeadingZero =\n      this.state.pos - start >= 2 &&\n      this.input.charCodeAt(start) === charCodes.digit0;\n\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        // disallow numeric separators in non octal decimals and legacy octal likes\n        const underscorePos = integer.indexOf(\"_\");\n        if (underscorePos > 0) {\n          // Numeric literals can't have newlines, so this is safe to do.\n          this.raise(\n            Errors.ZeroDigitNumericSeparator,\n            createPositionWithColumnOffset(startLoc, underscorePos),\n          );\n        }\n      }\n      isOctal = hasLeadingZero && !/[89]/.test(integer);\n    }\n\n    let next = this.input.charCodeAt(this.state.pos);\n    if (next === charCodes.dot && !isOctal) {\n      ++this.state.pos;\n      this.readInt(10);\n      isFloat = true;\n      next = this.input.charCodeAt(this.state.pos);\n    }\n\n    if (\n      (next === charCodes.uppercaseE || next === charCodes.lowercaseE) &&\n      !isOctal\n    ) {\n      next = this.input.charCodeAt(++this.state.pos);\n      if (next === charCodes.plusSign || next === charCodes.dash) {\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\n    if (next === charCodes.lowercaseN) {\n      // disallow floats, legacy octal syntax and non octal decimals\n      // new style octal (\"0o\") is handled in this.readRadixNumber\n      if (isFloat || hasLeadingZero) {\n        this.raise(Errors.InvalidBigIntLiteral, startLoc);\n      }\n      ++this.state.pos;\n      isBigInt = true;\n    }\n\n    if (!process.env.BABEL_8_BREAKING && next === charCodes.lowercaseM) {\n      this.expectPlugin(\"decimal\", this.state.curPosition());\n      if (hasExponent || hasLeadingZero) {\n        this.raise(Errors.InvalidDecimal, startLoc);\n      }\n      ++this.state.pos;\n      // eslint-disable-next-line no-var\n      var isDecimal = true;\n    }\n\n    if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {\n      throw this.raise(Errors.NumberIdentifier, this.state.curPosition());\n    }\n\n    // remove \"_\" for numeric literal separator, and trailing `m` or `n`\n    const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, \"\");\n\n    if (isBigInt) {\n      this.finishToken(tt.bigint, str);\n      return;\n    }\n\n    if (!process.env.BABEL_8_BREAKING && isDecimal) {\n      this.finishToken(tt.decimal, str);\n      return;\n    }\n\n    const val = isOctal ? parseInt(str, 8) : parseFloat(str);\n    this.finishToken(tt.num, val);\n  }\n\n  // Read a string value, interpreting backslash-escapes.\n\n  readCodePoint(throwOnInvalid: boolean): number | null {\n    const { code, pos } = readCodePoint(\n      this.input,\n      this.state.pos,\n      this.state.lineStart,\n      this.state.curLine,\n      throwOnInvalid,\n      this.errorHandlers_readCodePoint,\n    );\n    this.state.pos = pos;\n    return code;\n  }\n\n  readString(quote: number): void {\n    const { str, pos, curLine, lineStart } = readStringContents(\n      quote === charCodes.quotationMark ? \"double\" : \"single\",\n      this.input,\n      this.state.pos + 1, // skip the quote\n      this.state.lineStart,\n      this.state.curLine,\n      this.errorHandlers_readStringContents_string,\n    );\n    this.state.pos = pos + 1; // skip the quote\n    this.state.lineStart = lineStart;\n    this.state.curLine = curLine;\n    this.finishToken(tt.string, str);\n  }\n\n  // Reads template continuation `}...`\n  readTemplateContinuation(): void {\n    if (!this.match(tt.braceR)) {\n      this.unexpected(null, tt.braceR);\n    }\n    // rewind pos to `}`\n    this.state.pos--;\n    this.readTemplateToken();\n  }\n\n  // Reads template string tokens.\n  readTemplateToken(): void {\n    const opening = this.input[this.state.pos];\n    const { str, firstInvalidLoc, pos, curLine, lineStart } =\n      readStringContents(\n        \"template\",\n        this.input,\n        this.state.pos + 1, // skip '`' or `}`\n        this.state.lineStart,\n        this.state.curLine,\n        this.errorHandlers_readStringContents_template,\n      );\n    this.state.pos = pos + 1; // skip '`' or `$`\n    this.state.lineStart = lineStart;\n    this.state.curLine = curLine;\n\n    if (firstInvalidLoc) {\n      this.state.firstInvalidTemplateEscapePos = new Position(\n        firstInvalidLoc.curLine,\n        firstInvalidLoc.pos - firstInvalidLoc.lineStart,\n        this.sourceToOffsetPos(firstInvalidLoc.pos),\n      );\n    }\n\n    if (this.input.codePointAt(pos) === charCodes.graveAccent) {\n      this.finishToken(\n        tt.templateTail,\n        firstInvalidLoc ? null : opening + str + \"`\",\n      );\n    } else {\n      this.state.pos++; // skip '{'\n      this.finishToken(\n        tt.templateNonTail,\n        firstInvalidLoc ? null : opening + str + \"${\",\n      );\n    }\n  }\n\n  recordStrictModeErrors(toParseError: DeferredStrictError, at: Position) {\n    const index = at.index;\n\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\n  // Read an identifier, and return it as a string. Sets `this.state.containsEsc`\n  // to whether the word contained a '\\u' escape.\n  //\n  // Incrementally adds only escaped chars, adding other chunks as-is\n  // as a micro-optimization.\n  //\n  // When `firstCode` is given, it assumes it is always an identifier start and\n  // will skip reading start position again\n\n  readWord1(firstCode?: number): string {\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\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 === charCodes.backslash) {\n        this.state.containsEsc = true;\n\n        word += this.input.slice(chunkStart, this.state.pos);\n        const escStart = this.state.curPosition();\n        const identifierCheck =\n          this.state.pos === start ? isIdentifierStart : isIdentifierChar;\n\n        if (this.input.charCodeAt(++this.state.pos) !== charCodes.lowercaseU) {\n          this.raise(Errors.MissingUnicodeEscape, this.state.curPosition());\n          chunkStart = this.state.pos - 1;\n          continue;\n        }\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\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\n  // Read an identifier or keyword token. Will check for reserved\n  // words when necessary.\n\n  readWord(firstCode?: number): void {\n    const word = this.readWord1(firstCode);\n    const type = keywordTypes.get(word);\n    if (type !== undefined) {\n      // We don't use word as state.value here because word is a dynamic string\n      // while token label is a shared constant string\n      this.finishToken(type, tokenLabelName(type));\n    } else {\n      this.finishToken(tt.name, word);\n    }\n  }\n\n  checkKeywordEscapes(): void {\n    const { type } = 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\n  /**\n   * Raise a `ParseError` given the appropriate properties. If passed a\n   * `Position` for the `at` property, raises the `ParseError` at that location.\n   * Otherwise, if passed a `Node`, raises the `ParseError` at the start\n   * location of that `Node`.\n   *\n   * If `errorRecovery` is `true`, the error is pushed to the errors array and\n   * returned. If `errorRecovery` is `false`, the error is instead thrown.\n   *\n   * The return type is marked as `never` for simplicity, as error recovery\n   * will create types in an invalid AST shape.\n   */\n  raise<ErrorDetails = object>(\n    toParseError: ParseErrorConstructor<ErrorDetails>,\n    at: Position | Undone<Node>,\n    details: ErrorDetails = {} as ErrorDetails,\n  ): ParseError<ErrorDetails> {\n    const loc = at instanceof Position ? at : at.loc.start;\n    const error = toParseError(loc, details);\n\n    if (!(this.optionFlags & OptionFlags.ErrorRecovery)) throw error;\n    if (!this.isLookahead) this.state.errors.push(error);\n\n    return error;\n  }\n\n  /**\n   * If `errorRecovery` is `false`, this method behaves identically to `raise`.\n   * If `errorRecovery` is `true`, this method will first see if there is\n   * already an error stored at the same `Position`, and replaces it with the\n   * one generated here.\n   */\n  raiseOverwrite<ErrorDetails>(\n    toParseError: ParseErrorConstructor<ErrorDetails>,\n    at: Position | Undone<Node>,\n    details: ErrorDetails = {} as ErrorDetails,\n  ): ParseError<ErrorDetails> | never {\n    const loc = at instanceof Position ? at : at.loc.start;\n    const pos = loc.index;\n    const errors = this.state.errors;\n\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\n    return this.raise(toParseError, at, details);\n  }\n\n  // updateContext is used by the jsx plugin\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  updateContext(prevType: TokenType): void {}\n\n  // Raise an unexpected token error. Can take the expected token type.\n  unexpected(loc?: Position | null, type?: TokenType): void {\n    throw this.raise(\n      Errors.UnexpectedToken,\n      loc != null ? loc : this.state.startLoc,\n      {\n        expected: type ? tokenLabelName(type) : null,\n      },\n    );\n  }\n\n  expectPlugin(pluginName: Plugin, loc?: Position): true {\n    if (this.hasPlugin(pluginName)) {\n      return true;\n    }\n\n    throw this.raise(\n      Errors.MissingPlugin,\n      loc != null ? loc : this.state.startLoc,\n      {\n        missingPlugin: [pluginName],\n      },\n    );\n  }\n\n  expectOnePlugin(pluginNames: Plugin[]): void {\n    if (!pluginNames.some(name => this.hasPlugin(name))) {\n      throw this.raise(Errors.MissingOneOfPlugins, this.state.startLoc, {\n        missingPlugin: pluginNames,\n      });\n    }\n  }\n\n  errorBuilder(error: ParseErrorConstructor<object>) {\n    return (pos: number, lineStart: number, curLine: number) => {\n      this.raise(error, buildPosition(pos, lineStart, curLine));\n    };\n  }\n\n  errorHandlers_readInt: IntErrorHandlers = {\n    invalidDigit: (pos, lineStart, curLine, radix) => {\n      if (!(this.optionFlags & OptionFlags.ErrorRecovery)) return false;\n\n      this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), {\n        radix,\n      });\n      // Continue parsing the number as if there was no invalid digit.\n      return true;\n    },\n    numericSeparatorInEscapeSequence: this.errorBuilder(\n      Errors.NumericSeparatorInEscapeSequence,\n    ),\n    unexpectedNumericSeparator: this.errorBuilder(\n      Errors.UnexpectedNumericSeparator,\n    ),\n  };\n\n  errorHandlers_readCodePoint: CodePointErrorHandlers = {\n    ...this.errorHandlers_readInt,\n    invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),\n    invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint),\n  };\n\n  errorHandlers_readStringContents_string: StringContentsErrorHandlers = {\n    ...this.errorHandlers_readCodePoint,\n    strictNumericEscape: (pos, lineStart, curLine) => {\n      this.recordStrictModeErrors(\n        Errors.StrictNumericEscape,\n        buildPosition(pos, lineStart, curLine),\n      );\n    },\n    unterminated: (pos, lineStart, curLine) => {\n      throw this.raise(\n        Errors.UnterminatedString, // Report the error at the string quote\n        buildPosition(pos - 1, lineStart, curLine),\n      );\n    },\n  };\n\n  errorHandlers_readStringContents_template: StringContentsErrorHandlers = {\n    ...this.errorHandlers_readCodePoint,\n    strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),\n    unterminated: (pos, lineStart, curLine) => {\n      throw this.raise(\n        Errors.UnterminatedTemplate,\n        buildPosition(pos, lineStart, curLine),\n      );\n    },\n  };\n}\n","import { ClassElementType } from \"./scopeflags.ts\";\nimport type { Position } from \"./location.ts\";\nimport { Errors } from \"../parse-error.ts\";\nimport type Tokenizer from \"../tokenizer/index.ts\";\n\nexport class ClassScope {\n  // A list of private named declared in the current class\n  privateNames: Set<string> = new Set();\n\n  // A list of private getters of setters without their counterpart\n  loneAccessors: Map<string, ClassElementType> = new Map();\n\n  // A list of private names used before being defined, mapping to\n  // their position.\n  undefinedPrivateNames: Map<string, Position> = new Map();\n}\n\nexport default class ClassScopeHandler {\n  parser: Tokenizer;\n  stack: Array<ClassScope> = [];\n  undefinedPrivateNames: Map<string, Position> = new Map();\n\n  constructor(parser: Tokenizer) {\n    this.parser = parser;\n  }\n\n  current(): ClassScope {\n    return this.stack[this.stack.length - 1];\n  }\n\n  enter() {\n    this.stack.push(new ClassScope());\n  }\n\n  exit() {\n    const oldClassScope = this.stack.pop();\n\n    // Migrate the usage of not yet defined private names to the outer\n    // class scope, or raise an error if we reached the top-level scope.\n\n    const current = this.current();\n\n    // Array.from is needed because this is compiled to an array-like for loop\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\n  declarePrivateName(\n    name: string,\n    elementType: ClassElementType,\n    loc: Position,\n  ) {\n    const { privateNames, loneAccessors, undefinedPrivateNames } =\n      this.current();\n    let redefined = privateNames.has(name);\n\n    if (elementType & ClassElementType.KIND_ACCESSOR) {\n      const accessor = redefined && loneAccessors.get(name);\n      if (accessor) {\n        const oldStatic = accessor & ClassElementType.FLAG_STATIC;\n        const newStatic = elementType & ClassElementType.FLAG_STATIC;\n\n        const oldKind = accessor & ClassElementType.KIND_ACCESSOR;\n        const newKind = elementType & ClassElementType.KIND_ACCESSOR;\n\n        // The private name can be duplicated only if it is used by\n        // two accessors with different kind (get and set), and if\n        // they have the same placement (static or not).\n        redefined = oldKind === newKind || oldStatic !== newStatic;\n\n        if (!redefined) loneAccessors.delete(name);\n      } else if (!redefined) {\n        loneAccessors.set(name, elementType);\n      }\n    }\n\n    if (redefined) {\n      this.parser.raise(Errors.PrivateNameRedeclaration, loc, {\n        identifierName: name,\n      });\n    }\n\n    privateNames.add(name);\n    undefinedPrivateNames.delete(name);\n  }\n\n  usePrivateName(name: string, loc: Position) {\n    let classScope;\n    for (classScope of this.stack) {\n      if (classScope.privateNames.has(name)) return;\n    }\n\n    if (classScope) {\n      classScope.undefinedPrivateNames.set(name, loc);\n    } else {\n      // top-level\n      this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {\n        identifierName: name,\n      });\n    }\n  }\n}\n","import { Errors, type ParseErrorConstructor } from \"../parse-error.ts\";\nimport type { Position } from \"./location.ts\";\nimport type { Node } from \"../types.ts\";\nimport type Tokenizer from \"../tokenizer/index.ts\";\n\n/**\n * @module util/expression-scope\n\nExpressionScope is used to track declaration errors in these ambiguous patterns:\n\n- CoverParenthesizedExpressionAndArrowParameterList\n  e.g. we don't know if `({ x })` is an parenthesized expression or an\n  arrow function parameters until we see an `=>` after `)`.\n\n- CoverCallExpressionAndAsyncArrowHead\n  e.g. we don't know if `async({ x })` is a call expression or an async arrow\n  function parameters until we see an `=>` after `)`\n\nThe following declaration errors (@see parser-errors/standard) will be recorded in\nsome expression scopes and thrown later when we know what the ambiguous pattern is\n\n- AwaitBindingIdentifier\n- AwaitExpressionFormalParameter\n- YieldInParameter\n- InvalidParenthesizedAssignment when parenthesized is an identifier\n\nThere are four different expression scope\n- Expression\n  A general scope that represents program / function body / static block. No errors\n  will be recorded nor thrown in this scope.\n\n- MaybeArrowParameterDeclaration\n  A scope that represents ambiguous arrow head e.g. `(x)`. Errors will be recorded\n  alongside parent scopes and thrown when `ExpressionScopeHandler#validateAsPattern`\n  is called.\n\n- MaybeAsyncArrowParameterDeclaration\n  A scope that represents ambiguous async arrow head e.g. `async(x)`. Errors will\n  be recorded alongside parent scopes and thrown when\n  `ExpressionScopeHandler#validateAsPattern` is called.\n\n- ParameterDeclaration\n  A scope that represents unambiguous function parameters `function(x)`. Errors\n  recorded in this scope will be thrown immediately. No errors will be recorded in\n  this scope.\n\n// @see {@link https://docs.google.com/document/d/1FAvEp9EUK-G8kHfDIEo_385Hs2SUBCYbJ5H-NnLvq8M|V8 Expression Scope design docs}\n */\n\nconst enum ExpressionScopeType {\n  kExpression = 0,\n  kMaybeArrowParameterDeclaration = 1,\n  kMaybeAsyncArrowParameterDeclaration = 2,\n  kParameterDeclaration = 3,\n}\n\nclass ExpressionScope {\n  declare type: ExpressionScopeType;\n\n  constructor(type: ExpressionScopeType = ExpressionScopeType.kExpression) {\n    this.type = type;\n  }\n\n  canBeArrowParameterDeclaration(): this is ArrowHeadParsingScope {\n    return (\n      this.type === ExpressionScopeType.kMaybeAsyncArrowParameterDeclaration ||\n      this.type === ExpressionScopeType.kMaybeArrowParameterDeclaration\n    );\n  }\n\n  isCertainlyParameterDeclaration() {\n    return this.type === ExpressionScopeType.kParameterDeclaration;\n  }\n}\n\ntype ArrowHeadParsingParameterInitializerError =\n  | typeof Errors.AwaitExpressionFormalParameter\n  | typeof Errors.YieldInParameter;\ntype ArrowHeadParsingDeclarationError =\n  | ArrowHeadParsingParameterInitializerError\n  | typeof Errors.InvalidParenthesizedAssignment\n  | typeof Errors.AwaitBindingIdentifier;\n\nclass ArrowHeadParsingScope extends ExpressionScope {\n  declarationErrors: Map<number, [ParseErrorConstructor<object>, Position]> =\n    new Map();\n  constructor(\n    type:\n      | ExpressionScopeType.kMaybeArrowParameterDeclaration\n      | ExpressionScopeType.kMaybeAsyncArrowParameterDeclaration,\n  ) {\n    super(type);\n  }\n  recordDeclarationError(\n    ParsingErrorClass: ParseErrorConstructor<object>,\n    at: Position,\n  ) {\n    const index = at.index;\n\n    this.declarationErrors.set(index, [ParsingErrorClass, at]);\n  }\n  clearDeclarationError(index: number) {\n    this.declarationErrors.delete(index);\n  }\n  iterateErrors(\n    iterator: (a: [ArrowHeadParsingDeclarationError, Position]) => void,\n  ) {\n    this.declarationErrors.forEach(iterator);\n  }\n}\n\nexport default class ExpressionScopeHandler {\n  parser: Tokenizer;\n  stack: Array<ExpressionScope> = [new ExpressionScope()];\n\n  constructor(parser: Tokenizer) {\n    this.parser = parser;\n  }\n  enter(scope: ExpressionScope) {\n    this.stack.push(scope);\n  }\n\n  exit() {\n    this.stack.pop();\n  }\n\n  /**\n   * Record likely parameter initializer errors\n   *\n   * When current scope is a ParameterDeclaration, the error will be thrown immediately,\n   * otherwise it will be recorded to any ancestry MaybeArrowParameterDeclaration and\n   * MaybeAsyncArrowParameterDeclaration scope until an Expression scope is seen.\n   */\n  recordParameterInitializerError(\n    toParseError: ArrowHeadParsingParameterInitializerError,\n    node: Node,\n  ): void {\n    const origin = node.loc.start;\n    const { stack } = this;\n    let i = stack.length - 1;\n    let scope: ExpressionScope = stack[i];\n    while (!scope.isCertainlyParameterDeclaration()) {\n      if (scope.canBeArrowParameterDeclaration()) {\n        scope.recordDeclarationError(toParseError, origin);\n      } else {\n        /*:: invariant(scope.type == ExpressionScopeType.kExpression) */\n        // Type-Expression is the boundary where initializer error can populate to\n        return;\n      }\n      scope = stack[--i];\n    }\n    this.parser.raise(toParseError, origin);\n  }\n\n  /**\n   * Record errors that must be thrown if the current pattern ends up being an arrow\n   * function parameter. This is used to record parenthesized identifiers, and to record\n   * \"a as T\" and \"<T> a\" type assertions when parsing typescript.\n   *\n   * A parenthesized identifier (or type assertion) in LHS can be ambiguous because the assignment\n   * can be transformed to an assignable later, but not vice versa:\n   * For example, in `([(a) = []] = []) => {}`, we think `(a) = []` is an LHS in `[(a) = []]`,\n   * an LHS within `[(a) = []] = []`. However the LHS chain is then transformed by toAssignable,\n   * and we should throw assignment `(a)`, which is only valid in LHS. Hence we record the\n   * location of parenthesized `(a)` to current scope if it is one of MaybeArrowParameterDeclaration\n   * and MaybeAsyncArrowParameterDeclaration\n   *\n   * Unlike `recordParameterInitializerError`, we don't record to ancestry scope because we\n   * validate arrow head parsing scope before exit, and then the LHS will be unambiguous:\n   * For example, in `( x = ( [(a) = []] = [] ) ) => {}`, we should not record `(a)` in `( x = ... ) =>`\n   * arrow scope because when we finish parsing `( [(a) = []] = [] )`, it is an unambiguous assignment\n   * expression and can not be cast to pattern\n   */\n  recordArrowParameterBindingError(\n    error: ParseErrorConstructor<object>,\n    node: Node,\n  ): void {\n    const { stack } = this;\n    const scope: ExpressionScope = 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\n  /**\n   * Record likely async arrow parameter errors\n   *\n   * Errors will be recorded to any ancestry MaybeAsyncArrowParameterDeclaration\n   * scope until an Expression scope is seen.\n   */\n  recordAsyncArrowParametersError(at: Position): void {\n    const { stack } = this;\n    let i = stack.length - 1;\n    let scope: ExpressionScope = stack[i];\n    while (scope.canBeArrowParameterDeclaration()) {\n      if (\n        scope.type === ExpressionScopeType.kMaybeAsyncArrowParameterDeclaration\n      ) {\n        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at);\n      }\n      scope = stack[--i];\n    }\n  }\n\n  validateAsPattern(): void {\n    const { stack } = 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      // iterate from parent scope\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}\n\nexport function newParameterDeclarationScope() {\n  return new ExpressionScope(ExpressionScopeType.kParameterDeclaration);\n}\n\nexport function newArrowHeadScope() {\n  return new ArrowHeadParsingScope(\n    ExpressionScopeType.kMaybeArrowParameterDeclaration,\n  );\n}\n\nexport function newAsyncArrowScope() {\n  return new ArrowHeadParsingScope(\n    ExpressionScopeType.kMaybeAsyncArrowParameterDeclaration,\n  );\n}\n\nexport function newExpressionScope() {\n  return new ExpressionScope();\n}\n","// ProductionParameterHandler is a stack fashioned production parameter tracker\n// https://tc39.es/ecma262/#sec-grammar-notation\n// The tracked parameters are defined above.\n//\n// Whenever [+Await]/[+Yield] appears in the right-hand sides of a production,\n// we must enter a new tracking stack. For example when parsing\n//\n// AsyncFunctionDeclaration [Yield, Await]:\n//   async [no LineTerminator here] function BindingIdentifier[?Yield, ?Await]\n//     ( FormalParameters[~Yield, +Await] ) { AsyncFunctionBody }\n//\n// we must follow such process:\n//\n// 1. parse async keyword\n// 2. parse function keyword\n// 3. parse bindingIdentifier <= inherit current parameters: [?Await]\n// 4. enter new stack with (PARAM_AWAIT)\n// 5. parse formal parameters <= must have [Await] parameter [+Await]\n// 6. parse function body\n// 7. exit current stack\n\nexport const enum ParamKind {\n  // Initial Parameter flags\n  PARAM = 0b0000,\n  // track [Yield] production parameter\n  PARAM_YIELD = 0b0001,\n  // track [Await] production parameter\n  PARAM_AWAIT = 0b0010,\n  // track [Return] production parameter\n  PARAM_RETURN = 0b0100,\n  // track [In] production parameter\n  PARAM_IN = 0b1000,\n}\n\n// todo(flow->ts) - check if more granular type can be used,\n//  type below is not good because things like PARAM_AWAIT|PARAM_YIELD are not included\n// export type ParamKind =\n//   | typeof PARAM\n//   | typeof PARAM_AWAIT\n//   | typeof PARAM_IN\n//   | typeof PARAM_RETURN\n//   | typeof PARAM_YIELD;\n\nexport default class ProductionParameterHandler {\n  stacks: Array<ParamKind> = [];\n  enter(flags: ParamKind) {\n    this.stacks.push(flags);\n  }\n\n  exit() {\n    this.stacks.pop();\n  }\n\n  currentFlags(): ParamKind {\n    return this.stacks[this.stacks.length - 1];\n  }\n\n  get hasAwait(): boolean {\n    return (this.currentFlags() & ParamKind.PARAM_AWAIT) > 0;\n  }\n\n  get hasYield(): boolean {\n    return (this.currentFlags() & ParamKind.PARAM_YIELD) > 0;\n  }\n\n  get hasReturn(): boolean {\n    return (this.currentFlags() & ParamKind.PARAM_RETURN) > 0;\n  }\n\n  get hasIn(): boolean {\n    return (this.currentFlags() & ParamKind.PARAM_IN) > 0;\n  }\n}\n\nexport function functionFlags(\n  isAsync: boolean,\n  isGenerator: boolean,\n): ParamKind {\n  return (\n    (isAsync ? ParamKind.PARAM_AWAIT : 0) |\n    (isGenerator ? ParamKind.PARAM_YIELD : 0)\n  );\n}\n","import type { Position } from \"../util/location.ts\";\nimport {\n  tokenIsLiteralPropertyName,\n  tt,\n  type TokenType,\n} from \"../tokenizer/types.ts\";\nimport Tokenizer from \"../tokenizer/index.ts\";\nimport type State from \"../tokenizer/state.ts\";\nimport type {\n  EstreePropertyDefinition,\n  Node,\n  ObjectMethod,\n  ObjectProperty,\n  PrivateName,\n} from \"../types.d.ts\";\nimport { hasNewLine } from \"../util/whitespace.ts\";\nimport { isIdentifierChar } from \"../util/identifier.ts\";\nimport ClassScopeHandler from \"../util/class-scope.ts\";\nimport ExpressionScopeHandler from \"../util/expression-scope.ts\";\nimport { ScopeFlag } from \"../util/scopeflags.ts\";\nimport ProductionParameterHandler, {\n  ParamKind,\n} from \"../util/production-parameter.ts\";\nimport {\n  Errors,\n  type ParseError,\n  type ParseErrorConstructor,\n} from \"../parse-error.ts\";\nimport type Parser from \"./index.ts\";\n\nimport type ScopeHandler from \"../util/scope.ts\";\n\ntype TryParse<Node, Error, Thrown, Aborted, FailState> = {\n  node: Node;\n  error: Error;\n  thrown: Thrown;\n  aborted: Aborted;\n  failState: FailState;\n};\n\n// ## Parser utilities\n\nexport default abstract class UtilParser extends Tokenizer {\n  // Forward-declaration: defined in parser/index.js\n  abstract getScopeHandler(): new (...args: any) => ScopeHandler;\n\n  addExtra(\n    node: Partial<Node>,\n    key: string,\n    value: any,\n    enumerable: boolean = true,\n  ): void {\n    if (!node) return;\n\n    let { extra } = node;\n    if (extra == null) {\n      extra = {};\n      node.extra = extra;\n    }\n\n    if (enumerable) {\n      extra[key] = value;\n    } else {\n      Object.defineProperty(extra, key, { enumerable, value });\n    }\n  }\n\n  // Tests whether parsed token is a contextual keyword.\n\n  isContextual(token: TokenType): boolean {\n    return this.state.type === token && !this.state.containsEsc;\n  }\n\n  isUnparsedContextual(nameStart: number, name: string): boolean {\n    const nameEnd = nameStart + name.length;\n    if (this.input.slice(nameStart, nameEnd) === name) {\n      const nextCh = this.input.charCodeAt(nameEnd);\n      return !(\n        isIdentifierChar(nextCh) ||\n        // check if `nextCh is between 0xd800 - 0xdbff,\n        // if `nextCh` is NaN, `NaN & 0xfc00` is 0, the function\n        // returns true\n        (nextCh & 0xfc00) === 0xd800\n      );\n    }\n    return false;\n  }\n\n  isLookaheadContextual(name: string): boolean {\n    const next = this.nextTokenStart();\n    return this.isUnparsedContextual(next, name);\n  }\n\n  // Consumes contextual keyword if possible.\n\n  eatContextual(token: TokenType): boolean {\n    if (this.isContextual(token)) {\n      this.next();\n      return true;\n    }\n    return false;\n  }\n\n  // Asserts that following token is given contextual keyword.\n\n  expectContextual(\n    token: TokenType,\n    toParseError?: ParseErrorConstructor<any>,\n  ): void {\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\n  // Test whether a semicolon can be inserted at the current position.\n\n  canInsertSemicolon(): boolean {\n    return (\n      this.match(tt.eof) ||\n      this.match(tt.braceR) ||\n      this.hasPrecedingLineBreak()\n    );\n  }\n\n  hasPrecedingLineBreak(): boolean {\n    return hasNewLine(\n      this.input,\n      this.offsetToSourcePos(this.state.lastTokEndLoc.index),\n      this.state.start,\n    );\n  }\n\n  hasFollowingLineBreak(): boolean {\n    return hasNewLine(this.input, this.state.end, this.nextTokenStart());\n  }\n\n  isLineTerminator(): boolean {\n    return this.eat(tt.semi) || this.canInsertSemicolon();\n  }\n\n  // Consume a semicolon, or, failing that, see if we are allowed to\n  // pretend that there is a semicolon at this position.\n\n  semicolon(allowAsi: boolean = true): void {\n    if (allowAsi ? this.isLineTerminator() : this.eat(tt.semi)) return;\n    this.raise(Errors.MissingSemicolon, this.state.lastTokEndLoc);\n  }\n\n  // Expect a token of a given type. If found, consume it, otherwise,\n  // raise an unexpected token error at given pos.\n\n  expect(type: TokenType, loc?: Position | null): void {\n    if (!this.eat(type)) {\n      this.unexpected(loc, type);\n    }\n  }\n\n  // tryParse will clone parser state.\n  // It is expensive and should be used with cautions\n  tryParse<T extends Node | ReadonlyArray<Node>>(\n    fn: (abort: (node?: T) => never) => T,\n    oldState: State = this.state.clone(),\n  ):\n    | TryParse<T, null, false, false, null>\n    | TryParse<T | null, ParseError<any>, boolean, false, State>\n    | TryParse<T | null, null, false, true, State> {\n    const abortSignal: {\n      node: T | null;\n    } = { node: null };\n    try {\n      const node = fn((node = null) => {\n        abortSignal.node = node;\n        // eslint-disable-next-line @typescript-eslint/only-throw-error\n        throw abortSignal;\n      });\n      if (this.state.errors.length > oldState.errors.length) {\n        const failState = this.state;\n        this.state = oldState;\n        // tokensLength should be preserved during error recovery mode\n        // since the parser does not halt and will instead parse the\n        // remaining tokens\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\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        // @ts-expect-error casting general syntax error to parse error\n        return { node: null, error, thrown: true, aborted: false, failState };\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\n      throw error;\n    }\n  }\n\n  checkExpressionErrors(\n    refExpressionErrors: ExpressionErrors | undefined | null,\n    andThrow: boolean,\n  ) {\n    if (!refExpressionErrors) return false;\n    const {\n      shorthandAssignLoc,\n      doubleProtoLoc,\n      privateKeyLoc,\n      optionalParametersLoc,\n    } = refExpressionErrors;\n\n    const hasErrors =\n      !!shorthandAssignLoc ||\n      !!doubleProtoLoc ||\n      !!optionalParametersLoc ||\n      !!privateKeyLoc;\n\n    if (!andThrow) {\n      return hasErrors;\n    }\n\n    if (shorthandAssignLoc != null) {\n      this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);\n    }\n\n    if (doubleProtoLoc != null) {\n      this.raise(Errors.DuplicateProto, doubleProtoLoc);\n    }\n\n    if (privateKeyLoc != null) {\n      this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);\n    }\n\n    if (optionalParametersLoc != null) {\n      this.unexpected(optionalParametersLoc);\n    }\n  }\n\n  /**\n   * Test if current token is a literal property name\n   * https://tc39.es/ecma262/#prod-LiteralPropertyName\n   * LiteralPropertyName:\n   *   IdentifierName\n   *   StringLiteral\n   *   NumericLiteral\n   *   BigIntLiteral\n   */\n  isLiteralPropertyName(): boolean {\n    return tokenIsLiteralPropertyName(this.state.type);\n  }\n\n  /**\n   * Test if given node is a PrivateName\n   * will be overridden in ESTree plugin\n   */\n  isPrivateName(node: Node): node is PrivateName {\n    return node.type === \"PrivateName\";\n  }\n\n  /**\n   * Return the string value of a given private name\n   * WITHOUT `#`\n   * @see {@link https://tc39.es/ecma262/#sec-static-semantics-stringvalue}\n   */\n  getPrivateNameSV(node: PrivateName): string {\n    return node.id.name;\n  }\n\n  /**\n   * Return whether the given node is a member/optional chain that\n   * contains a private name as its property\n   * It is overridden in ESTree plugin\n   */\n  hasPropertyAsPrivateName(node: Node): boolean {\n    return (\n      (node.type === \"MemberExpression\" ||\n        node.type === \"OptionalMemberExpression\") &&\n      this.isPrivateName(node.property)\n    );\n  }\n\n  isObjectProperty(\n    node: Node,\n  ): node is ObjectProperty | EstreePropertyDefinition {\n    return node.type === \"ObjectProperty\";\n  }\n\n  isObjectMethod(node: Node): node is ObjectMethod {\n    return node.type === \"ObjectMethod\";\n  }\n\n  initializeScopes(\n    this: Parser,\n    inModule: boolean = this.options.sourceType === \"module\",\n  ): () => void {\n    // Initialize state\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n\n    const oldExportedIdentifiers = this.exportedIdentifiers;\n    this.exportedIdentifiers = new Set();\n\n    // initialize scopes\n    const oldInModule = this.inModule;\n    this.inModule = inModule;\n\n    const oldScope = this.scope;\n    const ScopeHandler = this.getScopeHandler();\n    this.scope = new ScopeHandler(this, inModule);\n\n    const oldProdParam = this.prodParam;\n    this.prodParam = new ProductionParameterHandler();\n\n    const oldClassScope = this.classScope;\n    this.classScope = new ClassScopeHandler(this);\n\n    const oldExpressionScope = this.expressionScope;\n    this.expressionScope = new ExpressionScopeHandler(this);\n\n    return () => {\n      // Revert state\n      this.state.labels = oldLabels;\n      this.exportedIdentifiers = oldExportedIdentifiers;\n\n      // Revert scopes\n      this.inModule = oldInModule;\n      this.scope = oldScope;\n      this.prodParam = oldProdParam;\n      this.classScope = oldClassScope;\n      this.expressionScope = oldExpressionScope;\n    };\n  }\n\n  enterInitialScopes() {\n    let paramFlags = ParamKind.PARAM;\n    if (this.inModule) {\n      paramFlags |= ParamKind.PARAM_AWAIT;\n    }\n    this.scope.enter(ScopeFlag.PROGRAM);\n    this.prodParam.enter(paramFlags);\n  }\n\n  checkDestructuringPrivate(refExpressionErrors: ExpressionErrors) {\n    const { privateKeyLoc } = refExpressionErrors;\n    if (privateKeyLoc !== null) {\n      this.expectPlugin(\"destructuringPrivate\", privateKeyLoc);\n    }\n  }\n}\n\n/**\n * The ExpressionErrors is a context struct used to track ambiguous patterns\n * When we are sure the parsed pattern is a RHS, which means it is not a pattern,\n * we will throw on this position on invalid assign syntax, otherwise it will be reset to -1\n *\n * Types of ExpressionErrors:\n *\n * - **shorthandAssignLoc**: track initializer `=` position\n * - **doubleProtoLoc**: track the duplicate `__proto__` key position\n * - **privateKey**: track private key `#p` position\n * - **optionalParametersLoc**: track the optional parameter (`?`).\n * It's only used by typescript and flow plugins\n */\nexport class ExpressionErrors {\n  shorthandAssignLoc: Position | undefined | null = null;\n  doubleProtoLoc: Position | undefined | null = null;\n  privateKeyLoc: Position | undefined | null = null;\n  optionalParametersLoc: Position | undefined | null = null;\n}\n","import UtilParser from \"./util.ts\";\nimport { SourceLocation, type Position } from \"../util/location.ts\";\nimport type { Comment, Node as NodeType, NodeBase } from \"../types.ts\";\nimport { OptionFlags } from \"../options.ts\";\n\n// Start an AST node, attaching a start offset.\n\nclass Node implements NodeBase {\n  constructor(parser: UtilParser, pos: number, loc: Position) {\n    this.start = pos;\n    this.end = 0;\n    this.loc = new SourceLocation(loc);\n    if (parser?.optionFlags & OptionFlags.Ranges) this.range = [pos, 0];\n    if (parser?.filename) this.loc.filename = parser.filename;\n  }\n\n  type: string = \"\";\n  declare start: number;\n  declare end: number;\n  declare loc: SourceLocation;\n  declare range: [number, number];\n  declare leadingComments: Array<Comment>;\n  declare trailingComments: Array<Comment>;\n  declare innerComments: Array<Comment>;\n  declare extra: {\n    [key: string]: any;\n  };\n}\nconst NodePrototype = Node.prototype;\n\nif (!process.env.BABEL_8_BREAKING) {\n  // @ts-expect-error __clone is not defined in Node prototype\n  NodePrototype.__clone = function (): Node {\n    const newNode = new Node(undefined, this.start, this.loc.start);\n    const keys = Object.keys(this) as (keyof Node)[];\n    for (let i = 0, length = keys.length; i < length; i++) {\n      const key = keys[i];\n      // Do not clone comments that are already attached to the node\n      if (\n        key !== \"leadingComments\" &&\n        key !== \"trailingComments\" &&\n        key !== \"innerComments\"\n      ) {\n        // @ts-expect-error cloning this to newNode\n        newNode[key] = this[key];\n      }\n    }\n\n    return newNode;\n  };\n}\n\nfunction clonePlaceholder(node: any): any {\n  return cloneIdentifier(node);\n}\n\nexport function cloneIdentifier(node: any): any {\n  // We don't need to clone `typeAnnotations` and `optional`: because\n  // cloneIdentifier is only used in object shorthand and named import/export.\n  // Neither of them allow type annotations after the identifier or optional identifier\n  const { type, start, end, loc, range, extra, name } = 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}\n\nexport function cloneStringLiteral(node: any): any {\n  const { type, start, end, loc, range, extra } = 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    // estree set node.raw instead of node.extra\n    cloned.raw = node.raw;\n  } else {\n    cloned.extra = extra;\n  }\n  cloned.value = node.value;\n  return cloned;\n}\n\nexport type Undone<T extends NodeType> = Omit<T, \"type\">;\n\nexport abstract class NodeUtils extends UtilParser {\n  startNode<T extends NodeType = never>(): Undone<T> {\n    const loc = this.state.startLoc;\n    return new Node(this, loc.index, loc) as unknown as Undone<T>;\n  }\n\n  startNodeAt<T extends NodeType = never>(loc: Position): Undone<T> {\n    return new Node(this, loc.index, loc) as unknown as Undone<T>;\n  }\n\n  /** Start a new node with a previous node's location. */\n  startNodeAtNode<T extends NodeType = never>(\n    type: Undone<NodeType>,\n  ): Undone<T> {\n    return this.startNodeAt(type.loc.start);\n  }\n\n  // Finish an AST node, adding `type` and `end` properties.\n\n  finishNode<T extends NodeType>(node: Undone<T>, type: T[\"type\"]): T {\n    return this.finishNodeAt(node, type, this.state.lastTokEndLoc);\n  }\n\n  // Finish node at given position\n\n  finishNodeAt<T extends NodeType>(\n    node: Omit<T, \"type\">,\n    type: T[\"type\"],\n    endLoc: Position,\n  ): T {\n    if (process.env.NODE_ENV !== \"production\" && node.end > 0) {\n      throw new Error(\n        \"Do not call finishNode*() twice on the same node.\" +\n          \" Instead use resetEndLocation() or change type directly.\",\n      );\n    }\n    (node as T).type = type;\n    node.end = endLoc.index;\n    node.loc.end = endLoc;\n    if (this.optionFlags & OptionFlags.Ranges) node.range[1] = endLoc.index;\n    if (this.optionFlags & OptionFlags.AttachComment) {\n      this.processComment(node as T);\n    }\n    return node as T;\n  }\n\n  resetStartLocation(node: NodeBase, startLoc: Position): void {\n    node.start = startLoc.index;\n    node.loc.start = startLoc;\n    if (this.optionFlags & OptionFlags.Ranges) node.range[0] = startLoc.index;\n  }\n\n  resetEndLocation(\n    node: NodeBase,\n    endLoc: Position = this.state.lastTokEndLoc,\n  ): void {\n    node.end = endLoc.index;\n    node.loc.end = endLoc;\n    if (this.optionFlags & OptionFlags.Ranges) node.range[1] = endLoc.index;\n  }\n\n  /**\n   * Reset the start location of node to the start location of locationNode\n   */\n  resetStartLocationFromNode(node: NodeBase, locationNode: NodeBase): void {\n    this.resetStartLocation(node, locationNode.loc.start);\n  }\n}\n","/*:: declare var invariant; */\n\nimport type Parser from \"../../parser/index.ts\";\nimport {\n  tokenIsIdentifier,\n  tokenIsKeyword,\n  tokenIsKeywordOrIdentifier,\n  tokenIsLiteralPropertyName,\n  tokenLabelName,\n  tt,\n  type TokenType,\n  tokenIsFlowInterfaceOrTypeOrOpaque,\n} from \"../../tokenizer/types.ts\";\nimport type * as N from \"../../types.ts\";\nimport type { Position } from \"../../util/location.ts\";\nimport { types as tc } from \"../../tokenizer/context.ts\";\nimport * as charCodes from \"charcodes\";\nimport { isIteratorStart } from \"../../util/identifier.ts\";\nimport FlowScopeHandler from \"./scope.ts\";\nimport { BindingFlag, ScopeFlag } from \"../../util/scopeflags.ts\";\nimport type { ExpressionErrors } from \"../../parser/util.ts\";\nimport type { ParseStatementFlag } from \"../../parser/statement.ts\";\nimport { Errors, ParseErrorEnum } from \"../../parse-error.ts\";\nimport { cloneIdentifier, type Undone } from \"../../parser/node.ts\";\nimport type { ClassWithMixin, IJSXParserMixin } from \"../jsx/index.ts\";\n\nconst reservedTypes = new Set([\n  \"_\",\n  \"any\",\n  \"bool\",\n  \"boolean\",\n  \"empty\",\n  \"extends\",\n  \"false\",\n  \"interface\",\n  \"mixed\",\n  \"null\",\n  \"number\",\n  \"static\",\n  \"string\",\n  \"true\",\n  \"typeof\",\n  \"void\",\n]);\n\n/* eslint sort-keys: \"error\" */\n// The Errors key follows https://github.com/facebook/flow/blob/master/src/parser/parse_error.ml unless it does not exist\nconst FlowErrors = ParseErrorEnum`flow`({\n  AmbiguousConditionalArrow:\n    \"Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.\",\n  AmbiguousDeclareModuleKind:\n    \"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  // TODO: When we get proper string enums in typescript make this ReservedType.\n  // Not really worth it to do the whole $Values dance with reservedTypes set.\n  AssignReservedType: ({ reservedType }: { reservedType: string }) =>\n    `Cannot overwrite reserved type ${reservedType}.`,\n  DeclareClassElement:\n    \"The `declare` modifier can only appear on class fields.\",\n  DeclareClassFieldInitializer:\n    \"Initializers are not allowed in fields with the `declare` modifier.\",\n  DuplicateDeclareModuleExports:\n    \"Duplicate `declare module.exports` statement.\",\n  EnumBooleanMemberNotInitialized: ({\n    memberName,\n    enumName,\n  }: {\n    memberName: string;\n    enumName: string;\n  }) =>\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  }: {\n    memberName: string;\n    enumName: string;\n  }) =>\n    `Enum member names need to be unique, but the name \\`${memberName}\\` has already been used before in enum \\`${enumName}\\`.`,\n  EnumInconsistentMemberValues: ({ enumName }: { enumName: string }) =>\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  }: {\n    invalidEnumType: string;\n    enumName: string;\n  }) =>\n    `Enum type \\`${invalidEnumType}\\` is not valid. Use one of \\`boolean\\`, \\`number\\`, \\`string\\`, or \\`symbol\\` in enum \\`${enumName}\\`.`,\n  EnumInvalidExplicitTypeUnknownSupplied: ({\n    enumName,\n  }: {\n    enumName: string;\n  }) =>\n    `Supplied enum type is not valid. Use one of \\`boolean\\`, \\`number\\`, \\`string\\`, or \\`symbol\\` in enum \\`${enumName}\\`.`,\n\n  // TODO: When moving to typescript, we should either have each of the\n  // following errors only accept the specific strings they want:\n  //\n  // ...PrimaryType: explicitType: \"string\" | \"number\" | \"boolean\"\n  // ...SymbolType: explicitType: \"symbol\"\n  // ...UnknownType: explicitType: null\n  //\n  // Or, alternatively, merge these three errors together into one\n  // `EnumInvalidMemberInitializer` error that can accept `EnumExplicitType`\n  // without alteration, and then just have its message change based on the\n  // explicitType.\n  EnumInvalidMemberInitializerPrimaryType: ({\n    enumName,\n    memberName,\n    explicitType,\n  }: {\n    enumName: string;\n    memberName: string;\n    explicitType: EnumExplicitType;\n  }) =>\n    `Enum \\`${enumName}\\` has type \\`${explicitType}\\`, so the initializer of \\`${memberName}\\` needs to be a ${explicitType} literal.`,\n  EnumInvalidMemberInitializerSymbolType: ({\n    enumName,\n    memberName,\n  }: {\n    enumName: string;\n    memberName: string;\n    explicitType: EnumExplicitType;\n  }) =>\n    `Symbol enum members cannot be initialized. Use \\`${memberName},\\` in enum \\`${enumName}\\`.`,\n  EnumInvalidMemberInitializerUnknownType: ({\n    enumName,\n    memberName,\n  }: {\n    enumName: string;\n    memberName: string;\n    explicitType: EnumExplicitType;\n  }) =>\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  }: {\n    enumName: string;\n    memberName: string;\n    suggestion: string;\n  }) =>\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  }: {\n    enumName: string;\n    memberName: string;\n  }) =>\n    `Number enum members need to be initialized, e.g. \\`${memberName} = 1\\` in enum \\`${enumName}\\`.`,\n  EnumStringMemberInconsistentlyInitialized: ({\n    enumName,\n  }: {\n    enumName: string;\n  }) =>\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:\n    \"An `import module` declaration can not use `type` or `typeof` keyword.\",\n  ImportTypeShorthandOnlyInPureImport:\n    \"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:\n    \"Explicit inexact syntax cannot appear inside an explicit exact object type.\",\n  InexactInsideNonObject:\n    \"Explicit inexact syntax cannot appear in class or interface definitions.\",\n  InexactVariance: \"Explicit inexact syntax cannot have variance.\",\n  InvalidNonTypeImportInDeclareModule:\n    \"Imports within a `declare module` body must always be `import type` or `import typeof`.\",\n  MissingTypeParamDefault:\n    \"Type parameter declaration needs a default, since a preceding type parameter declaration has a default.\",\n  NestedDeclareModule:\n    \"`declare module` cannot be used inside another `declare module`.\",\n  NestedFlowComment: \"Cannot have a flow comment inside another flow comment.\",\n  PatternIsOptional: {\n    message:\n      \"A binding pattern parameter cannot be optional in an implementation signature.\",\n    // For consistency in TypeScript and Flow error codes\n    ...(!process.env.BABEL_8_BREAKING\n      ? { reasonCode: \"OptionalBindingPattern\" }\n      : {}),\n  },\n  SetterMayNotHaveThisParam: \"A setter cannot have a `this` parameter.\",\n  SpreadVariance: \"Spread properties cannot have variance.\",\n  ThisParamAnnotationRequired:\n    \"A type annotation is required for the `this` parameter.\",\n  ThisParamBannedInConstructor:\n    \"Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.\",\n  ThisParamMayNotBeOptional: \"The `this` parameter cannot be optional.\",\n  ThisParamMustBeFirst:\n    \"The `this` parameter must be the first function parameter.\",\n  ThisParamNoDefault: \"The `this` parameter may not have a default value.\",\n  TypeBeforeInitializer:\n    \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.\",\n  TypeCastInPattern:\n    \"The type cast expression is expected to be wrapped with parenthesis.\",\n  UnexpectedExplicitInexactInObject:\n    \"Explicit inexact syntax must appear at the end of an inexact object.\",\n  UnexpectedReservedType: ({ reservedType }: { reservedType: string }) =>\n    `Unexpected reserved type ${reservedType}.`,\n  UnexpectedReservedUnderscore:\n    \"`_` is only allowed as a type argument to call or new.\",\n  UnexpectedSpaceBetweenModuloChecks:\n    \"Spaces between `%` and `checks` are not allowed here.\",\n  UnexpectedSpreadType:\n    \"Spread operator cannot appear in class or interface definitions.\",\n  UnexpectedSubtractionOperand:\n    'Unexpected token, expected \"number\" or \"bigint\".',\n  UnexpectedTokenAfterTypeParameter:\n    \"Expected an arrow function after this type parameter declaration.\",\n  UnexpectedTypeParameterBeforeAsyncArrowFunction:\n    \"Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.\",\n  UnsupportedDeclareExportKind: ({\n    unsupportedExportKind,\n    suggestion,\n  }: {\n    unsupportedExportKind: string;\n    suggestion: string;\n  }) =>\n    `\\`declare export ${unsupportedExportKind}\\` is not supported. Use \\`${suggestion}\\` instead.`,\n  UnsupportedStatementInDeclareModule:\n    \"Only declares and type imports are allowed inside declare module.\",\n  UnterminatedFlowComment: \"Unterminated flow-comment.\",\n});\n/* eslint-disable sort-keys */\n\nfunction isEsModuleType(bodyElement: N.Node): boolean {\n  return (\n    bodyElement.type === \"DeclareExportAllDeclaration\" ||\n    (bodyElement.type === \"DeclareExportDeclaration\" &&\n      (!bodyElement.declaration ||\n        (bodyElement.declaration.type !== \"TypeAlias\" &&\n          bodyElement.declaration.type !== \"InterfaceDeclaration\")))\n  );\n}\n\nfunction hasTypeImportKind(\n  node: Undone<N.ImportSpecifier | N.ImportDeclaration>,\n): boolean {\n  return node.importKind === \"type\" || node.importKind === \"typeof\";\n}\n\nconst exportSuggestions = {\n  const: \"declare export var\",\n  let: \"declare export var\",\n  type: \"export type\",\n  interface: \"export interface\",\n};\n\n// Like Array#filter, but returns a tuple [ acceptedElements, discardedElements ]\nfunction partition<T>(\n  list: T[],\n  test: (c: T, b: number, a: T[]) => boolean | undefined | null,\n): [T[], T[]] {\n  const list1: T[] = [];\n  const list2: T[] = [];\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}\n\nconst FLOW_PRAGMA_REGEX = /\\*?\\s*@((?:no)?flow)\\b/;\n\n// Flow enums types\ntype EnumExplicitType = null | \"boolean\" | \"number\" | \"string\" | \"symbol\";\n\ntype EnumContext = {\n  enumName: string;\n  explicitType: EnumExplicitType;\n  memberName: string;\n};\n\ntype EnumMemberInit =\n  | {\n      type: \"number\";\n      loc: Position;\n      value: N.Node;\n    }\n  | {\n      type: \"string\";\n      loc: Position;\n      value: N.Node;\n    }\n  | {\n      type: \"boolean\";\n      loc: Position;\n      value: N.Node;\n    }\n  | {\n      type: \"invalid\";\n      loc: Position;\n    }\n  | {\n      type: \"none\";\n      loc: Position;\n    };\n\nexport default (superClass: ClassWithMixin<typeof Parser, IJSXParserMixin>) =>\n  class FlowParserMixin extends superClass implements Parser {\n    // The value of the @flow/@noflow pragma. Initially undefined, transitions\n    // to \"@flow\" or \"@noflow\" if we see a pragma. Transitions to null if we are\n    // past the initial comment.\n    flowPragma: void | null | \"flow\" | \"noflow\" = undefined;\n\n    getScopeHandler(): new (...args: any) => FlowScopeHandler {\n      return FlowScopeHandler;\n    }\n\n    shouldParseTypes(): boolean {\n      return this.getPluginOption(\"flow\", \"all\") || this.flowPragma === \"flow\";\n    }\n\n    finishToken(type: TokenType, val: any): void {\n      if (\n        type !== tt.string &&\n        type !== tt.semi &&\n        type !== tt.interpreterDirective\n      ) {\n        if (this.flowPragma === undefined) {\n          this.flowPragma = null;\n        }\n      }\n      super.finishToken(type, val);\n    }\n\n    addComment(comment: N.Comment): void {\n      if (this.flowPragma === undefined) {\n        // Try to parse a flow pragma.\n        const matches = FLOW_PRAGMA_REGEX.exec(comment.value);\n        if (!matches) {\n          // do nothing\n        } 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\n    flowParseTypeInitialiser(tok?: TokenType): N.FlowType {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n      this.expect(tok || tt.colon);\n\n      const type = this.flowParseType();\n      this.state.inType = oldInType;\n      return type;\n    }\n\n    flowParsePredicate(): N.FlowPredicate {\n      const node = this.startNode<N.FlowPredicate>();\n      const moduloLoc = this.state.startLoc;\n      this.next(); // eat `%`\n      this.expectContextual(tt._checks);\n      // Force '%' and 'checks' to be adjacent\n      if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) {\n        this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc);\n      }\n      if (this.eat(tt.parenL)) {\n        node.value = super.parseExpression();\n        this.expect(tt.parenR);\n        return this.finishNode(node, \"DeclaredPredicate\");\n      } else {\n        return this.finishNode(node, \"InferredPredicate\");\n      }\n    }\n\n    flowParseTypeAndPredicateInitialiser(): [\n      N.FlowType | undefined | null,\n      N.FlowPredicate | undefined | null,\n    ] {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n      this.expect(tt.colon);\n      let type = null;\n      let predicate = null;\n      if (this.match(tt.modulo)) {\n        this.state.inType = oldInType;\n        predicate = this.flowParsePredicate();\n      } else {\n        type = this.flowParseType();\n        this.state.inType = oldInType;\n        if (this.match(tt.modulo)) {\n          predicate = this.flowParsePredicate();\n        }\n      }\n      return [type, predicate];\n    }\n\n    flowParseDeclareClass(\n      node: Undone<N.FlowDeclareClass>,\n    ): N.FlowDeclareClass {\n      this.next();\n      this.flowParseInterfaceish(node, /*isClass*/ true);\n      return this.finishNode(node, \"DeclareClass\");\n    }\n\n    flowParseDeclareFunction(\n      node: Undone<N.FlowDeclareFunction>,\n    ): N.FlowDeclareFunction {\n      this.next();\n\n      const id = (node.id = this.parseIdentifier());\n\n      const typeNode = this.startNode<N.FlowFunctionTypeAnnotation>();\n      const typeContainer = this.startNode<N.TypeAnnotation>();\n\n      if (this.match(tt.lt)) {\n        typeNode.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        typeNode.typeParameters = null;\n      }\n\n      this.expect(tt.parenL);\n      const tmp = this.flowParseFunctionTypeParams();\n      typeNode.params = tmp.params;\n      typeNode.rest = tmp.rest;\n      typeNode.this = tmp._this;\n      this.expect(tt.parenR);\n\n      [typeNode.returnType, node.predicate] =\n        this.flowParseTypeAndPredicateInitialiser();\n\n      typeContainer.typeAnnotation = this.finishNode(\n        typeNode,\n        \"FunctionTypeAnnotation\",\n      );\n\n      id.typeAnnotation = this.finishNode(typeContainer, \"TypeAnnotation\");\n\n      this.resetEndLocation(id);\n      this.semicolon();\n\n      this.scope.declareName(\n        node.id.name,\n        BindingFlag.TYPE_FLOW_DECLARE_FN,\n        node.id.loc.start,\n      );\n\n      return this.finishNode(node, \"DeclareFunction\");\n    }\n\n    flowParseDeclare(\n      node: Undone<N.FlowDeclare>,\n      insideModule?: boolean,\n    ): N.FlowDeclare {\n      if (this.match(tt._class)) {\n        return this.flowParseDeclareClass(node);\n      } else if (this.match(tt._function)) {\n        return this.flowParseDeclareFunction(node);\n      } else if (this.match(tt._var)) {\n        return this.flowParseDeclareVariable(node);\n      } else if (this.eatContextual(tt._module)) {\n        if (this.match(tt.dot)) {\n          return this.flowParseDeclareModuleExports(node);\n        } else {\n          if (insideModule) {\n            this.raise(\n              FlowErrors.NestedDeclareModule,\n              this.state.lastTokStartLoc,\n            );\n          }\n          return this.flowParseDeclareModule(node);\n        }\n      } else if (this.isContextual(tt._type)) {\n        return this.flowParseDeclareTypeAlias(node);\n      } else if (this.isContextual(tt._opaque)) {\n        return this.flowParseDeclareOpaqueType(node);\n      } else if (this.isContextual(tt._interface)) {\n        return this.flowParseDeclareInterface(node);\n      } else if (this.match(tt._export)) {\n        return this.flowParseDeclareExportDeclaration(node, insideModule);\n      } else {\n        this.unexpected();\n      }\n    }\n\n    flowParseDeclareVariable(\n      node: Undone<N.FlowDeclareVariable>,\n    ): N.FlowDeclareVariable {\n      this.next();\n      node.id = this.flowParseTypeAnnotatableIdentifier(\n        /*allowPrimitiveOverride*/ true,\n      );\n      this.scope.declareName(\n        node.id.name,\n        BindingFlag.TYPE_VAR,\n        node.id.loc.start,\n      );\n      this.semicolon();\n      return this.finishNode(node, \"DeclareVariable\");\n    }\n\n    flowParseDeclareModule(\n      node: Undone<N.FlowDeclareModule>,\n    ): N.FlowDeclareModule {\n      this.scope.enter(ScopeFlag.OTHER);\n\n      if (this.match(tt.string)) {\n        node.id = super.parseExprAtom();\n      } else {\n        node.id = this.parseIdentifier();\n      }\n\n      const bodyNode = (node.body = this.startNode<N.BlockStatement>());\n      // @ts-expect-error refine typings\n      const body = (bodyNode.body = []);\n      this.expect(tt.braceL);\n      while (!this.match(tt.braceR)) {\n        let bodyNode = this.startNode<N.ImportDeclaration>();\n\n        if (this.match(tt._import)) {\n          this.next();\n          if (!this.isContextual(tt._type) && !this.match(tt._typeof)) {\n            this.raise(\n              FlowErrors.InvalidNonTypeImportInDeclareModule,\n              this.state.lastTokStartLoc,\n            );\n          }\n          super.parseImport(bodyNode);\n        } else {\n          this.expectContextual(\n            tt._declare,\n            FlowErrors.UnsupportedStatementInDeclareModule,\n          );\n          // @ts-expect-error refine typings\n          bodyNode = this.flowParseDeclare(bodyNode, true);\n        }\n\n        body.push(bodyNode);\n      }\n\n      this.scope.exit();\n\n      this.expect(tt.braceR);\n\n      this.finishNode(bodyNode, \"BlockStatement\");\n\n      let kind: \"CommonJS\" | \"ES\" | null = 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\n      node.kind = kind || \"CommonJS\";\n      return this.finishNode(node, \"DeclareModule\");\n    }\n\n    flowParseDeclareExportDeclaration(\n      node: Undone<N.FlowDeclareExportDeclaration>,\n      insideModule?: boolean | null,\n    ): N.FlowDeclareExportDeclaration {\n      this.expect(tt._export);\n\n      if (this.eat(tt._default)) {\n        if (this.match(tt._function) || this.match(tt._class)) {\n          // declare export default class ...\n          // declare export default function ...\n          node.declaration = this.flowParseDeclare(this.startNode());\n        } else {\n          // declare export default [type];\n          node.declaration = this.flowParseType();\n          this.semicolon();\n        }\n        node.default = true;\n\n        return this.finishNode(node, \"DeclareExportDeclaration\");\n      } else {\n        if (\n          this.match(tt._const) ||\n          this.isLet() ||\n          ((this.isContextual(tt._type) || this.isContextual(tt._interface)) &&\n            !insideModule)\n        ) {\n          const label = this.state.value as\n            | \"const\"\n            | \"let\"\n            | \"type\"\n            | \"interface\";\n          throw this.raise(\n            FlowErrors.UnsupportedDeclareExportKind,\n            this.state.startLoc,\n            {\n              unsupportedExportKind: label,\n              suggestion: exportSuggestions[label],\n            },\n          );\n        }\n\n        if (\n          this.match(tt._var) || // declare export var ...\n          this.match(tt._function) || // declare export function ...\n          this.match(tt._class) || // declare export class ...\n          this.isContextual(tt._opaque) // declare export opaque ..\n        ) {\n          node.declaration = this.flowParseDeclare(this.startNode());\n          node.default = false;\n\n          return this.finishNode(node, \"DeclareExportDeclaration\");\n        } else if (\n          this.match(tt.star) || // declare export * from ''\n          this.match(tt.braceL) || // declare export {} ...\n          this.isContextual(tt._interface) || // declare export interface ...\n          this.isContextual(tt._type) || // declare export type ...\n          this.isContextual(tt._opaque) // declare export opaque type ...\n        ) {\n          node = this.parseExport(\n            node as Undone<N.ExportNamedDeclaration | N.ExportAllDeclaration>,\n            /* decorators */ null,\n          );\n          if (node.type === \"ExportNamedDeclaration\") {\n            node.type = \"ExportDeclaration\";\n            node.default = false;\n            delete node.exportKind;\n          }\n\n          node.type = \"Declare\" + node.type;\n\n          return node as N.FlowDeclareExportDeclaration;\n        }\n      }\n\n      this.unexpected();\n    }\n\n    flowParseDeclareModuleExports(\n      node: Undone<N.FlowDeclareModuleExports>,\n    ): N.FlowDeclareModuleExports {\n      this.next();\n      this.expectContextual(tt._exports);\n      node.typeAnnotation = this.flowParseTypeAnnotation();\n      this.semicolon();\n\n      return this.finishNode(node, \"DeclareModuleExports\");\n    }\n\n    flowParseDeclareTypeAlias(\n      node: Undone<N.FlowDeclareTypeAlias>,\n    ): N.FlowDeclareTypeAlias {\n      this.next();\n      const finished = this.flowParseTypeAlias(\n        node,\n      ) as unknown as N.FlowDeclareTypeAlias;\n      // Don't do finishNode as we don't want to process comments twice\n      finished.type = \"DeclareTypeAlias\";\n      return finished;\n    }\n\n    flowParseDeclareOpaqueType(\n      node: Undone<N.FlowDeclareOpaqueType>,\n    ): N.FlowDeclareOpaqueType {\n      this.next();\n      const finished = this.flowParseOpaqueType(\n        node,\n        true,\n      ) as unknown as N.FlowDeclareOpaqueType;\n      // Don't do finishNode as we don't want to process comments twice\n      finished.type = \"DeclareOpaqueType\";\n      return finished;\n    }\n\n    flowParseDeclareInterface(\n      node: Undone<N.FlowDeclareInterface>,\n    ): N.FlowDeclareInterface {\n      this.next();\n      this.flowParseInterfaceish(node, /* isClass */ false);\n      return this.finishNode(node, \"DeclareInterface\");\n    }\n\n    // Interfaces\n\n    flowParseInterfaceish(node: Undone<N.FlowDeclare>, isClass: boolean): void {\n      node.id = this.flowParseRestrictedIdentifier(\n        /* liberal */ !isClass,\n        /* declaration */ true,\n      );\n\n      this.scope.declareName(\n        node.id.name,\n        isClass ? BindingFlag.TYPE_FUNCTION : BindingFlag.TYPE_LEXICAL,\n        node.id.loc.start,\n      );\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        node.typeParameters = null;\n      }\n\n      node.extends = [];\n\n      if (this.eat(tt._extends)) {\n        do {\n          node.extends.push(this.flowParseInterfaceExtends());\n        } while (!isClass && this.eat(tt.comma));\n      }\n\n      if (isClass) {\n        node.implements = [];\n        node.mixins = [];\n\n        if (this.eatContextual(tt._mixins)) {\n          do {\n            node.mixins.push(this.flowParseInterfaceExtends());\n          } while (this.eat(tt.comma));\n        }\n\n        if (this.eatContextual(tt._implements)) {\n          do {\n            node.implements.push(this.flowParseInterfaceExtends());\n          } while (this.eat(tt.comma));\n        }\n      }\n\n      node.body = this.flowParseObjectType({\n        allowStatic: isClass,\n        allowExact: false,\n        allowSpread: false,\n        allowProto: isClass,\n        allowInexact: false,\n      });\n    }\n\n    flowParseInterfaceExtends(): N.FlowInterfaceExtends {\n      const node = this.startNode<N.FlowInterfaceExtends>();\n\n      node.id = this.flowParseQualifiedTypeIdentifier();\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterInstantiation();\n      } else {\n        node.typeParameters = null;\n      }\n\n      return this.finishNode(node, \"InterfaceExtends\");\n    }\n\n    flowParseInterface(node: Undone<N.FlowInterface>): N.FlowInterface {\n      this.flowParseInterfaceish(node, /* isClass */ false);\n      return this.finishNode(node, \"InterfaceDeclaration\");\n    }\n\n    checkNotUnderscore(word: string) {\n      if (word === \"_\") {\n        this.raise(\n          FlowErrors.UnexpectedReservedUnderscore,\n          this.state.startLoc,\n        );\n      }\n    }\n\n    checkReservedType(word: string, startLoc: Position, declaration?: boolean) {\n      if (!reservedTypes.has(word)) return;\n\n      this.raise(\n        declaration\n          ? FlowErrors.AssignReservedType\n          : FlowErrors.UnexpectedReservedType,\n        startLoc,\n        {\n          reservedType: word,\n        },\n      );\n    }\n\n    flowParseRestrictedIdentifier(\n      liberal?: boolean,\n      declaration?: boolean,\n    ): N.Identifier {\n      this.checkReservedType(\n        this.state.value,\n        this.state.startLoc,\n        declaration,\n      );\n      return this.parseIdentifier(liberal);\n    }\n\n    // Type aliases\n\n    flowParseTypeAlias(node: Undone<N.FlowTypeAlias>): N.FlowTypeAlias {\n      node.id = this.flowParseRestrictedIdentifier(\n        /* liberal */ false,\n        /* declaration */ true,\n      );\n      this.scope.declareName(\n        node.id.name,\n        BindingFlag.TYPE_LEXICAL,\n        node.id.loc.start,\n      );\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        node.typeParameters = null;\n      }\n\n      node.right = this.flowParseTypeInitialiser(tt.eq);\n      this.semicolon();\n\n      return this.finishNode(node, \"TypeAlias\");\n    }\n\n    flowParseOpaqueType(\n      node: Undone<N.FlowOpaqueType>,\n      declare: boolean,\n    ): N.FlowOpaqueType {\n      this.expectContextual(tt._type);\n      node.id = this.flowParseRestrictedIdentifier(\n        /* liberal */ true,\n        /* declaration */ true,\n      );\n      this.scope.declareName(\n        node.id.name,\n        BindingFlag.TYPE_LEXICAL,\n        node.id.loc.start,\n      );\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      } else {\n        node.typeParameters = null;\n      }\n\n      // Parse the supertype\n      node.supertype = null;\n      if (this.match(tt.colon)) {\n        node.supertype = this.flowParseTypeInitialiser(tt.colon);\n      }\n\n      node.impltype = null;\n      if (!declare) {\n        node.impltype = this.flowParseTypeInitialiser(tt.eq);\n      }\n      this.semicolon();\n\n      return this.finishNode(node, \"OpaqueType\");\n    }\n\n    // Type annotations\n\n    flowParseTypeParameter(requireDefault: boolean = false): N.TypeParameter {\n      const nodeStartLoc = this.state.startLoc;\n\n      const node = this.startNode<N.TypeParameter>();\n\n      const variance = this.flowParseVariance();\n\n      const ident = this.flowParseTypeAnnotatableIdentifier();\n      node.name = ident.name;\n      // @ts-expect-error migrate to Babel types\n      node.variance = variance;\n      // @ts-expect-error migrate to Babel types\n      node.bound = ident.typeAnnotation;\n\n      if (this.match(tt.eq)) {\n        this.eat(tt.eq);\n        // @ts-expect-error migrate to Babel types\n        node.default = this.flowParseType();\n      } else {\n        if (requireDefault) {\n          this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);\n        }\n      }\n\n      return this.finishNode(node, \"TypeParameter\");\n    }\n\n    flowParseTypeParameterDeclaration(): N.TypeParameterDeclaration {\n      const oldInType = this.state.inType;\n      const node = this.startNode<N.TypeParameterDeclaration>();\n      node.params = [];\n\n      this.state.inType = true;\n\n      // istanbul ignore else: this condition is already checked at all call sites\n      if (this.match(tt.lt) || this.match(tt.jsxTagStart)) {\n        this.next();\n      } else {\n        this.unexpected();\n      }\n\n      let defaultRequired = false;\n\n      do {\n        const typeParameter = this.flowParseTypeParameter(defaultRequired);\n\n        node.params.push(typeParameter);\n\n        if (typeParameter.default) {\n          defaultRequired = true;\n        }\n\n        if (!this.match(tt.gt)) {\n          this.expect(tt.comma);\n        }\n      } while (!this.match(tt.gt));\n      this.expect(tt.gt);\n\n      this.state.inType = oldInType;\n\n      return this.finishNode(node, \"TypeParameterDeclaration\");\n    }\n\n    // Parse in top level normal context if we are in a JSX context\n    flowInTopLevelContext<T>(cb: () => T): T {\n      if (this.curContext() !== tc.brace) {\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      } else {\n        return cb();\n      }\n    }\n\n    // Used when parsing type arguments from ES or JSX productions, where the first token\n    // has been created without state.inType. Thus we need to re-scan the lt token.\n    flowParseTypeParameterInstantiationInExpression():\n      | N.TypeParameterInstantiation\n      | undefined {\n      if (this.reScan_lt() !== tt.lt) return;\n      return this.flowParseTypeParameterInstantiation();\n    }\n\n    flowParseTypeParameterInstantiation(): N.TypeParameterInstantiation {\n      const node = this.startNode<N.TypeParameterInstantiation>();\n      const oldInType = this.state.inType;\n\n      this.state.inType = true;\n      node.params = [];\n      this.flowInTopLevelContext(() => {\n        this.expect(tt.lt);\n        const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n        this.state.noAnonFunctionType = false;\n        while (!this.match(tt.gt)) {\n          node.params.push(this.flowParseType());\n          if (!this.match(tt.gt)) {\n            this.expect(tt.comma);\n          }\n        }\n        this.state.noAnonFunctionType = oldNoAnonFunctionType;\n      });\n\n      this.state.inType = oldInType;\n      if (!this.state.inType && this.curContext() === tc.brace) {\n        // rescan `>` when we are no longer in type context and JSX parsing context\n        // since it was tokenized when `inType` is `true`.\n        this.reScan_lt_gt();\n      }\n      this.expect(tt.gt);\n\n      return this.finishNode(node, \"TypeParameterInstantiation\");\n    }\n\n    flowParseTypeParameterInstantiationCallOrNew(): N.TypeParameterInstantiation {\n      if (this.reScan_lt() !== tt.lt) return;\n      const node = this.startNode<N.TypeParameterInstantiation>();\n      const oldInType = this.state.inType;\n      node.params = [];\n\n      this.state.inType = true;\n\n      this.expect(tt.lt);\n      while (!this.match(tt.gt)) {\n        node.params.push(this.flowParseTypeOrImplicitInstantiation());\n        if (!this.match(tt.gt)) {\n          this.expect(tt.comma);\n        }\n      }\n      this.expect(tt.gt);\n\n      this.state.inType = oldInType;\n\n      return this.finishNode(node, \"TypeParameterInstantiation\");\n    }\n\n    flowParseInterfaceType(): N.FlowInterfaceType {\n      const node = this.startNode<N.FlowInterfaceType>();\n      this.expectContextual(tt._interface);\n\n      node.extends = [];\n      if (this.eat(tt._extends)) {\n        do {\n          node.extends.push(this.flowParseInterfaceExtends());\n        } while (this.eat(tt.comma));\n      }\n\n      node.body = this.flowParseObjectType({\n        allowStatic: false,\n        allowExact: false,\n        allowSpread: false,\n        allowProto: false,\n        allowInexact: false,\n      });\n\n      return this.finishNode(node, \"InterfaceTypeAnnotation\");\n    }\n\n    flowParseObjectPropertyKey(): N.Expression {\n      return this.match(tt.num) || this.match(tt.string)\n        ? super.parseExprAtom()\n        : this.parseIdentifier(true);\n    }\n\n    flowParseObjectTypeIndexer(\n      node: Undone<N.FlowObjectTypeIndexer>,\n      isStatic: boolean,\n      variance?: N.FlowVariance | null,\n    ): N.FlowObjectTypeIndexer {\n      node.static = isStatic;\n\n      // Note: bracketL has already been consumed\n      if (this.lookahead().type === tt.colon) {\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(tt.bracketR);\n      node.value = this.flowParseTypeInitialiser();\n      node.variance = variance;\n\n      return this.finishNode(node, \"ObjectTypeIndexer\");\n    }\n\n    flowParseObjectTypeInternalSlot(\n      node: Undone<N.FlowObjectTypeInternalSlot>,\n      isStatic: boolean,\n    ): N.FlowObjectTypeInternalSlot {\n      node.static = isStatic;\n      // Note: both bracketL have already been consumed\n      node.id = this.flowParseObjectPropertyKey();\n      this.expect(tt.bracketR);\n      this.expect(tt.bracketR);\n      if (this.match(tt.lt) || this.match(tt.parenL)) {\n        node.method = true;\n        node.optional = false;\n        node.value = this.flowParseObjectTypeMethodish(\n          this.startNodeAt(node.loc.start),\n        );\n      } else {\n        node.method = false;\n        if (this.eat(tt.question)) {\n          node.optional = true;\n        }\n        node.value = this.flowParseTypeInitialiser();\n      }\n      return this.finishNode(node, \"ObjectTypeInternalSlot\");\n    }\n\n    flowParseObjectTypeMethodish(\n      node: Undone<N.FlowFunctionTypeAnnotation>,\n    ): N.FlowFunctionTypeAnnotation {\n      node.params = [];\n      node.rest = null;\n      node.typeParameters = null;\n      node.this = null;\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n\n      this.expect(tt.parenL);\n      if (this.match(tt._this)) {\n        node.this = this.flowParseFunctionTypeParam(/* first */ true);\n        // match Flow parser behavior\n        node.this.name = null;\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n      while (!this.match(tt.parenR) && !this.match(tt.ellipsis)) {\n        node.params.push(this.flowParseFunctionTypeParam(false));\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n\n      if (this.eat(tt.ellipsis)) {\n        node.rest = this.flowParseFunctionTypeParam(false);\n      }\n      this.expect(tt.parenR);\n      node.returnType = this.flowParseTypeInitialiser();\n\n      return this.finishNode(node, \"FunctionTypeAnnotation\");\n    }\n\n    flowParseObjectTypeCallProperty(\n      node: Undone<N.FlowObjectTypeCallProperty>,\n      isStatic: boolean,\n    ): N.FlowObjectTypeCallProperty {\n      const valueNode = this.startNode();\n      node.static = isStatic;\n      node.value = this.flowParseObjectTypeMethodish(valueNode);\n      return this.finishNode(node, \"ObjectTypeCallProperty\");\n    }\n\n    flowParseObjectType({\n      allowStatic,\n      allowExact,\n      allowSpread,\n      allowProto,\n      allowInexact,\n    }: {\n      allowStatic: boolean;\n      allowExact: boolean;\n      allowSpread: boolean;\n      allowProto: boolean;\n      allowInexact: boolean;\n    }): N.FlowObjectTypeAnnotation {\n      const oldInType = this.state.inType;\n      this.state.inType = true;\n\n      const nodeStart = this.startNode<N.FlowObjectTypeAnnotation>();\n\n      nodeStart.callProperties = [];\n      nodeStart.properties = [];\n      nodeStart.indexers = [];\n      nodeStart.internalSlots = [];\n\n      let endDelim;\n      let exact;\n      let inexact = false;\n      if (allowExact && this.match(tt.braceBarL)) {\n        this.expect(tt.braceBarL);\n        endDelim = tt.braceBarR;\n        exact = true;\n      } else {\n        this.expect(tt.braceL);\n        endDelim = tt.braceR;\n        exact = false;\n      }\n\n      nodeStart.exact = exact;\n\n      while (!this.match(endDelim)) {\n        let isStatic = false;\n        let protoStartLoc: Position | undefined | null = null;\n        let inexactStartLoc: Position | undefined | null = null;\n        const node = this.startNode();\n\n        if (allowProto && this.isContextual(tt._proto)) {\n          const lookahead = this.lookahead();\n\n          if (lookahead.type !== tt.colon && lookahead.type !== tt.question) {\n            this.next();\n            protoStartLoc = this.state.startLoc;\n            allowStatic = false;\n          }\n        }\n\n        if (allowStatic && this.isContextual(tt._static)) {\n          const lookahead = this.lookahead();\n\n          // static is a valid identifier name\n          if (lookahead.type !== tt.colon && lookahead.type !== tt.question) {\n            this.next();\n            isStatic = true;\n          }\n        }\n\n        const variance = this.flowParseVariance();\n\n        if (this.eat(tt.bracketL)) {\n          if (protoStartLoc != null) {\n            this.unexpected(protoStartLoc);\n          }\n          if (this.eat(tt.bracketL)) {\n            if (variance) {\n              this.unexpected(variance.loc.start);\n            }\n            nodeStart.internalSlots.push(\n              this.flowParseObjectTypeInternalSlot(node, isStatic),\n            );\n          } else {\n            nodeStart.indexers.push(\n              this.flowParseObjectTypeIndexer(node, isStatic, variance),\n            );\n          }\n        } else if (this.match(tt.parenL) || this.match(tt.lt)) {\n          if (protoStartLoc != null) {\n            this.unexpected(protoStartLoc);\n          }\n          if (variance) {\n            this.unexpected(variance.loc.start);\n          }\n          nodeStart.callProperties.push(\n            this.flowParseObjectTypeCallProperty(node, isStatic),\n          );\n        } else {\n          let kind = \"init\";\n\n          if (this.isContextual(tt._get) || this.isContextual(tt._set)) {\n            const lookahead = this.lookahead();\n            if (tokenIsLiteralPropertyName(lookahead.type)) {\n              kind = this.state.value;\n              this.next();\n            }\n          }\n\n          const propOrInexact = this.flowParseObjectTypeProperty(\n            node,\n            isStatic,\n            protoStartLoc,\n            variance,\n            kind,\n            allowSpread,\n            allowInexact ?? !exact,\n          );\n\n          if (propOrInexact === null) {\n            inexact = true;\n            inexactStartLoc = this.state.lastTokStartLoc;\n          } else {\n            nodeStart.properties.push(propOrInexact);\n          }\n        }\n\n        this.flowObjectTypeSemicolon();\n\n        if (\n          inexactStartLoc &&\n          !this.match(tt.braceR) &&\n          !this.match(tt.braceBarR)\n        ) {\n          this.raise(\n            FlowErrors.UnexpectedExplicitInexactInObject,\n            inexactStartLoc,\n          );\n        }\n      }\n\n      this.expect(endDelim);\n\n      /* The inexact flag should only be added on ObjectTypeAnnotations that\n       * are not the body of an interface, declare interface, or declare class.\n       * Since spreads are only allowed in object types, checking that is\n       * sufficient here.\n       */\n      if (allowSpread) {\n        nodeStart.inexact = inexact;\n      }\n\n      const out = this.finishNode(nodeStart, \"ObjectTypeAnnotation\");\n\n      this.state.inType = oldInType;\n\n      return out;\n    }\n\n    flowParseObjectTypeProperty(\n      node: Undone<N.FlowObjectTypeProperty | N.FlowObjectTypeSpreadProperty>,\n      isStatic: boolean,\n      protoStartLoc: Position | undefined | null,\n      variance: N.FlowVariance | undefined | null,\n      kind: string,\n      allowSpread: boolean,\n      allowInexact: boolean,\n    ): N.FlowObjectTypeProperty | N.FlowObjectTypeSpreadProperty | null {\n      if (this.eat(tt.ellipsis)) {\n        const isInexactToken =\n          this.match(tt.comma) ||\n          this.match(tt.semi) ||\n          this.match(tt.braceR) ||\n          this.match(tt.braceBarR);\n\n        if (isInexactToken) {\n          if (!allowSpread) {\n            this.raise(\n              FlowErrors.InexactInsideNonObject,\n              this.state.lastTokStartLoc,\n            );\n          } else if (!allowInexact) {\n            this.raise(\n              FlowErrors.InexactInsideExact,\n              this.state.lastTokStartLoc,\n            );\n          }\n          if (variance) {\n            this.raise(FlowErrors.InexactVariance, variance);\n          }\n\n          return null;\n        }\n\n        if (!allowSpread) {\n          this.raise(\n            FlowErrors.UnexpectedSpreadType,\n            this.state.lastTokStartLoc,\n          );\n        }\n        if (protoStartLoc != null) {\n          this.unexpected(protoStartLoc);\n        }\n        if (variance) {\n          this.raise(FlowErrors.SpreadVariance, variance);\n        }\n\n        node.argument = this.flowParseType();\n        return this.finishNode(node, \"ObjectTypeSpreadProperty\");\n      } else {\n        node.key = this.flowParseObjectPropertyKey();\n        node.static = isStatic;\n        node.proto = protoStartLoc != null;\n        node.kind = kind;\n\n        let optional = false;\n        if (this.match(tt.lt) || this.match(tt.parenL)) {\n          // This is a method property\n          node.method = true;\n\n          if (protoStartLoc != null) {\n            this.unexpected(protoStartLoc);\n          }\n          if (variance) {\n            this.unexpected(variance.loc.start);\n          }\n\n          node.value = this.flowParseObjectTypeMethodish(\n            this.startNodeAt(node.loc.start),\n          );\n          if (kind === \"get\" || kind === \"set\") {\n            this.flowCheckGetterSetterParams(node);\n          }\n          /** Declared classes/interfaces do not allow spread */\n          if (\n            !allowSpread &&\n            node.key.name === \"constructor\" &&\n            node.value.this\n          ) {\n            this.raise(\n              FlowErrors.ThisParamBannedInConstructor,\n              node.value.this,\n            );\n          }\n        } else {\n          if (kind !== \"init\") this.unexpected();\n\n          node.method = false;\n\n          if (this.eat(tt.question)) {\n            optional = true;\n          }\n          node.value = this.flowParseTypeInitialiser();\n          node.variance = variance;\n        }\n\n        node.optional = optional;\n\n        return this.finishNode(node, \"ObjectTypeProperty\");\n      }\n    }\n\n    // This is similar to checkGetterSetterParams, but as\n    // @babel/parser uses non estree properties we cannot reuse it here\n    flowCheckGetterSetterParams(\n      property: Undone<\n        N.FlowObjectTypeProperty | N.FlowObjectTypeSpreadProperty\n      >,\n    ): void {\n      const paramCount = property.kind === \"get\" ? 0 : 1;\n      const length =\n        property.value.params.length + (property.value.rest ? 1 : 0);\n\n      if (property.value.this) {\n        this.raise(\n          property.kind === \"get\"\n            ? FlowErrors.GetterMayNotHaveThisParam\n            : FlowErrors.SetterMayNotHaveThisParam,\n          property.value.this,\n        );\n      }\n\n      if (length !== paramCount) {\n        this.raise(\n          property.kind === \"get\"\n            ? Errors.BadGetterArity\n            : Errors.BadSetterArity,\n          property,\n        );\n      }\n\n      if (property.kind === \"set\" && property.value.rest) {\n        this.raise(Errors.BadSetterRestParameter, property);\n      }\n    }\n\n    flowObjectTypeSemicolon(): void {\n      if (\n        !this.eat(tt.semi) &&\n        !this.eat(tt.comma) &&\n        !this.match(tt.braceR) &&\n        !this.match(tt.braceBarR)\n      ) {\n        this.unexpected();\n      }\n    }\n\n    flowParseQualifiedTypeIdentifier(\n      startLoc?: Position,\n      id?: N.Identifier,\n    ): N.FlowQualifiedTypeIdentifier | N.Identifier {\n      startLoc ??= this.state.startLoc;\n      let node: N.Identifier | N.FlowQualifiedTypeIdentifier =\n        id || this.flowParseRestrictedIdentifier(true);\n\n      while (this.eat(tt.dot)) {\n        const node2 = this.startNodeAt<N.FlowQualifiedTypeIdentifier>(startLoc);\n        node2.qualification = node;\n        node2.id = this.flowParseRestrictedIdentifier(true);\n        node = this.finishNode(node2, \"QualifiedTypeIdentifier\");\n      }\n\n      return node;\n    }\n\n    flowParseGenericType(\n      startLoc: Position,\n      id: N.Identifier,\n    ): N.FlowGenericTypeAnnotation {\n      const node = this.startNodeAt<N.FlowGenericTypeAnnotation>(startLoc);\n\n      node.typeParameters = null;\n      node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);\n\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterInstantiation();\n      }\n\n      return this.finishNode(node, \"GenericTypeAnnotation\");\n    }\n\n    flowParseTypeofType(): N.FlowTypeofTypeAnnotation {\n      const node = this.startNode<N.FlowTypeofTypeAnnotation>();\n      this.expect(tt._typeof);\n      node.argument = this.flowParsePrimaryType();\n      return this.finishNode(node, \"TypeofTypeAnnotation\");\n    }\n\n    flowParseTupleType(): N.FlowTupleTypeAnnotation {\n      const node = this.startNode<N.FlowTupleTypeAnnotation>();\n      node.types = [];\n      this.expect(tt.bracketL);\n      // We allow trailing commas\n      while (this.state.pos < this.length && !this.match(tt.bracketR)) {\n        node.types.push(this.flowParseType());\n        if (this.match(tt.bracketR)) break;\n        this.expect(tt.comma);\n      }\n      this.expect(tt.bracketR);\n      return this.finishNode(node, \"TupleTypeAnnotation\");\n    }\n\n    flowParseFunctionTypeParam(first: boolean): N.FlowFunctionTypeParam {\n      let name = null;\n      let optional = false;\n      let typeAnnotation = null;\n      const node = this.startNode<N.FlowFunctionTypeParam>();\n      const lh = this.lookahead();\n      const isThis = this.state.type === tt._this;\n\n      if (lh.type === tt.colon || lh.type === tt.question) {\n        if (isThis && !first) {\n          this.raise(FlowErrors.ThisParamMustBeFirst, node);\n        }\n        name = this.parseIdentifier(isThis);\n        if (this.eat(tt.question)) {\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\n    reinterpretTypeAsFunctionTypeParam(\n      type: N.FlowType,\n    ): N.FlowFunctionTypeParam {\n      const node = this.startNodeAt<N.FlowFunctionTypeParam>(type.loc.start);\n      node.name = null;\n      node.optional = false;\n      node.typeAnnotation = type;\n      return this.finishNode(node, \"FunctionTypeParam\");\n    }\n\n    flowParseFunctionTypeParams(params: N.FlowFunctionTypeParam[] = []): {\n      params: N.FlowFunctionTypeParam[];\n      rest: N.FlowFunctionTypeParam | undefined | null;\n      _this: N.FlowFunctionTypeParam | undefined | null;\n    } {\n      let rest: N.FlowFunctionTypeParam | undefined | null = null;\n      let _this: N.FlowFunctionTypeParam | undefined | null = null;\n      if (this.match(tt._this)) {\n        _this = this.flowParseFunctionTypeParam(/* first */ true);\n        // match Flow parser behavior\n        _this.name = null;\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n      while (!this.match(tt.parenR) && !this.match(tt.ellipsis)) {\n        params.push(this.flowParseFunctionTypeParam(false));\n        if (!this.match(tt.parenR)) {\n          this.expect(tt.comma);\n        }\n      }\n      if (this.eat(tt.ellipsis)) {\n        rest = this.flowParseFunctionTypeParam(false);\n      }\n      return { params, rest, _this };\n    }\n\n    flowIdentToTypeAnnotation(\n      startLoc: Position,\n      node: Undone<N.FlowType>,\n      id: N.Identifier,\n    ): N.FlowType {\n      switch (id.name) {\n        case \"any\":\n          return this.finishNode(node, \"AnyTypeAnnotation\");\n\n        case \"bool\":\n        case \"boolean\":\n          return this.finishNode(node, \"BooleanTypeAnnotation\");\n\n        case \"mixed\":\n          return this.finishNode(node, \"MixedTypeAnnotation\");\n\n        case \"empty\":\n          return this.finishNode(node, \"EmptyTypeAnnotation\");\n\n        case \"number\":\n          return this.finishNode(node, \"NumberTypeAnnotation\");\n\n        case \"string\":\n          return this.finishNode(node, \"StringTypeAnnotation\");\n\n        case \"symbol\":\n          return this.finishNode(node, \"SymbolTypeAnnotation\");\n\n        default:\n          this.checkNotUnderscore(id.name);\n          return this.flowParseGenericType(startLoc, id);\n      }\n    }\n\n    // The parsing of types roughly parallels the parsing of expressions, and\n    // primary types are kind of like primary expressions...they're the\n    // primitives with which other types are constructed.\n    flowParsePrimaryType(): N.FlowType {\n      const startLoc = this.state.startLoc;\n      const node = this.startNode<N.FlowOtherTypeAnnotation>();\n      let tmp;\n      let type;\n      let isGroupedType = false;\n      const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n\n      switch (this.state.type) {\n        case tt.braceL:\n          return this.flowParseObjectType({\n            allowStatic: false,\n            allowExact: false,\n            allowSpread: true,\n            allowProto: false,\n            allowInexact: true,\n          });\n\n        case tt.braceBarL:\n          return this.flowParseObjectType({\n            allowStatic: false,\n            allowExact: true,\n            allowSpread: true,\n            allowProto: false,\n            allowInexact: false,\n          });\n\n        case tt.bracketL:\n          this.state.noAnonFunctionType = false;\n          type = this.flowParseTupleType();\n          this.state.noAnonFunctionType = oldNoAnonFunctionType;\n          return type;\n\n        case tt.lt: {\n          const node = this.startNode<N.FlowFunctionTypeAnnotation>();\n          node.typeParameters = this.flowParseTypeParameterDeclaration();\n          this.expect(tt.parenL);\n          tmp = this.flowParseFunctionTypeParams();\n          node.params = tmp.params;\n          node.rest = tmp.rest;\n          node.this = tmp._this;\n          this.expect(tt.parenR);\n\n          this.expect(tt.arrow);\n\n          node.returnType = this.flowParseType();\n\n          return this.finishNode(node, \"FunctionTypeAnnotation\");\n        }\n\n        case tt.parenL: {\n          const node = this.startNode<N.FlowFunctionTypeAnnotation>();\n          this.next();\n\n          // Check to see if this is actually a grouped type\n          if (!this.match(tt.parenR) && !this.match(tt.ellipsis)) {\n            if (tokenIsIdentifier(this.state.type) || this.match(tt._this)) {\n              const token = this.lookahead().type;\n              isGroupedType = token !== tt.question && token !== tt.colon;\n            } else {\n              isGroupedType = true;\n            }\n          }\n\n          if (isGroupedType) {\n            this.state.noAnonFunctionType = false;\n            type = this.flowParseType();\n            this.state.noAnonFunctionType = oldNoAnonFunctionType;\n\n            // A `,` or a `) =>` means this is an anonymous function type\n            if (\n              this.state.noAnonFunctionType ||\n              !(\n                this.match(tt.comma) ||\n                (this.match(tt.parenR) && this.lookahead().type === tt.arrow)\n              )\n            ) {\n              this.expect(tt.parenR);\n              return type;\n            } else {\n              // Eat a comma if there is one\n              this.eat(tt.comma);\n            }\n          }\n\n          if (type) {\n            tmp = this.flowParseFunctionTypeParams([\n              this.reinterpretTypeAsFunctionTypeParam(type),\n            ]);\n          } else {\n            tmp = this.flowParseFunctionTypeParams();\n          }\n\n          node.params = tmp.params;\n          node.rest = tmp.rest;\n          node.this = tmp._this;\n\n          this.expect(tt.parenR);\n\n          this.expect(tt.arrow);\n\n          node.returnType = this.flowParseType();\n\n          node.typeParameters = null;\n\n          return this.finishNode(node, \"FunctionTypeAnnotation\");\n        }\n\n        case tt.string:\n          return this.parseLiteral<N.StringLiteralTypeAnnotation>(\n            this.state.value,\n            \"StringLiteralTypeAnnotation\",\n          );\n\n        case tt._true:\n        case tt._false:\n          node.value = this.match(tt._true);\n          this.next();\n          return this.finishNode(\n            node as Undone<N.BooleanLiteralTypeAnnotation>,\n            \"BooleanLiteralTypeAnnotation\",\n          );\n\n        case tt.plusMin:\n          if (this.state.value === \"-\") {\n            this.next();\n            if (this.match(tt.num)) {\n              return this.parseLiteralAtNode<N.NumberLiteralTypeAnnotation>(\n                -this.state.value,\n                \"NumberLiteralTypeAnnotation\",\n                node,\n              );\n            }\n\n            if (this.match(tt.bigint)) {\n              return this.parseLiteralAtNode<N.BigIntLiteralTypeAnnotation>(\n                -this.state.value,\n                \"BigIntLiteralTypeAnnotation\",\n                node,\n              );\n            }\n\n            throw this.raise(\n              FlowErrors.UnexpectedSubtractionOperand,\n              this.state.startLoc,\n            );\n          }\n          this.unexpected();\n          return;\n        case tt.num:\n          return this.parseLiteral(\n            this.state.value,\n            \"NumberLiteralTypeAnnotation\",\n          );\n\n        case tt.bigint:\n          return this.parseLiteral(\n            this.state.value,\n            \"BigIntLiteralTypeAnnotation\",\n          );\n\n        case tt._void:\n          this.next();\n          return this.finishNode(node, \"VoidTypeAnnotation\");\n\n        case tt._null:\n          this.next();\n          return this.finishNode(node, \"NullLiteralTypeAnnotation\");\n\n        case tt._this:\n          this.next();\n          return this.finishNode(node, \"ThisTypeAnnotation\");\n\n        case tt.star:\n          this.next();\n          return this.finishNode(node, \"ExistsTypeAnnotation\");\n\n        case tt._typeof:\n          return this.flowParseTypeofType();\n\n        default:\n          if (tokenIsKeyword(this.state.type)) {\n            const label = tokenLabelName(this.state.type);\n            this.next();\n            return super.createIdentifier(node as Undone<N.Identifier>, label);\n          } else if (tokenIsIdentifier(this.state.type)) {\n            if (this.isContextual(tt._interface)) {\n              return this.flowParseInterfaceType();\n            }\n\n            return this.flowIdentToTypeAnnotation(\n              startLoc,\n              node,\n              this.parseIdentifier(),\n            );\n          }\n      }\n\n      this.unexpected();\n    }\n\n    flowParsePostfixType(): N.FlowType {\n      const startLoc = this.state.startLoc;\n      let type = this.flowParsePrimaryType();\n      let seenOptionalIndexedAccess = false;\n      while (\n        (this.match(tt.bracketL) || this.match(tt.questionDot)) &&\n        !this.canInsertSemicolon()\n      ) {\n        const node = this.startNodeAt<N.FlowOtherTypeAnnotation>(startLoc);\n        const optional = this.eat(tt.questionDot);\n        seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;\n        this.expect(tt.bracketL);\n        if (!optional && this.match(tt.bracketR)) {\n          node.elementType = type;\n          this.next(); // eat `]`\n          type = this.finishNode(node, \"ArrayTypeAnnotation\");\n        } else {\n          node.objectType = type;\n          node.indexType = this.flowParseType();\n          this.expect(tt.bracketR);\n          if (seenOptionalIndexedAccess) {\n            node.optional = optional;\n            type = this.finishNode<N.FlowOptionalIndexedAccessType>(\n              // @ts-expect-error todo(flow->ts)\n              node,\n              \"OptionalIndexedAccessType\",\n            );\n          } else {\n            type = this.finishNode<N.FlowIndexedAccessType>(\n              // @ts-expect-error todo(flow->ts)\n              node,\n              \"IndexedAccessType\",\n            );\n          }\n        }\n      }\n      return type;\n    }\n\n    flowParsePrefixType(): N.FlowType {\n      const node = this.startNode<N.FlowOtherTypeAnnotation>();\n      if (this.eat(tt.question)) {\n        node.typeAnnotation = this.flowParsePrefixType();\n        return this.finishNode(node, \"NullableTypeAnnotation\");\n      } else {\n        return this.flowParsePostfixType();\n      }\n    }\n\n    flowParseAnonFunctionWithoutParens(): N.FlowType {\n      const param = this.flowParsePrefixType();\n      if (!this.state.noAnonFunctionType && this.eat(tt.arrow)) {\n        // TODO: This should be a type error. Passing in a SourceLocation, and it expects a Position.\n        const node = this.startNodeAt<N.FlowFunctionTypeAnnotation>(\n          param.loc.start,\n        );\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\n    flowParseIntersectionType(): N.FlowType {\n      const node = this.startNode<N.FlowOtherTypeAnnotation>();\n      this.eat(tt.bitwiseAND);\n      const type = this.flowParseAnonFunctionWithoutParens();\n      node.types = [type];\n      while (this.eat(tt.bitwiseAND)) {\n        node.types.push(this.flowParseAnonFunctionWithoutParens());\n      }\n      return node.types.length === 1\n        ? type\n        : this.finishNode(node, \"IntersectionTypeAnnotation\");\n    }\n\n    flowParseUnionType(): N.FlowType {\n      const node = this.startNode<N.FlowOtherTypeAnnotation>();\n      this.eat(tt.bitwiseOR);\n      const type = this.flowParseIntersectionType();\n      node.types = [type];\n      while (this.eat(tt.bitwiseOR)) {\n        node.types.push(this.flowParseIntersectionType());\n      }\n      return node.types.length === 1\n        ? type\n        : this.finishNode(node, \"UnionTypeAnnotation\");\n    }\n\n    flowParseType(): N.FlowType {\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\n    flowParseTypeOrImplicitInstantiation(): N.FlowType {\n      if (this.state.type === tt.name && 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\n    flowParseTypeAnnotation(): N.TypeAnnotation {\n      const node = this.startNode<N.TypeAnnotation>();\n      node.typeAnnotation = this.flowParseTypeInitialiser();\n      return this.finishNode(node, \"TypeAnnotation\");\n    }\n\n    flowParseTypeAnnotatableIdentifier(\n      allowPrimitiveOverride?: boolean,\n    ): N.Identifier {\n      const ident = allowPrimitiveOverride\n        ? this.parseIdentifier()\n        : this.flowParseRestrictedIdentifier();\n      if (this.match(tt.colon)) {\n        ident.typeAnnotation = this.flowParseTypeAnnotation();\n        this.resetEndLocation(ident);\n      }\n      return ident;\n    }\n\n    typeCastToParameter(node: N.TypeCastExpression): N.Expression {\n      (node.expression as N.Identifier).typeAnnotation = node.typeAnnotation;\n\n      this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);\n\n      return node.expression;\n    }\n\n    flowParseVariance(): N.FlowVariance | undefined | null {\n      let variance = null;\n      if (this.match(tt.plusMin)) {\n        variance = this.startNode<N.FlowVariance>();\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\n    // ==================================\n    // Overrides\n    // ==================================\n\n    parseFunctionBody(\n      node: N.Function,\n      allowExpressionBody?: boolean | null,\n      isMethod: boolean = false,\n    ): void {\n      if (allowExpressionBody) {\n        this.forwardNoArrowParamsConversionAt(node, () =>\n          super.parseFunctionBody(node, true, isMethod),\n        );\n        return;\n      }\n\n      super.parseFunctionBody(node, false, isMethod);\n    }\n\n    parseFunctionBodyAndFinish<\n      T extends\n        | N.Function\n        | N.TSDeclareMethod\n        | N.TSDeclareFunction\n        | N.ClassPrivateMethod,\n    >(node: Undone<T>, type: T[\"type\"], isMethod: boolean = false): T {\n      if (this.match(tt.colon)) {\n        const typeNode = this.startNode<N.TypeAnnotation>();\n\n        [\n          typeNode.typeAnnotation,\n          // @ts-expect-error predicate may not exist\n          node.predicate,\n        ] = this.flowParseTypeAndPredicateInitialiser();\n\n        node.returnType = typeNode.typeAnnotation\n          ? this.finishNode(typeNode, \"TypeAnnotation\")\n          : null;\n      }\n\n      return super.parseFunctionBodyAndFinish(node, type, isMethod);\n    }\n\n    // interfaces and enums\n    parseStatementLike(flags: ParseStatementFlag): N.Statement {\n      // strict mode handling of `interface` since it's a reserved word\n      if (this.state.strict && this.isContextual(tt._interface)) {\n        const lookahead = this.lookahead();\n        if (tokenIsKeywordOrIdentifier(lookahead.type)) {\n          const node = this.startNode<N.FlowInterface>();\n          this.next();\n          return this.flowParseInterface(node);\n        }\n      } else if (this.isContextual(tt._enum)) {\n        const node = this.startNode();\n        this.next();\n        return this.flowParseEnumDeclaration(node);\n      }\n      const stmt = super.parseStatementLike(flags);\n      // We will parse a flow pragma in any comment before the first statement.\n      if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {\n        this.flowPragma = null;\n      }\n      return stmt;\n    }\n\n    // declares, interfaces and type aliases\n    parseExpressionStatement(\n      node: N.ExpressionStatement,\n      expr: N.Expression,\n      decorators: N.Decorator[] | null,\n    ): N.ExpressionStatement {\n      if (expr.type === \"Identifier\") {\n        if (expr.name === \"declare\") {\n          if (\n            this.match(tt._class) ||\n            tokenIsIdentifier(this.state.type) ||\n            this.match(tt._function) ||\n            this.match(tt._var) ||\n            this.match(tt._export)\n          ) {\n            // @ts-expect-error: refine typings\n            return this.flowParseDeclare(node);\n          }\n        } else if (tokenIsIdentifier(this.state.type)) {\n          if (expr.name === \"interface\") {\n            // @ts-expect-error: refine typings\n            return this.flowParseInterface(node);\n          } else if (expr.name === \"type\") {\n            // @ts-expect-error: refine typings\n            return this.flowParseTypeAlias(node);\n          } else if (expr.name === \"opaque\") {\n            // @ts-expect-error: refine typings\n            return this.flowParseOpaqueType(node, false);\n          }\n        }\n      }\n\n      return super.parseExpressionStatement(node, expr, decorators);\n    }\n\n    // export type\n    shouldParseExportDeclaration(): boolean {\n      const { type } = this.state;\n      if (type === tt._enum || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {\n        return !this.state.containsEsc;\n      }\n      return super.shouldParseExportDeclaration();\n    }\n\n    isExportDefaultSpecifier(): boolean {\n      const { type } = this.state;\n      if (type === tt._enum || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {\n        return this.state.containsEsc;\n      }\n\n      return super.isExportDefaultSpecifier();\n    }\n\n    parseExportDefaultExpression() {\n      if (this.isContextual(tt._enum)) {\n        const node = this.startNode();\n        this.next();\n        return this.flowParseEnumDeclaration(node);\n      }\n      return super.parseExportDefaultExpression();\n    }\n\n    parseConditional(\n      expr: N.Expression,\n\n      startLoc: Position,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.Expression {\n      if (!this.match(tt.question)) return expr;\n\n      if (this.state.maybeInArrowParameters) {\n        const nextCh = this.lookaheadCharCode();\n        // These tokens cannot start an expression, so if one of them follows\n        // ? then we are probably in an arrow function parameters list and we\n        // don't parse the conditional expression.\n        if (\n          nextCh === charCodes.comma || // (a?, b) => c\n          nextCh === charCodes.equalsTo || // (a? = b) => c\n          nextCh === charCodes.colon || // (a?: b) => c\n          nextCh === charCodes.rightParenthesis // (a?) => c\n        ) {\n          /*:: invariant(refExpressionErrors != null) */\n          this.setOptionalParametersError(refExpressionErrors);\n          return expr;\n        }\n      }\n\n      this.expect(tt.question);\n      const state = this.state.clone();\n      const originalNoArrowAt = this.state.noArrowAt;\n      const node = this.startNodeAt<N.ConditionalExpression>(startLoc);\n      let { consequent, failed } = this.tryParseConditionalConsequent();\n      let [valid, invalid] = this.getArrowLikeExpressions(consequent);\n\n      if (failed || invalid.length > 0) {\n        const noArrowAt = [...originalNoArrowAt];\n\n        if (invalid.length > 0) {\n          this.state = state;\n          this.state.noArrowAt = noArrowAt;\n\n          for (let i = 0; i < invalid.length; i++) {\n            noArrowAt.push(invalid[i].start);\n          }\n\n          ({ consequent, failed } = this.tryParseConditionalConsequent());\n          [valid, invalid] = this.getArrowLikeExpressions(consequent);\n        }\n\n        if (failed && valid.length > 1) {\n          // if there are two or more possible correct ways of parsing, throw an\n          // error.\n          // e.g.   Source: a ? (b): c => (d): e => f\n          //      Result 1: a ? b : (c => ((d): e => f))\n          //      Result 2: a ? ((b): c => d) : (e => f)\n          this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc);\n        }\n\n        if (failed && valid.length === 1) {\n          this.state = state;\n          noArrowAt.push(valid[0].start);\n          this.state.noArrowAt = noArrowAt;\n          ({ consequent, failed } = this.tryParseConditionalConsequent());\n        }\n      }\n\n      this.getArrowLikeExpressions(consequent, true);\n\n      this.state.noArrowAt = originalNoArrowAt;\n      this.expect(tt.colon);\n\n      node.test = expr;\n      node.consequent = consequent;\n      node.alternate = this.forwardNoArrowParamsConversionAt(node, () =>\n        this.parseMaybeAssign(undefined, undefined),\n      );\n\n      return this.finishNode(node, \"ConditionalExpression\");\n    }\n\n    tryParseConditionalConsequent(): {\n      consequent: N.Expression;\n      failed: boolean;\n    } {\n      this.state.noArrowParamsConversionAt.push(this.state.start);\n\n      const consequent = this.parseMaybeAssignAllowIn();\n      const failed = !this.match(tt.colon);\n\n      this.state.noArrowParamsConversionAt.pop();\n\n      return { consequent, failed };\n    }\n\n    // Given an expression, walks through out its arrow functions whose body is\n    // an expression and through out conditional expressions. It returns every\n    // function which has been parsed with a return type but could have been\n    // parenthesized expressions.\n    // These functions are separated into two arrays: one containing the ones\n    // whose parameters can be converted to assignable lists, one containing the\n    // others.\n    getArrowLikeExpressions(\n      node: N.Expression,\n      disallowInvalid?: boolean,\n    ): [N.ArrowFunctionExpression[], N.ArrowFunctionExpression[]] {\n      const stack = [node];\n      const arrows: N.ArrowFunctionExpression[] = [];\n\n      while (stack.length !== 0) {\n        const node = stack.pop();\n        if (\n          node.type === \"ArrowFunctionExpression\" &&\n          node.body.type !== \"BlockStatement\"\n        ) {\n          if (node.typeParameters || !node.returnType) {\n            // This is an arrow expression without ambiguity, so check its parameters\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\n      if (disallowInvalid) {\n        arrows.forEach(node => this.finishArrowValidation(node));\n        return [arrows, []];\n      }\n\n      return partition(arrows, node =>\n        node.params.every(param => this.isAssignable(param, true)),\n      );\n    }\n\n    finishArrowValidation(node: N.ArrowFunctionExpression) {\n      this.toAssignableList(\n        // node.params is Expression[] instead of $ReadOnlyArray<Pattern> because it\n        // has not been converted yet.\n        node.params as any as N.Expression[],\n        node.extra?.trailingCommaLoc,\n        /* isLHS */ false,\n      );\n      // Enter scope, as checkParams defines bindings\n      this.scope.enter(ScopeFlag.FUNCTION | ScopeFlag.ARROW);\n      // Use super's method to force the parameters to be checked\n      super.checkParams(node, false, true);\n      this.scope.exit();\n    }\n\n    forwardNoArrowParamsConversionAt<T>(\n      node: Undone<N.Node>,\n      parse: () => T,\n    ): T {\n      let result: T;\n      if (\n        this.state.noArrowParamsConversionAt.includes(\n          this.offsetToSourcePos(node.start),\n        )\n      ) {\n        this.state.noArrowParamsConversionAt.push(this.state.start);\n        result = parse();\n        this.state.noArrowParamsConversionAt.pop();\n      } else {\n        result = parse();\n      }\n\n      return result;\n    }\n\n    parseParenItem<T extends N.Expression | N.RestElement | N.SpreadElement>(\n      node: T,\n      startLoc: Position,\n    ): T | N.TypeCastExpression | N.TsTypeCastExpression {\n      const newNode = super.parseParenItem(node, startLoc);\n      if (this.eat(tt.question)) {\n        (newNode as N.Identifier).optional = true;\n        // Include questionmark in location of node\n        // Don't use this.finishNode() as otherwise we might process comments twice and\n        // include already consumed parens\n        this.resetEndLocation(node);\n      }\n\n      if (this.match(tt.colon)) {\n        const typeCastNode = this.startNodeAt<N.TypeCastExpression>(startLoc);\n        typeCastNode.expression = newNode as N.Expression;\n        typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();\n\n        return this.finishNode(typeCastNode, \"TypeCastExpression\");\n      }\n\n      return newNode;\n    }\n\n    assertModuleNodeAllowed(node: N.Node) {\n      if (\n        (node.type === \"ImportDeclaration\" &&\n          (node.importKind === \"type\" || node.importKind === \"typeof\")) ||\n        (node.type === \"ExportNamedDeclaration\" &&\n          node.exportKind === \"type\") ||\n        (node.type === \"ExportAllDeclaration\" && node.exportKind === \"type\")\n      ) {\n        // Allow Flowtype imports and exports in all conditions because\n        // Flow itself does not care about 'sourceType'.\n        return;\n      }\n\n      super.assertModuleNodeAllowed(node);\n    }\n\n    parseExportDeclaration(\n      node: N.ExportNamedDeclaration,\n    ): N.Declaration | undefined | null {\n      if (this.isContextual(tt._type)) {\n        node.exportKind = \"type\";\n\n        const declarationNode = this.startNode();\n        this.next();\n\n        if (this.match(tt.braceL)) {\n          // export type { foo, bar };\n          node.specifiers = this.parseExportSpecifiers(\n            /* isInTypeExport */ true,\n          );\n          super.parseExportFrom(node);\n          return null;\n        } else {\n          // export type Foo = Bar;\n          // @ts-expect-error: refine typings\n          return this.flowParseTypeAlias(declarationNode);\n        }\n      } else if (this.isContextual(tt._opaque)) {\n        node.exportKind = \"type\";\n\n        const declarationNode = this.startNode();\n        this.next();\n        // export opaque type Foo = Bar;\n        // @ts-expect-error: refine typings\n        return this.flowParseOpaqueType(declarationNode, false);\n      } else if (this.isContextual(tt._interface)) {\n        node.exportKind = \"type\";\n        const declarationNode = this.startNode();\n        this.next();\n        // @ts-expect-error: refine typings\n        return this.flowParseInterface(declarationNode);\n      } else if (this.isContextual(tt._enum)) {\n        node.exportKind = \"value\";\n        const declarationNode = this.startNode();\n        this.next();\n        // @ts-expect-error: refine typings\n        return this.flowParseEnumDeclaration(declarationNode);\n      } else {\n        return super.parseExportDeclaration(node);\n      }\n    }\n\n    eatExportStar(\n      node: Undone<N.Node>,\n    ): node is Undone<N.ExportNamedDeclaration | N.ExportAllDeclaration> {\n      if (super.eatExportStar(node)) return true;\n\n      if (this.isContextual(tt._type) && this.lookahead().type === tt.star) {\n        (\n          node as Undone<N.ExportNamedDeclaration | N.ExportAllDeclaration>\n        ).exportKind = \"type\";\n        this.next();\n        this.next();\n        return true;\n      }\n\n      return false;\n    }\n\n    maybeParseExportNamespaceSpecifier(\n      node: Undone<N.ExportNamedDeclaration | N.ExportAllDeclaration>,\n    ): node is Undone<N.ExportNamedDeclaration> {\n      const { startLoc } = this.state;\n      const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);\n      if (hasNamespace && node.exportKind === \"type\") {\n        this.unexpected(startLoc);\n      }\n      return hasNamespace;\n    }\n\n    parseClassId(\n      node: N.Class,\n      isStatement: boolean,\n      optionalId?: boolean | null,\n    ) {\n      super.parseClassId(node, isStatement, optionalId);\n      if (this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n    }\n\n    parseClassMember(\n      classBody: N.ClassBody,\n      member: any,\n      state: N.ParseClassMemberState,\n    ): void {\n      const { startLoc } = this.state;\n      if (this.isContextual(tt._declare)) {\n        if (super.parseClassMemberFromModifier(classBody, member)) {\n          // 'declare' is a class element name\n          return;\n        }\n\n        member.declare = true;\n      }\n\n      super.parseClassMember(classBody, member, state);\n\n      if (member.declare) {\n        if (\n          member.type !== \"ClassProperty\" &&\n          member.type !== \"ClassPrivateProperty\" &&\n          member.type !== \"PropertyDefinition\" // Used by estree plugin\n        ) {\n          this.raise(FlowErrors.DeclareClassElement, startLoc);\n        } else if (member.value) {\n          this.raise(FlowErrors.DeclareClassFieldInitializer, member.value);\n        }\n      }\n    }\n\n    isIterator(word: string): boolean {\n      return word === \"iterator\" || word === \"asyncIterator\";\n    }\n\n    readIterator(): void {\n      const word = super.readWord1();\n      const fullWord = \"@@\" + word;\n\n      // Allow @@iterator and @@asyncIterator as a identifier only inside type\n      if (!this.isIterator(word) || !this.state.inType) {\n        this.raise(Errors.InvalidIdentifier, this.state.curPosition(), {\n          identifierName: fullWord,\n        });\n      }\n\n      this.finishToken(tt.name, fullWord);\n    }\n\n    // ensure that inside flow types, we bypass the jsx parser plugin\n    getTokenFromCode(code: number): void {\n      const next = this.input.charCodeAt(this.state.pos + 1);\n      if (code === charCodes.leftCurlyBrace && next === charCodes.verticalBar) {\n        this.finishOp(tt.braceBarL, 2);\n      } else if (\n        this.state.inType &&\n        (code === charCodes.greaterThan || code === charCodes.lessThan)\n      ) {\n        this.finishOp(code === charCodes.greaterThan ? tt.gt : tt.lt, 1);\n      } else if (this.state.inType && code === charCodes.questionMark) {\n        if (next === charCodes.dot) {\n          this.finishOp(tt.questionDot, 2);\n        } else {\n          // allow double nullable types in Flow: ??string\n          this.finishOp(tt.question, 1);\n        }\n      } else if (\n        isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))\n      ) {\n        this.state.pos += 2; // eat \"@@\"\n        this.readIterator();\n      } else {\n        super.getTokenFromCode(code);\n      }\n    }\n\n    isAssignable(node: N.Node, isBinding?: boolean): boolean {\n      if (node.type === \"TypeCastExpression\") {\n        return this.isAssignable(node.expression, isBinding);\n      } else {\n        return super.isAssignable(node, isBinding);\n      }\n    }\n\n    toAssignable(node: N.Node, isLHS: boolean = false): void {\n      if (\n        !isLHS &&\n        node.type === \"AssignmentExpression\" &&\n        node.left.type === \"TypeCastExpression\"\n      ) {\n        node.left = this.typeCastToParameter(node.left) as N.Assignable;\n      }\n      super.toAssignable(node, isLHS);\n    }\n\n    // turn type casts that we found in function parameter head into type annotated params\n    toAssignableList(\n      exprList: N.Expression[],\n      trailingCommaLoc: Position | undefined | null,\n      isLHS: boolean,\n    ): void {\n      for (let i = 0; i < exprList.length; i++) {\n        const expr = exprList[i];\n        if (expr?.type === \"TypeCastExpression\") {\n          exprList[i] = this.typeCastToParameter(expr);\n        }\n      }\n      super.toAssignableList(exprList, trailingCommaLoc, isLHS);\n    }\n\n    // this is a list of nodes, from something like a call expression, we need to filter the\n    // type casts that we've found that are illegal in this context\n    toReferencedList(\n      exprList:\n        | ReadonlyArray<N.Expression | N.SpreadElement>\n        | ReadonlyArray<N.Expression | N.RestElement>,\n      isParenthesizedExpr?: boolean,\n    ):\n      | ReadonlyArray<N.Expression | N.SpreadElement>\n      | ReadonlyArray<N.Expression | N.RestElement> {\n      for (let i = 0; i < exprList.length; i++) {\n        const expr = exprList[i];\n        if (\n          expr &&\n          expr.type === \"TypeCastExpression\" &&\n          !expr.extra?.parenthesized &&\n          (exprList.length > 1 || !isParenthesizedExpr)\n        ) {\n          this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);\n        }\n      }\n\n      return exprList;\n    }\n\n    parseArrayLike(\n      close: TokenType,\n      canBePattern: boolean,\n      isTuple: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ArrayExpression | N.TupleExpression {\n      const node = super.parseArrayLike(\n        close,\n        canBePattern,\n        isTuple,\n        refExpressionErrors,\n      );\n\n      // This could be an array pattern:\n      //   ([a: string, b: string]) => {}\n      // In this case, we don't have to call toReferencedList. We will\n      // call it, if needed, when we are sure that it is a parenthesized\n      // expression by calling toReferencedListDeep.\n      if (canBePattern && !this.state.maybeInArrowParameters) {\n        this.toReferencedList(node.elements);\n      }\n\n      return node;\n    }\n\n    isValidLVal(type: string, isParenthesized: boolean, binding: BindingFlag) {\n      return (\n        type === \"TypeCastExpression\" ||\n        super.isValidLVal(type, isParenthesized, binding)\n      );\n    }\n\n    // parse class property type annotations\n    parseClassProperty(node: N.ClassProperty): N.ClassProperty {\n      if (this.match(tt.colon)) {\n        node.typeAnnotation = this.flowParseTypeAnnotation();\n      }\n      return super.parseClassProperty(node);\n    }\n\n    parseClassPrivateProperty(\n      node: N.ClassPrivateProperty,\n    ): N.ClassPrivateProperty {\n      if (this.match(tt.colon)) {\n        node.typeAnnotation = this.flowParseTypeAnnotation();\n      }\n      return super.parseClassPrivateProperty(node);\n    }\n\n    // determine whether or not we're currently in the position where a class method would appear\n    isClassMethod(): boolean {\n      return this.match(tt.lt) || super.isClassMethod();\n    }\n\n    // determine whether or not we're currently in the position where a class property would appear\n    isClassProperty(): boolean {\n      return this.match(tt.colon) || super.isClassProperty();\n    }\n\n    isNonstaticConstructor(method: N.ClassMethod | N.ClassProperty): boolean {\n      return !this.match(tt.colon) && super.isNonstaticConstructor(method);\n    }\n\n    // parse type parameters for class methods\n    pushClassMethod(\n      classBody: N.ClassBody,\n      method: N.ClassMethod,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isConstructor: boolean,\n      allowsDirectSuper: boolean,\n    ): void {\n      if ((method as any).variance) {\n        this.unexpected((method as any).variance.loc.start);\n      }\n      delete (method as any).variance;\n      if (this.match(tt.lt)) {\n        method.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n\n      super.pushClassMethod(\n        classBody,\n        method,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowsDirectSuper,\n      );\n\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        // estree support\n      } else if (\n        // @ts-expect-error TS does not know about the fact that estree can replace ClassMethod with MethodDefinition\n        method.type === \"MethodDefinition\" &&\n        isConstructor &&\n        // @ts-expect-error estree\n        method.value.params\n      ) {\n        // @ts-expect-error estree\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\n    pushClassPrivateMethod(\n      classBody: N.ClassBody,\n      method: N.ClassPrivateMethod,\n      isGenerator: boolean,\n      isAsync: boolean,\n    ): void {\n      if ((method as any).variance) {\n        this.unexpected((method as any).variance.loc.start);\n      }\n      delete (method as any).variance;\n      if (this.match(tt.lt)) {\n        method.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n\n      super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);\n    }\n\n    // parse a the super class type parameters and implements\n    parseClassSuper(node: N.Class): void {\n      super.parseClassSuper(node);\n      if (\n        node.superClass &&\n        (this.match(tt.lt) ||\n          // handles `class extends C<<T>`\n          this.match(tt.bitShiftL))\n      ) {\n        if (process.env.BABEL_8_BREAKING) {\n          node.superTypeArguments =\n            this.flowParseTypeParameterInstantiationInExpression();\n        } else {\n          node.superTypeParameters =\n            this.flowParseTypeParameterInstantiationInExpression();\n        }\n      }\n      if (this.isContextual(tt._implements)) {\n        this.next();\n        const implemented: N.FlowClassImplements[] = (node.implements = []);\n        do {\n          const node = this.startNode<N.FlowClassImplements>();\n          node.id = this.flowParseRestrictedIdentifier(/*liberal*/ true);\n          if (this.match(tt.lt)) {\n            node.typeParameters = this.flowParseTypeParameterInstantiation();\n          } else {\n            node.typeParameters = null;\n          }\n          implemented.push(this.finishNode(node, \"ClassImplements\"));\n        } while (this.eat(tt.comma));\n      }\n    }\n\n    checkGetterSetterParams(method: N.ObjectMethod | N.ClassMethod): void {\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\n    parsePropertyNamePrefixOperator(\n      node: N.ObjectOrClassMember | N.ClassMember,\n    ): void {\n      node.variance = this.flowParseVariance();\n    }\n\n    // parse type parameters for object method shorthand\n    parseObjPropValue<T extends N.ObjectMember>(\n      prop: Undone<T>,\n      startLoc: Position | undefined | null,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isPattern: boolean,\n      isAccessor: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): T {\n      if ((prop as any).variance) {\n        this.unexpected((prop as any).variance.loc.start);\n      }\n      delete (prop as any).variance;\n\n      let typeParameters;\n\n      // method shorthand\n      if (this.match(tt.lt) && !isAccessor) {\n        typeParameters = this.flowParseTypeParameterDeclaration();\n        if (!this.match(tt.parenL)) this.unexpected();\n      }\n\n      const result = super.parseObjPropValue(\n        prop,\n        startLoc,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n        refExpressionErrors,\n      );\n\n      // add typeParameters if we found them\n      if (typeParameters) {\n        // @ts-expect-error: refine typings\n        (result.value || result).typeParameters = typeParameters;\n      }\n      return result;\n    }\n\n    parseFunctionParamType(param: N.Pattern): N.Pattern {\n      if (this.eat(tt.question)) {\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\n        (param as any as N.Identifier).optional = true;\n      }\n      if (this.match(tt.colon)) {\n        param.typeAnnotation = this.flowParseTypeAnnotation();\n      } else if (this.isThisParam(param)) {\n        this.raise(FlowErrors.ThisParamAnnotationRequired, param);\n      }\n\n      if (this.match(tt.eq) && this.isThisParam(param)) {\n        this.raise(FlowErrors.ThisParamNoDefault, param);\n      }\n\n      this.resetEndLocation(param);\n      return param;\n    }\n\n    parseMaybeDefault(\n      startLoc?: Position | null,\n      left?: N.Pattern | null,\n    ): N.Pattern {\n      const node = super.parseMaybeDefault(startLoc, left);\n\n      if (\n        node.type === \"AssignmentPattern\" &&\n        node.typeAnnotation &&\n        node.right.start < node.typeAnnotation.start\n      ) {\n        this.raise(FlowErrors.TypeBeforeInitializer, node.typeAnnotation);\n      }\n\n      return node;\n    }\n\n    checkImportReflection(node: Undone<N.ImportDeclaration>) {\n      super.checkImportReflection(node);\n      if (node.module && node.importKind !== \"value\") {\n        this.raise(\n          FlowErrors.ImportReflectionHasImportType,\n          node.specifiers[0].loc.start,\n        );\n      }\n    }\n\n    parseImportSpecifierLocal<\n      T extends\n        | N.ImportSpecifier\n        | N.ImportDefaultSpecifier\n        | N.ImportNamespaceSpecifier,\n    >(node: N.ImportDeclaration, specifier: Undone<T>, type: T[\"type\"]): void {\n      specifier.local = hasTypeImportKind(node)\n        ? this.flowParseRestrictedIdentifier(\n            /* liberal */ true,\n            /* declaration */ true,\n          )\n        : this.parseIdentifier();\n\n      node.specifiers.push(this.finishImportSpecifier(specifier, type));\n    }\n\n    isPotentialImportPhase(isExport: boolean): boolean {\n      if (super.isPotentialImportPhase(isExport)) return true;\n      if (this.isContextual(tt._type)) {\n        if (!isExport) return true;\n        const ch = this.lookaheadCharCode();\n        return ch === charCodes.leftCurlyBrace || ch === charCodes.asterisk;\n      }\n      return !isExport && this.isContextual(tt._typeof);\n    }\n\n    applyImportPhase(\n      node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n      isExport: boolean,\n      phase: string | null,\n      loc?: Position,\n    ): void {\n      super.applyImportPhase(node, isExport, phase, loc);\n      if (isExport) {\n        if (!phase && this.match(tt._default)) {\n          // TODO: Align with our TS AST and always add .exportKind\n          return;\n        }\n        (node as N.ExportNamedDeclaration).exportKind =\n          phase === \"type\" ? phase : \"value\";\n      } else {\n        if (phase === \"type\" && this.match(tt.star)) this.unexpected();\n        (node as N.ImportDeclaration).importKind =\n          phase === \"type\" || phase === \"typeof\" ? phase : \"value\";\n      }\n    }\n\n    // parse import-type/typeof shorthand\n    parseImportSpecifier(\n      specifier: any,\n      importedIsString: boolean,\n      isInTypeOnlyImport: boolean,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      isMaybeTypeOnly: boolean,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      bindingType: BindingFlag | undefined,\n    ): N.ImportSpecifier {\n      const firstIdent = specifier.imported;\n\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\n      let isBinding = false;\n      if (this.isContextual(tt._as) && !this.isLookaheadContextual(\"as\")) {\n        const as_ident = this.parseIdentifier(true);\n        if (\n          specifierTypeKind !== null &&\n          !tokenIsKeywordOrIdentifier(this.state.type)\n        ) {\n          // `import {type as ,` or `import {type as }`\n          specifier.imported = as_ident;\n          specifier.importKind = specifierTypeKind;\n          specifier.local = cloneIdentifier(as_ident);\n        } else {\n          // `import {type as foo`\n          specifier.imported = firstIdent;\n          specifier.importKind = null;\n          specifier.local = this.parseIdentifier();\n        }\n      } else {\n        if (\n          specifierTypeKind !== null &&\n          tokenIsKeywordOrIdentifier(this.state.type)\n        ) {\n          // `import {type foo`\n          specifier.imported = this.parseIdentifier(true);\n          specifier.importKind = specifierTypeKind;\n        } else {\n          if (importedIsString) {\n            /*:: invariant(firstIdent instanceof N.StringLiteral) */\n            throw this.raise(Errors.ImportBindingIsString, specifier, {\n              importName: firstIdent.value,\n            });\n          }\n          /*:: invariant(firstIdent instanceof N.Node) */\n          specifier.imported = firstIdent;\n          specifier.importKind = null;\n        }\n\n        if (this.eatContextual(tt._as)) {\n          specifier.local = this.parseIdentifier();\n        } else {\n          isBinding = true;\n          specifier.local = cloneIdentifier(specifier.imported);\n        }\n      }\n\n      const specifierIsTypeImport = hasTypeImportKind(specifier);\n\n      if (isInTypeOnlyImport && specifierIsTypeImport) {\n        this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);\n      }\n\n      if (isInTypeOnlyImport || specifierIsTypeImport) {\n        this.checkReservedType(\n          specifier.local.name,\n          specifier.local.loc.start,\n          /* declaration */ true,\n        );\n      }\n\n      if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {\n        this.checkReservedWord(\n          specifier.local.name,\n          specifier.loc.start,\n          true,\n          true,\n        );\n      }\n\n      return this.finishImportSpecifier(specifier, \"ImportSpecifier\");\n    }\n\n    parseBindingAtom(): N.Pattern {\n      switch (this.state.type) {\n        case tt._this:\n          // \"this\" may be the name of a parameter, so allow it.\n          return this.parseIdentifier(/* liberal */ true);\n        default:\n          return super.parseBindingAtom();\n      }\n    }\n\n    // parse function type parameters - function foo<T>() {}\n    parseFunctionParams(\n      node: Undone<N.Function>,\n      isConstructor: boolean,\n    ): void {\n      // @ts-expect-error kind may not index node\n      const kind = node.kind;\n      if (kind !== \"get\" && kind !== \"set\" && this.match(tt.lt)) {\n        node.typeParameters = this.flowParseTypeParameterDeclaration();\n      }\n      super.parseFunctionParams(node, isConstructor);\n    }\n\n    // parse flow type annotations on variable declarator heads - let foo: string = bar\n    parseVarId(\n      decl: N.VariableDeclarator,\n      kind: \"var\" | \"let\" | \"const\",\n    ): void {\n      super.parseVarId(decl, kind);\n      if (this.match(tt.colon)) {\n        decl.id.typeAnnotation = this.flowParseTypeAnnotation();\n        this.resetEndLocation(decl.id); // set end position to end of type\n      }\n    }\n\n    // parse the return type of an async arrow function - let foo = (async (): number => {});\n    parseAsyncArrowFromCallExpression(\n      node: N.ArrowFunctionExpression,\n      call: N.CallExpression,\n    ): N.ArrowFunctionExpression {\n      if (this.match(tt.colon)) {\n        const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n        this.state.noAnonFunctionType = true;\n        node.returnType = this.flowParseTypeAnnotation();\n        this.state.noAnonFunctionType = oldNoAnonFunctionType;\n      }\n\n      return super.parseAsyncArrowFromCallExpression(node, call);\n    }\n\n    // todo description\n    shouldParseAsyncArrow(): boolean {\n      return this.match(tt.colon) || super.shouldParseAsyncArrow();\n    }\n\n    // We need to support type parameter declarations for arrow functions. This\n    // is tricky. There are three situations we need to handle\n    //\n    // 1. This is either JSX or an arrow function. We'll try JSX first. If that\n    //    fails, we'll try an arrow function. If that fails, we'll throw the JSX\n    //    error.\n    // 2. This is an arrow function. We'll parse the type parameter declaration,\n    //    parse the rest, make sure the rest is an arrow function, and go from\n    //    there\n    // 3. This is neither. Just call the super method\n    parseMaybeAssign(\n      refExpressionErrors?: ExpressionErrors | null,\n      afterLeftParse?: Function,\n    ): N.Expression {\n      let state = null;\n\n      let jsx;\n\n      if (\n        this.hasPlugin(\"jsx\") &&\n        (this.match(tt.jsxTagStart) || this.match(tt.lt))\n      ) {\n        state = this.state.clone();\n\n        jsx = this.tryParse(\n          () => super.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n          state,\n        );\n\n        /*:: invariant(!jsx.aborted) */\n        /*:: invariant(jsx.node != null) */\n        if (!jsx.error) return jsx.node;\n\n        // Remove `tc.j_expr` and `tc.j_oTag` from context added\n        // by parsing `jsxTagStart` to stop the JSX plugin from\n        // messing with the tokens\n        const { context } = this.state;\n        const currentContext = context[context.length - 1];\n        if (currentContext === tc.j_oTag || currentContext === tc.j_expr) {\n          context.pop();\n        }\n      }\n\n      if (jsx?.error || this.match(tt.lt)) {\n        state = state || this.state.clone();\n\n        let typeParameters: N.TypeParameterDeclaration;\n\n        const arrow = this.tryParse((abort: () => never) => {\n          typeParameters = this.flowParseTypeParameterDeclaration();\n\n          const arrowExpression = this.forwardNoArrowParamsConversionAt(\n            typeParameters,\n            () => {\n              const result = super.parseMaybeAssign(\n                refExpressionErrors,\n                afterLeftParse,\n              );\n\n              this.resetStartLocationFromNode(result, typeParameters);\n\n              return result;\n            },\n          );\n\n          // <T>(() => {});\n          // <T>(() => {}: any);\n          if (arrowExpression.extra?.parenthesized) abort();\n\n          // The above can return a TypeCastExpression when the arrow\n          // expression is not wrapped in parens. See also `this.parseParenItem`.\n          // (<T>() => {}: any);\n          const expr = this.maybeUnwrapTypeCastExpression(arrowExpression);\n\n          if (expr.type !== \"ArrowFunctionExpression\") abort();\n\n          expr.typeParameters = typeParameters;\n          this.resetStartLocationFromNode(expr, typeParameters);\n\n          return arrowExpression;\n        }, state);\n\n        let arrowExpression:\n          | N.ArrowFunctionExpression\n          | N.TypeCastExpression\n          | undefined\n          | null = null;\n\n        if (\n          arrow.node &&\n          this.maybeUnwrapTypeCastExpression(arrow.node).type ===\n            \"ArrowFunctionExpression\"\n        ) {\n          if (!arrow.error && !arrow.aborted) {\n            // <T> async () => {}\n            // @ts-expect-error: refine tryParse typings\n            if (arrow.node.async) {\n              /*:: invariant(typeParameters) */\n              this.raise(\n                FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction,\n                typeParameters,\n              );\n            }\n            return arrow.node;\n          }\n\n          // @ts-expect-error: refine typings\n          arrowExpression = arrow.node;\n        }\n\n        // If we are here, both JSX and Flow parsing attempts failed.\n        // Give the precedence to the JSX error, except if JSX had an\n        // unrecoverable error while Flow didn't.\n        // If the error is recoverable, we can only re-report it if there is\n        // a node we can return.\n\n        if (jsx?.node) {\n          /*:: invariant(jsx.failState) */\n          this.state = jsx.failState;\n          return jsx.node;\n        }\n\n        if (arrowExpression) {\n          /*:: invariant(arrow.failState) */\n          this.state = arrow.failState;\n          return arrowExpression;\n        }\n\n        if (jsx?.thrown) throw jsx.error;\n        if (arrow.thrown) throw arrow.error;\n\n        /*:: invariant(typeParameters) */\n        throw this.raise(\n          FlowErrors.UnexpectedTokenAfterTypeParameter,\n          typeParameters,\n        );\n      }\n\n      return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n    }\n\n    // handle return types for arrow functions\n    parseArrow(\n      node: Undone<N.ArrowFunctionExpression>,\n    ): Undone<N.ArrowFunctionExpression> | undefined | null {\n      if (this.match(tt.colon)) {\n        // @ts-expect-error todo(flow->ts)\n        const result = this.tryParse<N.TypeAnnotation>(() => {\n          const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n          this.state.noAnonFunctionType = true;\n\n          const typeNode = this.startNode<N.TypeAnnotation>();\n\n          [\n            typeNode.typeAnnotation,\n            // @ts-expect-error (destructuring not supported yet)\n            node.predicate,\n          ] = this.flowParseTypeAndPredicateInitialiser();\n\n          this.state.noAnonFunctionType = oldNoAnonFunctionType;\n\n          if (this.canInsertSemicolon()) this.unexpected();\n          if (!this.match(tt.arrow)) this.unexpected();\n\n          return typeNode;\n        });\n\n        if (result.thrown) return null;\n        /*:: invariant(result.node) */\n\n        if (result.error) this.state = result.failState;\n\n        // assign after it is clear it is an arrow\n        // @ts-expect-error todo(flow->ts)\n        node.returnType = result.node.typeAnnotation\n          ? this.finishNode(result.node, \"TypeAnnotation\")\n          : null;\n      }\n\n      return super.parseArrow(node);\n    }\n\n    shouldParseArrow(params: Array<N.Node>): boolean {\n      return this.match(tt.colon) || super.shouldParseArrow(params);\n    }\n\n    setArrowFunctionParameters(\n      node: Undone<N.ArrowFunctionExpression>,\n      params:\n        | Array<N.Expression | N.SpreadElement>\n        | Array<N.Expression | N.RestElement>,\n    ): void {\n      if (\n        this.state.noArrowParamsConversionAt.includes(\n          this.offsetToSourcePos(node.start),\n        )\n      ) {\n        node.params = params as N.ArrowFunctionExpression[\"params\"];\n      } else {\n        super.setArrowFunctionParameters(node, params);\n      }\n    }\n\n    checkParams(\n      node: N.Function,\n      allowDuplicates: boolean,\n      isArrowFunction?: boolean | null,\n      strictModeChanged: boolean = true,\n    ): void {\n      if (\n        isArrowFunction &&\n        this.state.noArrowParamsConversionAt.includes(\n          this.offsetToSourcePos(node.start),\n        )\n      ) {\n        return;\n      }\n\n      // ensure the `this` param is first, if it exists\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\n      super.checkParams(\n        node,\n        allowDuplicates,\n        isArrowFunction,\n        strictModeChanged,\n      );\n    }\n\n    parseParenAndDistinguishExpression(canBeArrow: boolean): N.Expression {\n      return super.parseParenAndDistinguishExpression(\n        canBeArrow &&\n          !this.state.noArrowAt.includes(\n            this.sourceToOffsetPos(this.state.start),\n          ),\n      );\n    }\n\n    parseSubscripts(\n      base: N.Expression,\n      startLoc: Position,\n      noCalls?: boolean | null,\n    ): N.Expression {\n      if (\n        base.type === \"Identifier\" &&\n        base.name === \"async\" &&\n        this.state.noArrowAt.includes(startLoc.index)\n      ) {\n        this.next();\n\n        const node = this.startNodeAt<N.CallExpression>(startLoc);\n        node.callee = base;\n        node.arguments = super.parseCallExpressionArguments(tt.parenR);\n        base = this.finishNode(node, \"CallExpression\");\n      } else if (\n        base.type === \"Identifier\" &&\n        base.name === \"async\" &&\n        this.match(tt.lt)\n      ) {\n        const state = this.state.clone();\n        const arrow = this.tryParse(\n          abort => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(),\n          state,\n        );\n\n        /*:: invariant(arrow.node != null) */\n        // @ts-expect-error: refine tryParse typings\n        if (!arrow.error && !arrow.aborted) return arrow.node;\n\n        const result = this.tryParse(\n          () => super.parseSubscripts(base, startLoc, noCalls),\n          state,\n        );\n\n        if (result.node && !result.error) return result.node;\n\n        if (arrow.node) {\n          this.state = arrow.failState;\n          // @ts-expect-error: refine tryParse typings\n          return arrow.node;\n        }\n\n        if (result.node) {\n          this.state = result.failState;\n          return result.node;\n        }\n\n        throw arrow.error || result.error;\n      }\n\n      return super.parseSubscripts(base, startLoc, noCalls);\n    }\n\n    parseSubscript(\n      base: N.Expression,\n\n      startLoc: Position,\n      noCalls: boolean | undefined | null,\n      subscriptState: N.ParseSubscriptState,\n    ): N.Expression {\n      if (this.match(tt.questionDot) && 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<N.OptionalCallExpression>(startLoc);\n        node.callee = base;\n        node.typeArguments =\n          this.flowParseTypeParameterInstantiationInExpression();\n        this.expect(tt.parenL);\n        node.arguments = this.parseCallExpressionArguments(tt.parenR);\n        node.optional = true;\n        return this.finishCallExpression(node, /* optional */ true);\n      } else if (\n        !noCalls &&\n        this.shouldParseTypes() &&\n        (this.match(tt.lt) ||\n          // also handles `new C<<T>`\n          this.match(tt.bitShiftL))\n      ) {\n        const node = this.startNodeAt<\n          N.OptionalCallExpression | N.CallExpression\n        >(startLoc);\n        node.callee = base;\n\n        const result = this.tryParse(() => {\n          node.typeArguments =\n            this.flowParseTypeParameterInstantiationCallOrNew();\n          this.expect(tt.parenL);\n          node.arguments = super.parseCallExpressionArguments(tt.parenR);\n          if (subscriptState.optionalChainMember) {\n            (node as Undone<N.OptionalCallExpression>).optional = false;\n          }\n          return this.finishCallExpression(\n            node,\n            subscriptState.optionalChainMember,\n          );\n        });\n\n        if (result.node) {\n          if (result.error) this.state = result.failState;\n          return result.node;\n        }\n      }\n\n      return super.parseSubscript(\n        base,\n\n        startLoc,\n        noCalls,\n        subscriptState,\n      );\n    }\n\n    parseNewCallee(node: N.NewExpression): void {\n      super.parseNewCallee(node);\n\n      let targs = null;\n      if (this.shouldParseTypes() && this.match(tt.lt)) {\n        targs = this.tryParse(() =>\n          this.flowParseTypeParameterInstantiationCallOrNew(),\n        ).node;\n      }\n      node.typeArguments = targs;\n    }\n\n    parseAsyncArrowWithTypeParameters(\n      startLoc: Position,\n    ): N.ArrowFunctionExpression | undefined | null {\n      const node = this.startNodeAt<N.ArrowFunctionExpression>(startLoc);\n      this.parseFunctionParams(node, false);\n      if (!this.parseArrow(node)) return;\n      return super.parseArrowExpression(\n        node,\n        /* params */ undefined,\n        /* isAsync */ true,\n      );\n    }\n\n    readToken_mult_modulo(code: number): void {\n      const next = this.input.charCodeAt(this.state.pos + 1);\n      if (\n        code === charCodes.asterisk &&\n        next === charCodes.slash &&\n        this.state.hasFlowComment\n      ) {\n        this.state.hasFlowComment = false;\n        this.state.pos += 2;\n        this.nextToken();\n        return;\n      }\n\n      super.readToken_mult_modulo(code);\n    }\n\n    readToken_pipe_amp(code: number): void {\n      const next = this.input.charCodeAt(this.state.pos + 1);\n      if (\n        code === charCodes.verticalBar &&\n        next === charCodes.rightCurlyBrace\n      ) {\n        // '|}'\n        this.finishOp(tt.braceBarR, 2);\n        return;\n      }\n\n      super.readToken_pipe_amp(code);\n    }\n\n    parseTopLevel(file: N.File, program: N.Program): N.File {\n      const fileNode = super.parseTopLevel(file, program);\n      if (this.state.hasFlowComment) {\n        this.raise(\n          FlowErrors.UnterminatedFlowComment,\n          this.state.curPosition(),\n        );\n      }\n      return fileNode;\n    }\n\n    skipBlockComment(): N.CommentBlock | undefined {\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\n      return super.skipBlockComment(this.state.hasFlowComment ? \"*-/\" : \"*/\");\n    }\n\n    skipFlowComment(): number | false {\n      const { pos } = this.state;\n      let shiftToFirstNonWhiteSpace = 2;\n      while (\n        [charCodes.space, charCodes.tab].includes(\n          // @ts-expect-error testing whether a number is included\n          this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace),\n        )\n      ) {\n        shiftToFirstNonWhiteSpace++;\n      }\n\n      const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);\n      const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);\n\n      if (ch2 === charCodes.colon && ch3 === charCodes.colon) {\n        return shiftToFirstNonWhiteSpace + 2; // check for /*::\n      }\n      if (\n        this.input.slice(\n          shiftToFirstNonWhiteSpace + pos,\n          shiftToFirstNonWhiteSpace + pos + 12,\n        ) === \"flow-include\"\n      ) {\n        return shiftToFirstNonWhiteSpace + 12; // check for /*flow-include\n      }\n      if (ch2 === charCodes.colon && ch3 !== charCodes.colon) {\n        return shiftToFirstNonWhiteSpace; // check for /*:, advance up to :\n      }\n      return false;\n    }\n\n    hasFlowCommentCompletion(): void {\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\n    // Flow enum parsing\n\n    flowEnumErrorBooleanMemberNotInitialized(\n      loc: Position,\n      {\n        enumName,\n        memberName,\n      }: {\n        enumName: string;\n        memberName: string;\n      },\n    ): void {\n      this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, {\n        memberName,\n        enumName,\n      });\n    }\n\n    flowEnumErrorInvalidMemberInitializer(\n      loc: Position,\n      enumContext: EnumContext,\n    ) {\n      return this.raise(\n        !enumContext.explicitType\n          ? FlowErrors.EnumInvalidMemberInitializerUnknownType\n          : enumContext.explicitType === \"symbol\"\n            ? FlowErrors.EnumInvalidMemberInitializerSymbolType\n            : FlowErrors.EnumInvalidMemberInitializerPrimaryType,\n        loc,\n        enumContext,\n      );\n    }\n\n    flowEnumErrorNumberMemberNotInitialized(\n      loc: Position,\n      details: {\n        enumName: string;\n        memberName: string;\n      },\n    ): void {\n      this.raise(FlowErrors.EnumNumberMemberNotInitialized, loc, details);\n    }\n\n    flowEnumErrorStringMemberInconsistentlyInitialized(\n      node: N.Node,\n      details: {\n        enumName: string;\n      },\n    ): void {\n      this.raise(\n        FlowErrors.EnumStringMemberInconsistentlyInitialized,\n        node,\n        details,\n      );\n    }\n\n    flowEnumMemberInit(): EnumMemberInit {\n      const startLoc = this.state.startLoc;\n      const endOfInit = () => this.match(tt.comma) || this.match(tt.braceR);\n      switch (this.state.type) {\n        case tt.num: {\n          const literal = this.parseNumericLiteral(this.state.value);\n          if (endOfInit()) {\n            return { type: \"number\", loc: literal.loc.start, value: literal };\n          }\n          return { type: \"invalid\", loc: startLoc };\n        }\n        case tt.string: {\n          const literal = this.parseStringLiteral(this.state.value);\n          if (endOfInit()) {\n            return { type: \"string\", loc: literal.loc.start, value: literal };\n          }\n          return { type: \"invalid\", loc: startLoc };\n        }\n        case tt._true:\n        case tt._false: {\n          const literal = this.parseBooleanLiteral(this.match(tt._true));\n          if (endOfInit()) {\n            return {\n              type: \"boolean\",\n              loc: literal.loc.start,\n              value: literal,\n            };\n          }\n          return { type: \"invalid\", loc: startLoc };\n        }\n        default:\n          return { type: \"invalid\", loc: startLoc };\n      }\n    }\n\n    flowEnumMemberRaw(): {\n      id: N.Identifier;\n      init: EnumMemberInit;\n    } {\n      const loc = this.state.startLoc;\n      const id = this.parseIdentifier(true);\n      const init = this.eat(tt.eq)\n        ? this.flowEnumMemberInit()\n        : { type: \"none\" as const, loc };\n      return { id, init };\n    }\n\n    flowEnumCheckExplicitTypeMismatch(\n      loc: Position,\n      context: EnumContext,\n      expectedType: EnumExplicitType,\n    ): void {\n      const { explicitType } = context;\n      if (explicitType === null) {\n        return;\n      }\n      if (explicitType !== expectedType) {\n        this.flowEnumErrorInvalidMemberInitializer(loc, context);\n      }\n    }\n\n    flowEnumMembers({\n      enumName,\n      explicitType,\n    }: {\n      enumName: string;\n      explicitType: EnumExplicitType;\n    }): {\n      members: {\n        booleanMembers: Extract<\n          N.FlowEnumMember,\n          { type: \"EnumBooleanMember\" }\n        >[];\n        numberMembers: Extract<\n          N.FlowEnumMember,\n          { type: \"EnumNumberMember\" }\n        >[];\n        stringMembers: Extract<\n          N.FlowEnumMember,\n          { type: \"EnumStringMember\" }\n        >[];\n        defaultedMembers: Extract<\n          N.FlowEnumMember,\n          { type: \"EnumDefaultedMember\" }\n        >[];\n      };\n      hasUnknownMembers: boolean;\n    } {\n      const seenNames = new Set();\n      const members = {\n        // @ts-expect-error: migrate to Babel types\n        booleanMembers: [],\n        // @ts-expect-error: migrate to Babel types\n        numberMembers: [],\n        // @ts-expect-error: migrate to Babel types\n        stringMembers: [],\n        // @ts-expect-error: migrate to Babel types\n        defaultedMembers: [],\n      };\n      let hasUnknownMembers = false;\n      while (!this.match(tt.braceR)) {\n        if (this.eat(tt.ellipsis)) {\n          hasUnknownMembers = true;\n          break;\n        }\n        const memberNode = this.startNode<N.FlowEnumMember>();\n        const { id, init } = 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 = { enumName, explicitType, memberName };\n        memberNode.id = id;\n        switch (init.type) {\n          case \"boolean\": {\n            this.flowEnumCheckExplicitTypeMismatch(\n              init.loc,\n              context,\n              \"boolean\",\n            );\n            memberNode.init = init.value;\n            members.booleanMembers.push(\n              this.finishNode(memberNode, \"EnumBooleanMember\"),\n            );\n            break;\n          }\n          case \"number\": {\n            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"number\");\n            memberNode.init = init.value;\n            members.numberMembers.push(\n              this.finishNode(memberNode, \"EnumNumberMember\"),\n            );\n            break;\n          }\n          case \"string\": {\n            this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"string\");\n            memberNode.init = init.value;\n            members.stringMembers.push(\n              this.finishNode(memberNode, \"EnumStringMember\"),\n            );\n            break;\n          }\n          case \"invalid\": {\n            throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);\n          }\n          case \"none\": {\n            switch (explicitType) {\n              case \"boolean\":\n                this.flowEnumErrorBooleanMemberNotInitialized(\n                  init.loc,\n                  context,\n                );\n                break;\n              case \"number\":\n                this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);\n                break;\n              default:\n                members.defaultedMembers.push(\n                  this.finishNode(memberNode, \"EnumDefaultedMember\"),\n                );\n            }\n          }\n        }\n\n        if (!this.match(tt.braceR)) {\n          this.expect(tt.comma);\n        }\n      }\n      return { members, hasUnknownMembers };\n    }\n\n    flowEnumStringMembers(\n      initializedMembers: Array<N.Node>,\n      defaultedMembers: Array<N.Node>,\n      {\n        enumName,\n      }: {\n        enumName: string;\n      },\n    ): Array<N.Node> {\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\n    flowEnumParseExplicitType({\n      enumName,\n    }: {\n      enumName: string;\n    }): EnumExplicitType {\n      if (!this.eatContextual(tt._of)) return null;\n\n      if (!tokenIsIdentifier(this.state.type)) {\n        throw this.raise(\n          FlowErrors.EnumInvalidExplicitTypeUnknownSupplied,\n          this.state.startLoc,\n          {\n            enumName,\n          },\n        );\n      }\n\n      const { value } = this.state;\n      this.next();\n\n      if (\n        value !== \"boolean\" &&\n        value !== \"number\" &&\n        value !== \"string\" &&\n        value !== \"symbol\"\n      ) {\n        this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, {\n          enumName,\n          invalidEnumType: value,\n        });\n      }\n\n      return value;\n    }\n\n    flowEnumBody(node: Undone<N.FlowEnumBody>, id: N.Identifier): N.Node {\n      const enumName = id.name;\n      const nameLoc = id.loc.start;\n      const explicitType = this.flowEnumParseExplicitType({ enumName });\n      this.expect(tt.braceL);\n      const { members, hasUnknownMembers } = this.flowEnumMembers({\n        enumName,\n        explicitType,\n      });\n      node.hasUnknownMembers = hasUnknownMembers;\n\n      switch (explicitType) {\n        case \"boolean\":\n          node.explicitType = true;\n          node.members = members.booleanMembers;\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumBooleanBody\");\n        case \"number\":\n          node.explicitType = true;\n          node.members = members.numberMembers;\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumNumberBody\");\n        case \"string\":\n          node.explicitType = true;\n          node.members = this.flowEnumStringMembers(\n            members.stringMembers,\n            members.defaultedMembers,\n            { enumName },\n          );\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumStringBody\");\n        case \"symbol\":\n          node.members = members.defaultedMembers;\n          this.expect(tt.braceR);\n          return this.finishNode(node, \"EnumSymbolBody\");\n        default: {\n          // `explicitType` is `null`\n          const empty = () => {\n            node.members = [];\n            this.expect(tt.braceR);\n            return this.finishNode(node, \"EnumStringBody\");\n          };\n          node.explicitType = false;\n\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\n          if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {\n            return empty();\n          } else if (!boolsLen && !numsLen) {\n            node.members = this.flowEnumStringMembers(\n              members.stringMembers,\n              members.defaultedMembers,\n              { enumName },\n            );\n            this.expect(tt.braceR);\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(tt.braceR);\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(tt.braceR);\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\n    flowParseEnumDeclaration(\n      node: Undone<N.FlowEnumDeclaration>,\n    ): N.FlowEnumDeclaration {\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\n    jsxParseOpeningElementAfterName(\n      node: N.JSXOpeningElement,\n    ): N.JSXOpeningElement {\n      if (this.shouldParseTypes()) {\n        if (this.match(tt.lt) || this.match(tt.bitShiftL)) {\n          node.typeArguments =\n            this.flowParseTypeParameterInstantiationInExpression();\n        }\n      }\n\n      return super.jsxParseOpeningElementAfterName(node);\n    }\n\n    // check if the next token is a tt.lt\n    isLookaheadToken_lt(): boolean {\n      const next = this.nextTokenStart();\n      if (this.input.charCodeAt(next) === charCodes.lessThan) {\n        const afterNext = this.input.charCodeAt(next + 1);\n        return (\n          afterNext !== charCodes.lessThan && afterNext !== charCodes.equalsTo\n        );\n      }\n      return false;\n    }\n\n    // used after we have finished parsing types\n    reScan_lt_gt() {\n      const { type } = this.state;\n      if (type === tt.lt) {\n        this.state.pos -= 1;\n        this.readToken_lt();\n      } else if (type === tt.gt) {\n        this.state.pos -= 1;\n        this.readToken_gt();\n      }\n    }\n\n    reScan_lt() {\n      const { type } = this.state;\n      if (type === tt.bitShiftL) {\n        this.state.pos -= 2;\n        this.finishOp(tt.lt, 1);\n        return tt.lt;\n      }\n      return type;\n    }\n\n    maybeUnwrapTypeCastExpression(node: N.Node) {\n      return node.type === \"TypeCastExpression\" ? node.expression : node;\n    }\n  };\n","const entities: {\n  __proto__: null;\n  [name: string]: string;\n} = {\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} as const;\nexport default entities;\n","import * as charCodes from \"charcodes\";\n\nimport XHTMLEntities from \"./xhtml.ts\";\nimport type Parser from \"../../parser/index.ts\";\nimport type { ExpressionErrors } from \"../../parser/util.ts\";\nimport {\n  tokenComesBeforeExpression,\n  tokenIsKeyword,\n  tokenLabelName,\n  type TokenType,\n  tt,\n} from \"../../tokenizer/types.ts\";\nimport type { TokContext } from \"../../tokenizer/context.ts\";\nimport { types as tc } from \"../../tokenizer/context.ts\";\nimport type * as N from \"../../types.ts\";\nimport { isIdentifierChar, isIdentifierStart } from \"../../util/identifier.ts\";\nimport type { Position } from \"../../util/location.ts\";\nimport { isNewLine } from \"../../util/whitespace.ts\";\nimport { Errors, ParseErrorEnum } from \"../../parse-error.ts\";\nimport type { Undone } from \"../../parser/node.ts\";\n\n/* eslint sort-keys: \"error\" */\nconst JsxErrors = ParseErrorEnum`jsx`({\n  AttributeIsEmpty:\n    \"JSX attributes must only be assigned a non-empty expression.\",\n  MissingClosingTagElement: ({ openingTagName }: { openingTagName: string }) =>\n    `Expected corresponding JSX closing tag for <${openingTagName}>.`,\n  MissingClosingTagFragment: \"Expected corresponding JSX closing tag for <>.\",\n  UnexpectedSequenceExpression:\n    \"Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?\",\n  // FIXME: Unify with Errors.UnexpectedToken\n  UnexpectedToken: ({\n    unexpected,\n    HTMLEntity,\n  }: {\n    unexpected: string;\n    HTMLEntity: string;\n  }) =>\n    `Unexpected token \\`${unexpected}\\`. Did you mean \\`${HTMLEntity}\\` or \\`{'${unexpected}'}\\`?`,\n  UnsupportedJsxValue:\n    \"JSX value should be either an expression or a quoted JSX text.\",\n  UnterminatedJsxContent: \"Unterminated JSX contents.\",\n  UnwrappedAdjacentJSXElements:\n    \"Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?\",\n});\n\n/* eslint-disable sort-keys */\n\nfunction isFragment(object?: N.JSXTag | null): object is N.JSXFragmentTag {\n  return object\n    ? object.type === \"JSXOpeningFragment\" ||\n        object.type === \"JSXClosingFragment\"\n    : false;\n}\n\n// Transforms JSX element name to string.\n\nfunction getQualifiedJSXName(\n  object: N.JSXIdentifier | N.JSXNamespacedName | N.JSXMemberExpression,\n): string {\n  if (object.type === \"JSXIdentifier\") {\n    return object.name;\n  }\n\n  if (object.type === \"JSXNamespacedName\") {\n    return object.namespace.name + \":\" + object.name.name;\n  }\n\n  if (object.type === \"JSXMemberExpression\") {\n    return (\n      getQualifiedJSXName(object.object) +\n      \".\" +\n      getQualifiedJSXName(object.property)\n    );\n  }\n\n  // istanbul ignore next\n  // @ts-expect-error - object is 'never'\n  throw new Error(\"Node had unexpected type: \" + object.type);\n}\n\nexport interface IJSXParserMixin {\n  jsxParseOpeningElementAfterName(\n    node: N.JSXOpeningElement,\n  ): N.JSXOpeningElement;\n}\n\nexport type ClassWithMixin<\n  T extends new (...args: any) => any,\n  M extends object,\n> = T extends new (...args: infer P) => infer I\n  ? new (...args: P) => I & M\n  : never;\n\nexport default (superClass: typeof Parser) =>\n  class JSXParserMixin extends superClass implements Parser, IJSXParserMixin {\n    // Reads inline JSX contents token.\n\n    jsxReadToken(): void {\n      let out = \"\";\n      let chunkStart = this.state.pos;\n      for (;;) {\n        if (this.state.pos >= this.length) {\n          throw this.raise(\n            JsxErrors.UnterminatedJsxContent,\n            this.state.startLoc,\n          );\n        }\n\n        const ch = this.input.charCodeAt(this.state.pos);\n\n        switch (ch) {\n          case charCodes.lessThan:\n          case charCodes.leftCurlyBrace:\n            if (this.state.pos === this.state.start) {\n              if (ch === charCodes.lessThan && this.state.canStartJSXElement) {\n                ++this.state.pos;\n                this.finishToken(tt.jsxTagStart);\n              } else {\n                super.getTokenFromCode(ch);\n              }\n              return;\n            }\n            out += this.input.slice(chunkStart, this.state.pos);\n            this.finishToken(tt.jsxText, out);\n            return;\n\n          case charCodes.ampersand:\n            out += this.input.slice(chunkStart, this.state.pos);\n            out += this.jsxReadEntity();\n            chunkStart = this.state.pos;\n            break;\n\n          case charCodes.greaterThan:\n          case charCodes.rightCurlyBrace:\n            if (process.env.BABEL_8_BREAKING) {\n              this.raise(JsxErrors.UnexpectedToken, this.state.curPosition(), {\n                unexpected: this.input[this.state.pos],\n                HTMLEntity:\n                  ch === charCodes.rightCurlyBrace ? \"&rbrace;\" : \"&gt;\",\n              });\n            }\n          /* falls through */\n\n          default:\n            if (isNewLine(ch)) {\n              out += this.input.slice(chunkStart, this.state.pos);\n              out += this.jsxReadNewLine(true);\n              chunkStart = this.state.pos;\n            } else {\n              ++this.state.pos;\n            }\n        }\n      }\n    }\n\n    jsxReadNewLine(normalizeCRLF: boolean): string {\n      const ch = this.input.charCodeAt(this.state.pos);\n      let out;\n      ++this.state.pos;\n      if (\n        ch === charCodes.carriageReturn &&\n        this.input.charCodeAt(this.state.pos) === charCodes.lineFeed\n      ) {\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\n      return out;\n    }\n\n    jsxReadString(quote: number): void {\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\n        const ch = this.input.charCodeAt(this.state.pos);\n        if (ch === quote) break;\n        if (ch === charCodes.ampersand) {\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(tt.string, out);\n    }\n\n    jsxReadEntity(): string {\n      const startPos = ++this.state.pos;\n      if (this.codePointAtPos(this.state.pos) === charCodes.numberSign) {\n        ++this.state.pos;\n\n        let radix = 10;\n        if (this.codePointAtPos(this.state.pos) === charCodes.lowercaseX) {\n          radix = 16;\n          ++this.state.pos;\n        }\n\n        const codePoint = this.readInt(\n          radix,\n          /* len */ undefined,\n          /* forceLen */ false,\n          /* allowNumSeparator */ \"bail\",\n        );\n        if (\n          codePoint !== null &&\n          this.codePointAtPos(this.state.pos) === charCodes.semicolon\n        ) {\n          ++this.state.pos;\n          return String.fromCodePoint(codePoint);\n        }\n      } else {\n        let count = 0;\n        let semi = false;\n        while (\n          count++ < 10 &&\n          this.state.pos < this.length &&\n          !(semi = this.codePointAtPos(this.state.pos) === charCodes.semicolon)\n        ) {\n          ++this.state.pos;\n        }\n\n        if (semi) {\n          const desc = this.input.slice(startPos, this.state.pos);\n          const entity = XHTMLEntities[desc];\n          ++this.state.pos;\n\n          if (entity) {\n            return entity;\n          }\n        }\n      }\n\n      // Not a valid entity\n      this.state.pos = startPos;\n      return \"&\";\n    }\n\n    // Read a JSX identifier (valid tag or attribute name).\n    //\n    // Optimized version since JSX identifiers can\"t contain\n    // escape characters and so can be read as single slice.\n    // Also assumes that first character was already checked\n    // by isIdentifierStart in readToken.\n\n    jsxReadWord(): void {\n      let ch;\n      const start = this.state.pos;\n      do {\n        ch = this.input.charCodeAt(++this.state.pos);\n      } while (isIdentifierChar(ch) || ch === charCodes.dash);\n      this.finishToken(tt.jsxName, this.input.slice(start, this.state.pos));\n    }\n\n    // Parse next token as JSX identifier\n\n    jsxParseIdentifier(): N.JSXIdentifier {\n      const node = this.startNode<N.JSXIdentifier>();\n      if (this.match(tt.jsxName)) {\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\n    // Parse namespaced identifier.\n\n    jsxParseNamespacedName(): N.JSXNamespacedName | N.JSXIdentifier {\n      const startLoc = this.state.startLoc;\n      const name = this.jsxParseIdentifier();\n      if (!this.eat(tt.colon)) return name;\n\n      const node = this.startNodeAt<N.JSXNamespacedName>(startLoc);\n      node.namespace = name;\n      node.name = this.jsxParseIdentifier();\n      return this.finishNode(node, \"JSXNamespacedName\");\n    }\n\n    // Parses element name in any form - namespaced, member\n    // or single identifier.\n\n    jsxParseElementName():\n      | N.JSXIdentifier\n      | N.JSXNamespacedName\n      | N.JSXMemberExpression {\n      const startLoc = this.state.startLoc;\n      let node: N.JSXIdentifier | N.JSXNamespacedName | N.JSXMemberExpression =\n        this.jsxParseNamespacedName();\n      if (node.type === \"JSXNamespacedName\") {\n        return node;\n      }\n      while (this.eat(tt.dot)) {\n        const newNode = this.startNodeAt<N.JSXMemberExpression>(startLoc);\n        newNode.object = node;\n        newNode.property = this.jsxParseIdentifier();\n        node = this.finishNode(newNode, \"JSXMemberExpression\");\n      }\n      return node;\n    }\n\n    // Parses any type of JSX attribute value.\n\n    jsxParseAttributeValue():\n      | N.JSXExpressionContainer\n      | N.JSXElement\n      | N.StringLiteral {\n      let node;\n      switch (this.state.type) {\n        case tt.braceL:\n          node = this.startNode();\n          this.setContext(tc.brace);\n          this.next();\n          node = this.jsxParseExpressionContainer(node, tc.j_oTag);\n          if (node.expression.type === \"JSXEmptyExpression\") {\n            this.raise(JsxErrors.AttributeIsEmpty, node);\n          }\n          return node;\n\n        case tt.jsxTagStart:\n        case tt.string:\n          return this.parseExprAtom() as N.JSXElement | N.StringLiteral;\n\n        default:\n          throw this.raise(JsxErrors.UnsupportedJsxValue, this.state.startLoc);\n      }\n    }\n\n    // JSXEmptyExpression is unique type since it doesn't actually parse anything,\n    // and so it should start at the end of last read token (left brace) and finish\n    // at the beginning of the next one (right brace).\n\n    jsxParseEmptyExpression(): N.JSXEmptyExpression {\n      const node = this.startNodeAt(this.state.lastTokEndLoc);\n      return this.finishNodeAt(node, \"JSXEmptyExpression\", this.state.startLoc);\n    }\n\n    // Parse JSX spread child\n\n    jsxParseSpreadChild(node: Undone<N.JSXSpreadChild>): N.JSXSpreadChild {\n      this.next(); // ellipsis\n      node.expression = this.parseExpression();\n      this.setContext(tc.j_expr);\n      this.state.canStartJSXElement = true;\n      this.expect(tt.braceR);\n\n      return this.finishNode(node, \"JSXSpreadChild\");\n    }\n\n    // Parses JSX expression enclosed into curly brackets.\n\n    jsxParseExpressionContainer(\n      node: Undone<N.JSXExpressionContainer>,\n      previousContext: TokContext,\n    ): N.JSXExpressionContainer {\n      if (this.match(tt.braceR)) {\n        node.expression = this.jsxParseEmptyExpression();\n      } else {\n        const expression = this.parseExpression();\n\n        if (process.env.BABEL_8_BREAKING) {\n          if (\n            expression.type === \"SequenceExpression\" &&\n            !expression.extra?.parenthesized\n          ) {\n            this.raise(\n              JsxErrors.UnexpectedSequenceExpression,\n              expression.expressions[1],\n            );\n          }\n        }\n\n        node.expression = expression;\n      }\n      this.setContext(previousContext);\n      this.state.canStartJSXElement = true;\n      this.expect(tt.braceR);\n\n      return this.finishNode(node, \"JSXExpressionContainer\");\n    }\n\n    // Parses following JSX attribute name-value pair.\n\n    jsxParseAttribute(): N.JSXAttribute | N.JSXSpreadAttribute {\n      const node = this.startNode<N.JSXAttribute | N.JSXSpreadAttribute>();\n      if (this.match(tt.braceL)) {\n        this.setContext(tc.brace);\n        this.next();\n        this.expect(tt.ellipsis);\n        node.argument = this.parseMaybeAssignAllowIn();\n        this.setContext(tc.j_oTag);\n        this.state.canStartJSXElement = true;\n        this.expect(tt.braceR);\n        return this.finishNode(node, \"JSXSpreadAttribute\");\n      }\n      node.name = this.jsxParseNamespacedName();\n      node.value = this.eat(tt.eq) ? this.jsxParseAttributeValue() : null;\n      return this.finishNode(node, \"JSXAttribute\");\n    }\n\n    // Parses JSX opening tag starting after \"<\".\n\n    jsxParseOpeningElementAt(\n      startLoc: Position,\n    ): N.JSXOpeningElement | N.JSXOpeningFragment {\n      const node = this.startNodeAt<N.JSXOpeningElement | N.JSXOpeningFragment>(\n        startLoc,\n      );\n      if (this.eat(tt.jsxTagEnd)) {\n        return this.finishNode(node, \"JSXOpeningFragment\");\n      }\n      node.name = this.jsxParseElementName();\n      return this.jsxParseOpeningElementAfterName(\n        node as Undone<N.JSXOpeningElement>,\n      );\n    }\n\n    jsxParseOpeningElementAfterName(\n      node: Undone<N.JSXOpeningElement>,\n    ): N.JSXOpeningElement {\n      const attributes: (N.JSXAttribute | N.JSXSpreadAttribute)[] = [];\n      while (!this.match(tt.slash) && !this.match(tt.jsxTagEnd)) {\n        attributes.push(this.jsxParseAttribute());\n      }\n      node.attributes = attributes;\n      node.selfClosing = this.eat(tt.slash);\n      this.expect(tt.jsxTagEnd);\n      return this.finishNode(node, \"JSXOpeningElement\");\n    }\n\n    // Parses JSX closing tag starting after \"</\".\n\n    jsxParseClosingElementAt(\n      startLoc: Position,\n    ): N.JSXClosingElement | N.JSXClosingFragment {\n      const node = this.startNodeAt<N.JSXClosingFragment | N.JSXClosingElement>(\n        startLoc,\n      );\n      if (this.eat(tt.jsxTagEnd)) {\n        return this.finishNode(node, \"JSXClosingFragment\");\n      }\n      node.name = this.jsxParseElementName();\n      this.expect(tt.jsxTagEnd);\n      return this.finishNode(node, \"JSXClosingElement\");\n    }\n\n    // Parses entire JSX element, including it\"s opening tag\n    // (starting after \"<\"), attributes, contents and closing tag.\n\n    jsxParseElementAt(startLoc: Position): N.JSXElement | N.JSXFragment {\n      const node = this.startNodeAt<N.JSXElement | N.JSXFragment>(startLoc);\n      const children = [];\n      const openingElement = this.jsxParseOpeningElementAt(startLoc);\n      let closingElement = null;\n\n      if (!openingElement.selfClosing) {\n        contents: for (;;) {\n          switch (this.state.type) {\n            case tt.jsxTagStart:\n              startLoc = this.state.startLoc;\n              this.next();\n              if (this.eat(tt.slash)) {\n                closingElement = this.jsxParseClosingElementAt(startLoc);\n                break contents;\n              }\n              children.push(this.jsxParseElementAt(startLoc));\n              break;\n\n            case tt.jsxText:\n              children.push(this.parseLiteral(this.state.value, \"JSXText\"));\n              break;\n\n            case tt.braceL: {\n              const node = this.startNode<\n                N.JSXSpreadChild | N.JSXExpressionContainer\n              >();\n              this.setContext(tc.brace);\n              this.next();\n              if (this.match(tt.ellipsis)) {\n                children.push(this.jsxParseSpreadChild(node));\n              } else {\n                children.push(\n                  this.jsxParseExpressionContainer(node, tc.j_expr),\n                );\n              }\n\n              break;\n            }\n            // istanbul ignore next - should never happen\n            default:\n              this.unexpected();\n          }\n        }\n\n        if (\n          isFragment(openingElement) &&\n          !isFragment(closingElement) &&\n          closingElement !== null\n        ) {\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 (\n            getQualifiedJSXName(closingElement.name) !==\n            getQualifiedJSXName(openingElement.name)\n          ) {\n            this.raise(JsxErrors.MissingClosingTagElement, closingElement, {\n              openingTagName: getQualifiedJSXName(openingElement.name),\n            });\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(tt.lt)) {\n        throw this.raise(\n          JsxErrors.UnwrappedAdjacentJSXElements,\n          this.state.startLoc,\n        );\n      }\n\n      return isFragment(openingElement)\n        ? this.finishNode(node, \"JSXFragment\")\n        : this.finishNode(node, \"JSXElement\");\n    }\n\n    // Parses entire JSX element from current position.\n\n    jsxParseElement(): N.JSXElement | N.JSXFragment {\n      const startLoc = this.state.startLoc;\n      this.next();\n      return this.jsxParseElementAt(startLoc);\n    }\n\n    setContext(newContext: TokContext) {\n      const { context } = this.state;\n      context[context.length - 1] = newContext;\n    }\n\n    // ==================================\n    // Overrides\n    // ==================================\n\n    parseExprAtom(refExpressionErrors?: ExpressionErrors | null): N.Expression {\n      if (this.match(tt.jsxTagStart)) {\n        return this.jsxParseElement();\n      } else if (\n        this.match(tt.lt) &&\n        this.input.charCodeAt(this.state.pos) !== charCodes.exclamationMark\n      ) {\n        // In case we encounter an lt token here it will always be the start of\n        // jsx as the lt sign is not allowed in places that expect an expression\n        this.replaceToken(tt.jsxTagStart);\n        return this.jsxParseElement();\n      } else {\n        return super.parseExprAtom(refExpressionErrors);\n      }\n    }\n\n    skipSpace() {\n      const curContext = this.curContext();\n      if (!curContext.preserveSpace) super.skipSpace();\n    }\n\n    getTokenFromCode(code: number): void {\n      const context = this.curContext();\n\n      if (context === tc.j_expr) {\n        this.jsxReadToken();\n        return;\n      }\n\n      if (context === tc.j_oTag || context === tc.j_cTag) {\n        if (isIdentifierStart(code)) {\n          this.jsxReadWord();\n          return;\n        }\n\n        if (code === charCodes.greaterThan) {\n          ++this.state.pos;\n          this.finishToken(tt.jsxTagEnd);\n          return;\n        }\n\n        if (\n          (code === charCodes.quotationMark || code === charCodes.apostrophe) &&\n          context === tc.j_oTag\n        ) {\n          this.jsxReadString(code);\n          return;\n        }\n      }\n\n      if (\n        code === charCodes.lessThan &&\n        this.state.canStartJSXElement &&\n        this.input.charCodeAt(this.state.pos + 1) !== charCodes.exclamationMark\n      ) {\n        ++this.state.pos;\n        this.finishToken(tt.jsxTagStart);\n        return;\n      }\n\n      super.getTokenFromCode(code);\n    }\n\n    updateContext(prevType: TokenType): void {\n      const { context, type } = this.state;\n      if (type === tt.slash && prevType === tt.jsxTagStart) {\n        // do not consider JSX expr -> JSX open tag -> ... anymore\n        // reconsider as closing tag context\n        context.splice(-2, 2, tc.j_cTag);\n        this.state.canStartJSXElement = false;\n      } else if (type === tt.jsxTagStart) {\n        // start opening tag context\n        context.push(tc.j_oTag);\n      } else if (type === tt.jsxTagEnd) {\n        const out = context[context.length - 1];\n        if ((out === tc.j_oTag && prevType === tt.slash) || out === tc.j_cTag) {\n          context.pop();\n          this.state.canStartJSXElement =\n            context[context.length - 1] === tc.j_expr;\n        } else {\n          this.setContext(tc.j_expr);\n          this.state.canStartJSXElement = true;\n        }\n      } else {\n        this.state.canStartJSXElement = tokenComesBeforeExpression(type);\n      }\n    }\n  };\n","import type { Position } from \"../../util/location.ts\";\nimport ScopeHandler, { NameType, Scope } from \"../../util/scope.ts\";\nimport { BindingFlag, ScopeFlag } from \"../../util/scopeflags.ts\";\nimport type * as N from \"../../types.ts\";\nimport { Errors } from \"../../parse-error.ts\";\n\nconst enum TsNameType {\n  Types = 1 << 0,\n  // enums (which are also in .types)\n  Enums = 1 << 1,\n  // const enums (which are also in .enums and .types)\n  ConstEnums = 1 << 2,\n  // classes (which are also in .lexical) and interface (which are also in .types)\n  Classes = 1 << 3,\n  // namespaces and ambient functions (or classes) are too difficult to track,\n  // especially without type analysis.\n  // We need to track them anyway, to avoid \"X is not defined\" errors\n  // when exporting them.\n  ExportOnlyBindings = 1 << 4,\n}\n\nclass TypeScriptScope extends Scope {\n  tsNames: Map<string, TsNameType> = new Map();\n}\n\n// See https://github.com/babel/babel/pull/9766#discussion_r268920730 for an\n// explanation of how typescript handles scope.\n\nexport default class TypeScriptScopeHandler extends ScopeHandler<TypeScriptScope> {\n  importsStack: Set<string>[] = [];\n\n  createScope(flags: ScopeFlag): TypeScriptScope {\n    this.importsStack.push(new Set()); // Always keep the top-level scope for export checks.\n\n    return new TypeScriptScope(flags);\n  }\n\n  enter(flags: ScopeFlag): void {\n    if (flags === ScopeFlag.TS_MODULE) {\n      this.importsStack.push(new Set());\n    }\n\n    super.enter(flags);\n  }\n\n  exit() {\n    const flags = super.exit();\n\n    if (flags === ScopeFlag.TS_MODULE) {\n      this.importsStack.pop();\n    }\n\n    return flags;\n  }\n\n  hasImport(name: string, allowShadow?: boolean) {\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\n  declareName(name: string, bindingType: BindingFlag, loc: Position) {\n    if (bindingType & BindingFlag.FLAG_TS_IMPORT) {\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\n    const scope = this.currentScope();\n    let type = scope.tsNames.get(name) || 0;\n\n    if (bindingType & BindingFlag.FLAG_TS_EXPORT_ONLY) {\n      this.maybeExportDefined(scope, name);\n      scope.tsNames.set(name, type | TsNameType.ExportOnlyBindings);\n      return;\n    }\n\n    super.declareName(name, bindingType, loc);\n\n    if (bindingType & BindingFlag.KIND_TYPE) {\n      if (!(bindingType & BindingFlag.KIND_VALUE)) {\n        // \"Value\" bindings have already been registered by the superclass.\n        this.checkRedeclarationInScope(scope, name, bindingType, loc);\n        this.maybeExportDefined(scope, name);\n      }\n      type = type | TsNameType.Types;\n    }\n    if (bindingType & BindingFlag.FLAG_TS_ENUM) {\n      type = type | TsNameType.Enums;\n    }\n    if (bindingType & BindingFlag.FLAG_TS_CONST_ENUM) {\n      type = type | TsNameType.ConstEnums;\n    }\n    if (bindingType & BindingFlag.FLAG_CLASS) {\n      type = type | TsNameType.Classes;\n    }\n    if (type) scope.tsNames.set(name, type);\n  }\n\n  isRedeclaredInScope(\n    scope: TypeScriptScope,\n    name: string,\n    bindingType: BindingFlag,\n  ): boolean {\n    const type = scope.tsNames.get(name);\n    if ((type & TsNameType.Enums) > 0) {\n      if (bindingType & BindingFlag.FLAG_TS_ENUM) {\n        // Enums can be merged with other enums if they are both\n        //  const or both non-const.\n        const isConst = !!(bindingType & BindingFlag.FLAG_TS_CONST_ENUM);\n        const wasConst = (type & TsNameType.ConstEnums) > 0;\n        return isConst !== wasConst;\n      }\n      return true;\n    }\n    if (\n      bindingType & BindingFlag.FLAG_CLASS &&\n      (type & TsNameType.Classes) > 0\n    ) {\n      if (scope.names.get(name) & NameType.Lexical) {\n        // Classes can be merged with interfaces\n        return !!(bindingType & BindingFlag.KIND_VALUE);\n      } else {\n        // Interface can be merged with other classes or interfaces\n        return false;\n      }\n    }\n    if (bindingType & BindingFlag.KIND_TYPE && (type & TsNameType.Types) > 0) {\n      return true;\n    }\n\n    return super.isRedeclaredInScope(scope, name, bindingType);\n  }\n\n  checkLocalExport(id: N.Identifier) {\n    const { name } = id;\n\n    if (this.hasImport(name)) return;\n\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 (\n        (type & TsNameType.Types) > 0 ||\n        (type & TsNameType.ExportOnlyBindings) > 0\n      ) {\n        return;\n      }\n    }\n\n    super.checkLocalExport(id);\n  }\n}\n","import * as charCodes from \"charcodes\";\nimport { tt, type TokenType } from \"../tokenizer/types.ts\";\nimport type {\n  AssignmentPattern,\n  TSParameterProperty,\n  Decorator,\n  Expression,\n  Identifier,\n  Node,\n  Pattern,\n  RestElement,\n  SpreadElement,\n  ObjectOrClassMember,\n  ClassMember,\n  ObjectMember,\n  TsNamedTypeElementBase,\n  PrivateName,\n  ObjectExpression,\n  ObjectPattern,\n  ArrayPattern,\n  AssignmentProperty,\n  Assignable,\n} from \"../types.ts\";\nimport type { Pos, Position } from \"../util/location.ts\";\nimport {\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n} from \"../util/identifier.ts\";\nimport { NodeUtils, type Undone } from \"./node.ts\";\nimport { BindingFlag } from \"../util/scopeflags.ts\";\nimport type { ExpressionErrors } from \"./util.ts\";\nimport { Errors, type LValAncestor } from \"../parse-error.ts\";\nimport type Parser from \"./index.ts\";\n\nconst unwrapParenthesizedExpression = (node: Node): Node => {\n  return node.type === \"ParenthesizedExpression\"\n    ? unwrapParenthesizedExpression(node.expression)\n    : node;\n};\n\nexport const enum ParseBindingListFlags {\n  ALLOW_EMPTY = 1 << 0,\n  IS_FUNCTION_PARAMS = 1 << 1,\n  IS_CONSTRUCTOR_PARAMS = 1 << 2,\n}\n\nexport default abstract class LValParser extends NodeUtils {\n  // Forward-declaration: defined in expression.js\n  abstract parseIdentifier(liberal?: boolean): Identifier;\n  abstract parseMaybeAssign(\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n    refNeedsArrowPos?: Pos | null,\n  ): Expression;\n\n  abstract parseMaybeAssignAllowIn(\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n    refNeedsArrowPos?: Pos | null,\n  ): Expression;\n\n  abstract parseObjectLike<T extends ObjectPattern | ObjectExpression>(\n    close: TokenType,\n    isPattern: boolean,\n    isRecord?: boolean,\n    refExpressionErrors?: ExpressionErrors,\n  ): T;\n  abstract parseObjPropValue(\n    prop: any,\n    startLoc: Position | null,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isPattern: boolean,\n    isAccessor: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): void;\n  abstract parsePropertyName(\n    prop: ObjectOrClassMember | ClassMember | TsNamedTypeElementBase,\n  ): void;\n  abstract parsePrivateName(): PrivateName;\n  // Forward-declaration: defined in statement.js\n  abstract parseDecorator(): Decorator;\n\n  /**\n   * Convert existing expression atom to assignable pattern\n   * if possible. Also checks invalid destructuring targets:\n   *\n   * - Parenthesized Destructuring patterns\n   * - RestElement is not the last element\n   * - Missing `=` in assignment pattern\n   *\n   * NOTE: There is a corresponding \"isAssignable\" method.\n   * When this one is updated, please check if also that one needs to be updated.\n   *\n   * @param node The expression atom\n   * @param isLHS Whether we are parsing a LeftHandSideExpression.\n   *              If isLHS is `true`, the following cases are allowed: `[(a)] = [0]`, `[(a.b)] = [0]`\n   *              If isLHS is `false`, we are in an arrow function parameters list.\n   */\n  toAssignable(node: Node, isLHS: boolean = false): asserts node is Assignable {\n    let parenthesized = undefined;\n    if (node.type === \"ParenthesizedExpression\" || node.extra?.parenthesized) {\n      parenthesized = unwrapParenthesizedExpression(node);\n      if (isLHS) {\n        // an LHS can be reinterpreted to a binding pattern but not vice versa.\n        // therefore a parenthesized identifier is ambiguous until we are sure it is an assignment expression\n        // i.e. `([(a) = []] = []) => {}`\n        // see also `recordArrowParameterBindingError` signature in packages/babel-parser/src/util/expression-scope.js\n        if (parenthesized.type === \"Identifier\") {\n          this.expressionScope.recordArrowParameterBindingError(\n            Errors.InvalidParenthesizedAssignment,\n            node,\n          );\n        } else if (\n          parenthesized.type !== \"MemberExpression\" &&\n          !this.isOptionalMemberExpression(parenthesized)\n        ) {\n          // A parenthesized member expression can be in LHS but not in pattern.\n          // If the LHS is later interpreted as a pattern, `checkLVal` will throw for member expression binding\n          // i.e. `([(a.b) = []] = []) => {}`\n          this.raise(Errors.InvalidParenthesizedAssignment, node);\n        }\n      } else {\n        this.raise(Errors.InvalidParenthesizedAssignment, node);\n      }\n    }\n\n    switch (node.type) {\n      case \"Identifier\":\n      case \"ObjectPattern\":\n      case \"ArrayPattern\":\n      case \"AssignmentPattern\":\n      case \"RestElement\":\n        break;\n\n      case \"ObjectExpression\":\n        (node as Node).type = \"ObjectPattern\";\n        for (\n          let i = 0, length = node.properties.length, last = length - 1;\n          i < length;\n          i++\n        ) {\n          const prop = node.properties[i];\n          const isLast = i === last;\n          this.toAssignableObjectExpressionProp(prop, isLast, isLHS);\n\n          if (\n            isLast &&\n            (prop as Node).type === \"RestElement\" &&\n            node.extra?.trailingCommaLoc\n          ) {\n            this.raise(Errors.RestTrailingComma, node.extra.trailingCommaLoc);\n          }\n        }\n        break;\n\n      case \"ObjectProperty\": {\n        const { key, value } = node;\n        if (this.isPrivateName(key)) {\n          this.classScope.usePrivateName(\n            this.getPrivateNameSV(key),\n            key.loc.start,\n          );\n        }\n        this.toAssignable(value, isLHS);\n        break;\n      }\n\n      case \"SpreadElement\": {\n        throw new Error(\n          \"Internal @babel/parser error (this is a bug, please report it).\" +\n            \" SpreadElement should be converted by .toAssignable's caller.\",\n        );\n      }\n\n      case \"ArrayExpression\":\n        (node as Node).type = \"ArrayPattern\";\n        this.toAssignableList(\n          node.elements,\n          node.extra?.trailingCommaLoc,\n          isLHS,\n        );\n        break;\n\n      case \"AssignmentExpression\":\n        if (node.operator !== \"=\") {\n          this.raise(Errors.MissingEqInAssignment, node.left.loc.end);\n        }\n\n        (node as Node).type = \"AssignmentPattern\";\n        delete node.operator;\n        this.toAssignable(node.left, isLHS);\n        break;\n\n      case \"ParenthesizedExpression\":\n        /*::invariant (parenthesized !== undefined) */\n        this.toAssignable(parenthesized, isLHS);\n        break;\n\n      default:\n      // We don't know how to deal with this node. It will\n      // be reported by a later call to checkLVal\n    }\n  }\n\n  toAssignableObjectExpressionProp(\n    prop: Node,\n    isLast: boolean,\n    isLHS: boolean,\n  ) {\n    if (prop.type === \"ObjectMethod\") {\n      this.raise(\n        prop.kind === \"get\" || prop.kind === \"set\"\n          ? Errors.PatternHasAccessor\n          : Errors.PatternHasMethod,\n        prop.key,\n      );\n    } else if (prop.type === \"SpreadElement\") {\n      (prop as Node).type = \"RestElement\";\n      const arg = prop.argument;\n      this.checkToRestConversion(arg, /* allowPattern */ false);\n      this.toAssignable(arg, isLHS);\n\n      if (!isLast) {\n        this.raise(Errors.RestTrailingComma, prop);\n      }\n    } else {\n      this.toAssignable(prop, isLHS);\n    }\n  }\n\n  // Convert list of expression atoms to binding list.\n\n  toAssignableList(\n    exprList: (Expression | SpreadElement | RestElement)[],\n    trailingCommaLoc: Position | undefined | null,\n    isLHS: boolean,\n  ): void {\n    const end = exprList.length - 1;\n\n    for (let i = 0; i <= end; i++) {\n      const elt = exprList[i];\n      if (!elt) continue;\n\n      if (elt.type === \"SpreadElement\") {\n        (elt as unknown as RestElement).type = \"RestElement\";\n        const arg = elt.argument;\n        this.checkToRestConversion(arg, /* allowPattern */ true);\n        this.toAssignable(arg, isLHS);\n      } else {\n        this.toAssignable(elt, isLHS);\n      }\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\n  isAssignable(node: Node, isBinding?: boolean): boolean {\n    switch (node.type) {\n      case \"Identifier\":\n      case \"ObjectPattern\":\n      case \"ArrayPattern\":\n      case \"AssignmentPattern\":\n      case \"RestElement\":\n        return true;\n\n      case \"ObjectExpression\": {\n        const last = node.properties.length - 1;\n        return node.properties.every((prop, i) => {\n          return (\n            prop.type !== \"ObjectMethod\" &&\n            (i === last || prop.type !== \"SpreadElement\") &&\n            this.isAssignable(prop)\n          );\n        });\n      }\n\n      case \"ObjectProperty\":\n        return this.isAssignable(node.value);\n\n      case \"SpreadElement\":\n        return this.isAssignable(node.argument);\n\n      case \"ArrayExpression\":\n        return node.elements.every(\n          element => element === null || this.isAssignable(element),\n        );\n\n      case \"AssignmentExpression\":\n        return node.operator === \"=\";\n\n      case \"ParenthesizedExpression\":\n        return this.isAssignable(node.expression);\n\n      case \"MemberExpression\":\n      case \"OptionalMemberExpression\":\n        return !isBinding;\n\n      default:\n        return false;\n    }\n  }\n\n  // Convert list of expression atoms to a list of\n\n  toReferencedList(\n    exprList:\n      | ReadonlyArray<Expression | SpreadElement>\n      | ReadonlyArray<Expression | RestElement>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    isParenthesizedExpr?: boolean,\n  ):\n    | ReadonlyArray<Expression | SpreadElement>\n    | ReadonlyArray<Expression | RestElement> {\n    return exprList;\n  }\n\n  toReferencedListDeep(\n    exprList:\n      | ReadonlyArray<Expression | SpreadElement>\n      | ReadonlyArray<Expression | RestElement>,\n    isParenthesizedExpr?: boolean,\n  ): void {\n    this.toReferencedList(exprList, isParenthesizedExpr);\n\n    for (const expr of exprList) {\n      if (expr?.type === \"ArrayExpression\") {\n        this.toReferencedListDeep(expr.elements);\n      }\n    }\n  }\n\n  // Parses spread element.\n\n  parseSpread(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): SpreadElement {\n    const node = this.startNode<SpreadElement>();\n    this.next();\n    node.argument = this.parseMaybeAssignAllowIn(\n      refExpressionErrors,\n      undefined,\n    );\n    return this.finishNode(node, \"SpreadElement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingRestProperty\n  // https://tc39.es/ecma262/#prod-BindingRestElement\n  parseRestBinding(this: Parser): RestElement {\n    const node = this.startNode<RestElement>();\n    this.next(); // eat `...`\n    node.argument = this.parseBindingAtom();\n    return this.finishNode(node, \"RestElement\");\n  }\n\n  // Parses lvalue (assignable) atom.\n  parseBindingAtom(this: Parser): Pattern {\n    // https://tc39.es/ecma262/#prod-BindingPattern\n    switch (this.state.type) {\n      case tt.bracketL: {\n        const node = this.startNode<ArrayPattern>();\n        this.next();\n        // @ts-expect-error: Fixme: TSParameterProperty can not be assigned to node.elements\n        node.elements = this.parseBindingList(\n          tt.bracketR,\n          charCodes.rightSquareBracket,\n          ParseBindingListFlags.ALLOW_EMPTY,\n        );\n        return this.finishNode(node, \"ArrayPattern\");\n      }\n\n      case tt.braceL:\n        return this.parseObjectLike(tt.braceR, true);\n    }\n\n    // https://tc39.es/ecma262/#prod-BindingIdentifier\n    return this.parseIdentifier();\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingElementList\n  parseBindingList(\n    this: Parser,\n    close: TokenType,\n    closeCharCode: (typeof charCodes)[keyof typeof charCodes],\n    flags: ParseBindingListFlags,\n  ): Array<Pattern | TSParameterProperty> {\n    const allowEmpty = flags & ParseBindingListFlags.ALLOW_EMPTY;\n\n    const elts: Array<Pattern | TSParameterProperty> = [];\n    let first = true;\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n      }\n      if (allowEmpty && this.match(tt.comma)) {\n        elts.push(null);\n      } else if (this.eat(close)) {\n        break;\n      } else if (this.match(tt.ellipsis)) {\n        let rest: Pattern = this.parseRestBinding();\n        if (\n          (!process.env.BABEL_8_BREAKING && this.hasPlugin(\"flow\")) ||\n          flags & ParseBindingListFlags.IS_FUNCTION_PARAMS\n        ) {\n          rest = this.parseFunctionParamType(rest);\n        }\n        elts.push(rest);\n        if (!this.checkCommaAfterRest(closeCharCode)) {\n          this.expect(close);\n          break;\n        }\n      } else {\n        const decorators = [];\n        if (this.match(tt.at) && this.hasPlugin(\"decorators\")) {\n          this.raise(Errors.UnsupportedParameterDecorator, this.state.startLoc);\n        }\n        // invariant: hasPlugin(\"decorators-legacy\")\n        while (this.match(tt.at)) {\n          decorators.push(this.parseDecorator());\n        }\n        elts.push(this.parseAssignableListItem(flags, decorators));\n      }\n    }\n    return elts;\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingRestProperty\n  parseBindingRestProperty(\n    this: Parser,\n    prop: Undone<RestElement>,\n  ): RestElement {\n    this.next(); // eat '...'\n    // Don't use parseRestBinding() as we only allow Identifier here.\n    prop.argument = this.parseIdentifier();\n    this.checkCommaAfterRest(charCodes.rightCurlyBrace);\n    return this.finishNode(prop, \"RestElement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-BindingProperty\n  parseBindingProperty(this: Parser): AssignmentProperty | RestElement {\n    const { type, startLoc } = this.state;\n    if (type === tt.ellipsis) {\n      return this.parseBindingRestProperty(this.startNode());\n    }\n\n    const prop = this.startNode<AssignmentProperty>();\n    if (type === tt.privateName) {\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(\n      prop,\n      startLoc,\n      false /* isGenerator */,\n      false /* isAsync */,\n      true /* isPattern */,\n      false /* isAccessor */,\n    );\n  }\n\n  parseAssignableListItem(\n    this: Parser,\n    flags: ParseBindingListFlags,\n    decorators: Decorator[],\n  ): Pattern | TSParameterProperty {\n    const left = this.parseMaybeDefault();\n    if (\n      (!process.env.BABEL_8_BREAKING && this.hasPlugin(\"flow\")) ||\n      flags & ParseBindingListFlags.IS_FUNCTION_PARAMS\n    ) {\n      this.parseFunctionParamType(left);\n    }\n    const elt = this.parseMaybeDefault(left.loc.start, left);\n    if (decorators.length) {\n      left.decorators = decorators;\n    }\n    return elt;\n  }\n\n  // Used by flow/typescript plugin to add type annotations to binding elements\n  parseFunctionParamType(param: Pattern): Pattern {\n    return param;\n  }\n\n  // Parses assignment pattern around given atom if possible.\n  // https://tc39.es/ecma262/#prod-BindingElement\n  parseMaybeDefault(\n    this: Parser,\n    startLoc?: Position | null,\n    left?: Pattern | null,\n  ): Pattern {\n    startLoc ??= this.state.startLoc;\n    left = left ?? this.parseBindingAtom();\n    if (!this.eat(tt.eq)) return left;\n\n    const node = this.startNodeAt<AssignmentPattern>(startLoc);\n    node.left = left;\n    node.right = this.parseMaybeAssignAllowIn();\n    return this.finishNode(node, \"AssignmentPattern\");\n  }\n  /**\n   * Return information use in determining whether a Node of a given type is an LVal,\n   * possibly given certain additional context information.\n   *\n   * Subclasser notes: This method has kind of a lot of mixed, but related,\n   * responsibilities. If we can definitively determine with the information\n   * provided that this either *is* or *isn't* a valid `LVal`, then the return\n   * value is easy: just return `true` or `false`. However, if it is a valid\n   * LVal *ancestor*, and thus its descendants must be subsequently visited to\n   * continue the \"investigation\", then this method should return the relevant\n   * child key as a `string`. In some special cases, you additionally want to\n   * convey that this node should be treated as if it were parenthesized. In\n   * that case, a tuple of [key: string, parenthesized: boolean] is returned.\n   * The `string`-only return option is actually just a shorthand for:\n   * `[key: string, parenthesized: false]`.\n   *\n   * @param type A Node `type` string\n   * @param isUnparenthesizedInAssign\n   *        Whether the node in question is unparenthesized and its parent\n   *        is either an assignment pattern or an assignment expression.\n   * @param binding\n   *        The binding operation that is being considered for this potential\n   *        LVal.\n   * @returns `true` or `false` if we can immediately determine whether the node\n   *          type in question can be treated as an `LVal`.\n   *          A `string` key to traverse if we must check this child.\n   *          A `[string, boolean]` tuple if we need to check this child and\n   *          treat is as parenthesized.\n   */\n  isValidLVal(\n    type: string,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    isUnparenthesizedInAssign: boolean,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    binding: BindingFlag,\n  ): string | boolean | [string, boolean] {\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\n  // Overridden by the estree plugin\n  isOptionalMemberExpression(expression: Node): boolean {\n    return expression.type === \"OptionalMemberExpression\";\n  }\n\n  /**\n   * Verify that a target expression is an lval (something that can be assigned to).\n   *\n   * @param expression The expression in question to check.\n   * @param ancestor\n   *        The relevant ancestor to provide context information for the error\n   *        if the check fails.\n   * @param binding\n   *        The desired binding type. If the given expression is an identifier\n   *        and `binding` is not `BindingFlag.TYPE_NONE`, `checkLVal` will register binding\n   *        to the parser scope See also `src/util/scopeflags.js`\n   * @param checkClashes\n   *        An optional string set to check if an identifier name is included.\n   *        `checkLVal` will add checked identifier name to `checkClashes` It is\n   *        used in tracking duplicates in function parameter lists. If it is\n   *        false, `checkLVal` will skip duplicate checks\n   * @param strictModeChanged\n   *        Whether an identifier has been parsed in a sloppy context but should\n   *        be reinterpreted as strict-mode. e.g. `(arguments) => { \"use strict \"}`\n   * @param hasParenthesizedAncestor\n   *        This is only used internally during recursive calls, and you should\n   *        not have to set it yourself.\n   */\n\n  checkLVal(\n    expression:\n      | Expression\n      | ObjectMember\n      | RestElement\n      | Pattern\n      | TSParameterProperty,\n    ancestor: LValAncestor,\n    binding: BindingFlag = BindingFlag.TYPE_NONE,\n    checkClashes: Set<string> | false = false,\n    strictModeChanged: boolean = false,\n    hasParenthesizedAncestor: boolean = false,\n  ): void {\n    const type = expression.type;\n\n    // If we find here an ObjectMethod, it's because this was originally\n    // an ObjectExpression which has then been converted.\n    // toAssignable already reported this error with a nicer message.\n    if (this.isObjectMethod(expression)) return;\n\n    const isOptionalMemberExpression =\n      this.isOptionalMemberExpression(expression);\n\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\n      if (binding !== BindingFlag.TYPE_NONE) {\n        this.raise(Errors.InvalidPropertyBindingPattern, expression);\n      }\n      return;\n    }\n\n    if (type === \"Identifier\") {\n      this.checkIdentifier(expression, binding, strictModeChanged);\n\n      const { name } = expression;\n\n      if (checkClashes) {\n        if (checkClashes.has(name)) {\n          this.raise(Errors.ParamDupe, expression);\n        } else {\n          checkClashes.add(name);\n        }\n      }\n\n      return;\n    }\n\n    const validity = this.isValidLVal(\n      type,\n      !(hasParenthesizedAncestor || expression.extra?.parenthesized) &&\n        ancestor.type === \"AssignmentExpression\",\n      binding,\n    );\n\n    if (validity === true) return;\n    if (validity === false) {\n      const ParseErrorClass =\n        binding === BindingFlag.TYPE_NONE\n          ? Errors.InvalidLhs\n          : Errors.InvalidLhsBinding;\n\n      this.raise(ParseErrorClass, expression, { ancestor });\n      return;\n    }\n\n    let key: string, isParenthesizedExpression: boolean;\n    if (typeof validity === \"string\") {\n      key = validity;\n      isParenthesizedExpression = type === \"ParenthesizedExpression\";\n    } else {\n      [key, isParenthesizedExpression] = validity;\n    }\n\n    const nextAncestor =\n      type === \"ArrayPattern\" || type === \"ObjectPattern\"\n        ? ({ type } as const)\n        : ancestor;\n\n    // @ts-expect-error key may not index expression.\n    const val = expression[key];\n    if (Array.isArray(val)) {\n      for (const child of val) {\n        if (child) {\n          this.checkLVal(\n            child,\n            nextAncestor,\n            binding,\n            checkClashes,\n            strictModeChanged,\n            isParenthesizedExpression,\n          );\n        }\n      }\n    } else if (val) {\n      this.checkLVal(\n        val,\n        nextAncestor,\n        binding,\n        checkClashes,\n        strictModeChanged,\n        isParenthesizedExpression,\n      );\n    }\n  }\n\n  checkIdentifier(\n    at: Identifier,\n    bindingType: BindingFlag,\n    strictModeChanged: boolean = false,\n  ) {\n    if (\n      this.state.strict &&\n      (strictModeChanged\n        ? isStrictBindReservedWord(at.name, this.inModule)\n        : isStrictBindOnlyReservedWord(at.name))\n    ) {\n      if (bindingType === BindingFlag.TYPE_NONE) {\n        this.raise(Errors.StrictEvalArguments, at, { referenceName: at.name });\n      } else {\n        this.raise(Errors.StrictEvalArgumentsBinding, at, {\n          bindingName: at.name,\n        });\n      }\n    }\n\n    if (bindingType & BindingFlag.FLAG_NO_LET_IN_LEXICAL && at.name === \"let\") {\n      this.raise(Errors.LetInLexicalBinding, at);\n    }\n\n    if (!(bindingType & BindingFlag.TYPE_NONE)) {\n      this.declareNameFromIdentifier(at, bindingType);\n    }\n  }\n\n  declareNameFromIdentifier(identifier: Identifier, binding: BindingFlag) {\n    this.scope.declareName(identifier.name, binding, identifier.loc.start);\n  }\n\n  checkToRestConversion(node: Node, allowPattern: boolean): void {\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      /* falls through */\n      default:\n        this.raise(Errors.InvalidRestAssignmentPattern, node);\n    }\n  }\n\n  checkCommaAfterRest(\n    close: (typeof charCodes)[keyof typeof charCodes],\n  ): boolean {\n    if (!this.match(tt.comma)) {\n      return false;\n    }\n\n    this.raise(\n      this.lookaheadCharCode() === close\n        ? Errors.RestTrailingComma\n        : Errors.ElementAfterRest,\n      this.state.startLoc,\n    );\n\n    return true;\n  }\n}\n","import type State from \"../../tokenizer/state.ts\";\nimport {\n  tokenIsIdentifier,\n  tokenIsTSDeclarationStart,\n  tokenIsTSTypeOperator,\n  tokenOperatorPrecedence,\n  tokenIsKeywordOrIdentifier,\n  tt,\n  type TokenType,\n  tokenIsTemplate,\n  tokenCanStartExpression,\n} from \"../../tokenizer/types.ts\";\nimport { types as tc } from \"../../tokenizer/context.ts\";\nimport type * as N from \"../../types.ts\";\nimport type { Position } from \"../../util/location.ts\";\nimport { createPositionWithColumnOffset } from \"../../util/location.ts\";\nimport type Parser from \"../../parser/index.ts\";\nimport { ScopeFlag, BindingFlag } from \"../../util/scopeflags.ts\";\nimport TypeScriptScopeHandler from \"./scope.ts\";\nimport * as charCodes from \"charcodes\";\nimport type { ExpressionErrors } from \"../../parser/util.ts\";\nimport type { ParseStatementFlag } from \"../../parser/statement.ts\";\nimport { ParamKind } from \"../../util/production-parameter.ts\";\nimport { Errors, ParseErrorEnum } from \"../../parse-error.ts\";\nimport { cloneIdentifier, type Undone } from \"../../parser/node.ts\";\nimport type { Pattern } from \"../../types.ts\";\nimport type { Expression } from \"../../types.ts\";\nimport type { ClassWithMixin, IJSXParserMixin } from \"../jsx/index.ts\";\nimport { ParseBindingListFlags } from \"../../parser/lval.ts\";\nimport { OptionFlags } from \"../../options.ts\";\n\ntype TsModifier =\n  | \"readonly\"\n  | \"abstract\"\n  | \"declare\"\n  | \"static\"\n  | \"override\"\n  | \"const\"\n  | N.Accessibility\n  | N.VarianceAnnotations;\n\nfunction nonNull<T>(x?: T | null): T {\n  if (x == null) {\n    throw new Error(`Unexpected ${x} value.`);\n  }\n  return x;\n}\n\nfunction assert(x: boolean): void {\n  if (!x) {\n    throw new Error(\"Assert fail\");\n  }\n}\n\ntype ParsingContext =\n  | \"EnumMembers\"\n  | \"HeritageClauseElement\"\n  | \"TupleElementTypes\"\n  | \"TypeMembers\"\n  | \"TypeParametersOrArguments\";\n\ntype ModifierBase = {\n  accessibility?: N.Accessibility;\n} & {\n  [key in TsModifier]?: boolean | undefined | null;\n};\n\n/* eslint sort-keys: \"error\" */\nconst TSErrors = ParseErrorEnum`typescript`({\n  AbstractMethodHasImplementation: ({ methodName }: { methodName: string }) =>\n    `Method '${methodName}' cannot have an implementation because it is marked abstract.`,\n  AbstractPropertyHasInitializer: ({\n    propertyName,\n  }: {\n    propertyName: string;\n  }) =>\n    `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,\n  AccessorCannotBeOptional:\n    \"An 'accessor' property cannot be declared optional.\",\n  AccessorCannotDeclareThisParameter:\n    \"'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:\n    \"A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.\",\n  ConstructorHasTypeParameters:\n    \"Type parameters cannot appear on a constructor declaration.\",\n  DeclareAccessor: ({ kind }: { kind: \"get\" | \"set\" }) =>\n    `'declare' is not allowed in ${kind}ters.`,\n  DeclareClassFieldHasInitializer:\n    \"Initializers are not allowed in ambient contexts.\",\n  DeclareFunctionHasImplementation:\n    \"An implementation cannot be declared in ambient contexts.\",\n  DuplicateAccessibilityModifier:\n    // `Accessibility modifier already seen: ${modifier}` would be more helpful.\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ({ modifier }: { modifier: N.Accessibility }) =>\n      `Accessibility modifier already seen.`,\n  DuplicateModifier: ({ modifier }: { modifier: TsModifier }) =>\n    `Duplicate modifier: '${modifier}'.`,\n  // `token` matches the terminology used by typescript:\n  // https://github.com/microsoft/TypeScript/blob/main/src/compiler/types.ts#L2915\n  EmptyHeritageClauseType: ({ token }: { token: \"extends\" | \"implements\" }) =>\n    `'${token}' list cannot be empty.`,\n  EmptyTypeArguments: \"Type argument list cannot be empty.\",\n  EmptyTypeParameters: \"Type parameter list cannot be empty.\",\n  ExpectedAmbientAfterExportDeclare:\n    \"'export declare' must be followed by an ambient declaration.\",\n  ImportAliasHasImportType: \"An import alias can not use 'import type'.\",\n  ImportReflectionHasImportType:\n    \"An `import module` declaration can not use `type` modifier\",\n  IncompatibleModifiers: ({\n    modifiers,\n  }: {\n    modifiers: [TsModifier, TsModifier];\n  }) =>\n    `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,\n  IndexSignatureHasAbstract:\n    \"Index signatures cannot have the 'abstract' modifier.\",\n  IndexSignatureHasAccessibility: ({\n    modifier,\n  }: {\n    modifier: N.Accessibility;\n  }) =>\n    `Index signatures cannot have an accessibility modifier ('${modifier}').`,\n  IndexSignatureHasDeclare:\n    \"Index signatures cannot have the 'declare' modifier.\",\n  IndexSignatureHasOverride:\n    \"'override' modifier cannot appear on an index signature.\",\n  IndexSignatureHasStatic:\n    \"Index signatures cannot have the 'static' modifier.\",\n  InitializerNotAllowedInAmbientContext:\n    \"Initializers are not allowed in ambient contexts.\",\n  InvalidModifierOnTypeMember: ({ modifier }: { modifier: TsModifier }) =>\n    `'${modifier}' modifier cannot appear on a type member.`,\n  InvalidModifierOnTypeParameter: ({ modifier }: { modifier: TsModifier }) =>\n    `'${modifier}' modifier cannot appear on a type parameter.`,\n  InvalidModifierOnTypeParameterPositions: ({\n    modifier,\n  }: {\n    modifier: TsModifier;\n  }) =>\n    `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,\n  InvalidModifiersOrder: ({\n    orderedModifiers,\n  }: {\n    orderedModifiers: [TsModifier, TsModifier];\n  }) =>\n    `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,\n  InvalidPropertyAccessAfterInstantiationExpression:\n    \"Invalid property access after an instantiation expression. \" +\n    \"You can either wrap the instantiation expression in parentheses, or delete the type arguments.\",\n  InvalidTupleMemberLabel:\n    \"Tuple members must be labeled with a simple identifier.\",\n  MissingInterfaceName:\n    \"'interface' declarations must be followed by an identifier.\",\n  NonAbstractClassHasAbstractMethod:\n    \"Abstract methods can only appear within an abstract class.\",\n  NonClassMethodPropertyHasAbstractModifer:\n    \"'abstract' modifier can only appear on a class, method, or property declaration.\",\n  OptionalTypeBeforeRequired:\n    \"A required element cannot follow an optional element.\",\n  OverrideNotInSubClass:\n    \"This member cannot have an 'override' modifier because its containing class does not extend another class.\",\n  PatternIsOptional:\n    \"A binding pattern parameter cannot be optional in an implementation signature.\",\n  PrivateElementHasAbstract:\n    \"Private elements cannot have the 'abstract' modifier.\",\n  PrivateElementHasAccessibility: ({\n    modifier,\n  }: {\n    modifier: N.Accessibility;\n  }) =>\n    `Private elements cannot have an accessibility modifier ('${modifier}').`,\n  ReadonlyForMethodSignature:\n    \"'readonly' modifier can only appear on a property declaration or index signature.\",\n  ReservedArrowTypeParam:\n    \"This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.\",\n  ReservedTypeAssertion:\n    \"This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.\",\n  SetAccessorCannotHaveOptionalParameter:\n    \"A 'set' accessor cannot have an optional parameter.\",\n  SetAccessorCannotHaveRestParameter:\n    \"A 'set' accessor cannot have rest parameter.\",\n  SetAccessorCannotHaveReturnType:\n    \"A 'set' accessor cannot have a return type annotation.\",\n  SingleTypeParameterWithoutTrailingComma: ({\n    typeParameterName,\n  }: {\n    typeParameterName: string;\n  }) =>\n    `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,\n  StaticBlockCannotHaveModifier:\n    \"Static class blocks cannot have any modifier.\",\n  TupleOptionalAfterType:\n    \"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:\n    \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.\",\n  TypeImportCannotSpecifyDefaultAndNamed:\n    \"A type-only import can specify a default import or named bindings, but not both.\",\n  TypeModifierIsUsedInTypeExports:\n    \"The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.\",\n  TypeModifierIsUsedInTypeImports:\n    \"The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.\",\n  UnexpectedParameterModifier:\n    \"A parameter property is only allowed in a constructor implementation.\",\n  UnexpectedReadonly:\n    \"'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:\n    \"Argument in a type import must be a string literal.\",\n  UnsupportedParameterPropertyKind:\n    \"A parameter property may not be declared using a binding pattern.\",\n  UnsupportedSignatureParameterKind: ({ type }: { type: string }) =>\n    `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,\n});\n\n/* eslint-disable sort-keys */\n\n// Doesn't handle \"void\" or \"null\" because those are keywords, not identifiers.\n// It also doesn't handle \"intrinsic\", since usually it's not a keyword.\nfunction keywordTypeFromName(value: string): N.TsKeywordTypeType | undefined {\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}\n\nfunction tsIsAccessModifier(modifier: string): modifier is N.Accessibility {\n  return (\n    modifier === \"private\" || modifier === \"public\" || modifier === \"protected\"\n  );\n}\n\nfunction tsIsVarianceAnnotations(\n  modifier: string,\n): modifier is N.VarianceAnnotations {\n  return modifier === \"in\" || modifier === \"out\";\n}\n\nexport const enum tsParseEntityNameFlags {\n  NONE = 0b00,\n  ALLOW_RESERVED_WORDS = 0b01,\n  LEADING_THIS_AS_IDENTIFIER = 0b10,\n}\n\nexport default (superClass: ClassWithMixin<typeof Parser, IJSXParserMixin>) =>\n  class TypeScriptParserMixin extends superClass implements Parser {\n    getScopeHandler(): new (...args: any) => TypeScriptScopeHandler {\n      return TypeScriptScopeHandler;\n    }\n\n    tsIsIdentifier(): boolean {\n      // TODO: actually a bit more complex in TypeScript, but shouldn't matter.\n      // See https://github.com/Microsoft/TypeScript/issues/15008\n      return tokenIsIdentifier(this.state.type);\n    }\n\n    tsTokenCanFollowModifier() {\n      return (\n        this.match(tt.bracketL) ||\n        this.match(tt.braceL) ||\n        this.match(tt.star) ||\n        this.match(tt.ellipsis) ||\n        this.match(tt.privateName) ||\n        this.isLiteralPropertyName()\n      );\n    }\n\n    tsNextTokenOnSameLineAndCanFollowModifier() {\n      this.next();\n      if (this.hasPrecedingLineBreak()) {\n        return false;\n      }\n      return this.tsTokenCanFollowModifier();\n    }\n\n    tsNextTokenCanFollowModifier() {\n      // Note: TypeScript's implementation is much more complicated because\n      // more things are considered modifiers there.\n      // This implementation only handles modifiers not handled by @babel/parser itself. And \"static\".\n      if (this.match(tt._static)) {\n        this.next();\n        return this.tsTokenCanFollowModifier();\n      }\n      return this.tsNextTokenOnSameLineAndCanFollowModifier();\n    }\n\n    /** Parses a modifier matching one the given modifier names. */\n    tsParseModifier<T extends TsModifier>(\n      allowedModifiers: T[],\n      stopOnStartOfClassStaticBlock?: boolean,\n    ): T | undefined | null {\n      if (\n        !tokenIsIdentifier(this.state.type) &&\n        this.state.type !== tt._in &&\n        this.state.type !== tt._const\n      ) {\n        return undefined;\n      }\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\n    /** Parses a list of modifiers, in any order.\n     *  If you need a specific order, you must call this function multiple times:\n     *    this.tsParseModifiers({ modified: node, allowedModifiers: [\"public\"] });\n     *    this.tsParseModifiers({ modified: node, allowedModifiers: [\"abstract\", \"readonly\"] });\n     */\n    tsParseModifiers<N extends ModifierBase>(\n      {\n        allowedModifiers,\n        disallowedModifiers,\n        stopOnStartOfClassStaticBlock,\n        errorTemplate = TSErrors.InvalidModifierOnTypeMember,\n      }: {\n        allowedModifiers: readonly TsModifier[];\n        disallowedModifiers?: TsModifier[];\n        stopOnStartOfClassStaticBlock?: boolean;\n        errorTemplate?: typeof TSErrors.InvalidModifierOnTypeMember;\n      },\n      modified: N,\n    ): void {\n      const enforceOrder = (\n        loc: Position,\n        modifier: TsModifier,\n        before: TsModifier,\n        after: TsModifier,\n      ) => {\n        if (modifier === before && modified[after]) {\n          this.raise(TSErrors.InvalidModifiersOrder, loc, {\n            orderedModifiers: [before, after],\n          });\n        }\n      };\n      const incompatible = (\n        loc: Position,\n        modifier: TsModifier,\n        mod1: TsModifier,\n        mod2: TsModifier,\n      ) => {\n        if (\n          (modified[mod1] && modifier === mod2) ||\n          (modified[mod2] && modifier === mod1)\n        ) {\n          this.raise(TSErrors.IncompatibleModifiers, loc, {\n            modifiers: [mod1, mod2],\n          });\n        }\n      };\n\n      for (;;) {\n        const { startLoc } = this.state;\n        const modifier: TsModifier | undefined | null = this.tsParseModifier(\n          allowedModifiers.concat(disallowedModifiers ?? []),\n          stopOnStartOfClassStaticBlock,\n        );\n\n        if (!modifier) break;\n\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\n            modified.accessibility = modifier;\n          }\n        } else if (tsIsVarianceAnnotations(modifier)) {\n          if (modified[modifier]) {\n            this.raise(TSErrors.DuplicateModifier, startLoc, { modifier });\n          }\n          modified[modifier] = true;\n\n          enforceOrder(startLoc, modifier, \"in\", \"out\");\n        } else {\n          if (Object.hasOwn(modified, modifier)) {\n            this.raise(TSErrors.DuplicateModifier, startLoc, { modifier });\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\n            incompatible(startLoc, modifier, \"declare\", \"override\");\n            incompatible(startLoc, modifier, \"static\", \"abstract\");\n          }\n          modified[modifier] = true;\n        }\n\n        if (disallowedModifiers?.includes(modifier)) {\n          this.raise(errorTemplate, startLoc, {\n            modifier,\n          });\n        }\n      }\n    }\n\n    tsIsListTerminator(kind: ParsingContext): boolean {\n      switch (kind) {\n        case \"EnumMembers\":\n        case \"TypeMembers\":\n          return this.match(tt.braceR);\n        case \"HeritageClauseElement\":\n          return this.match(tt.braceL);\n        case \"TupleElementTypes\":\n          return this.match(tt.bracketR);\n        case \"TypeParametersOrArguments\":\n          return this.match(tt.gt);\n      }\n    }\n\n    tsParseList<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T,\n    ): T[] {\n      const result: T[] = [];\n      while (!this.tsIsListTerminator(kind)) {\n        // Skipping \"parseListElement\" from the TS source since that's just for error handling.\n        result.push(parseElement());\n      }\n      return result;\n    }\n\n    tsParseDelimitedList<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T,\n      refTrailingCommaPos?: {\n        value: number;\n      },\n    ): T[] {\n      return nonNull(\n        this.tsParseDelimitedListWorker(\n          kind,\n          parseElement,\n          /* expectSuccess */ true,\n          refTrailingCommaPos,\n        ),\n      );\n    }\n\n    /**\n     * If !expectSuccess, returns undefined instead of failing to parse.\n     * If expectSuccess, parseElement should always return a defined value.\n     */\n    tsParseDelimitedListWorker<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T | undefined,\n      expectSuccess: boolean,\n      refTrailingCommaPos?: {\n        value: number;\n      },\n    ): T[] | undefined {\n      const result: T[] = [];\n      let trailingCommaPos = -1;\n\n      for (;;) {\n        if (this.tsIsListTerminator(kind)) {\n          break;\n        }\n        trailingCommaPos = -1;\n\n        const element = parseElement();\n        if (element == null) {\n          return undefined;\n        }\n        result.push(element);\n\n        if (this.eat(tt.comma)) {\n          trailingCommaPos = this.state.lastTokStartLoc.index;\n          continue;\n        }\n\n        if (this.tsIsListTerminator(kind)) {\n          break;\n        }\n\n        if (expectSuccess) {\n          // This will fail with an error about a missing comma\n          this.expect(tt.comma);\n        }\n        return undefined;\n      }\n\n      if (refTrailingCommaPos) {\n        refTrailingCommaPos.value = trailingCommaPos;\n      }\n\n      return result;\n    }\n\n    tsParseBracketedList<T extends N.Node>(\n      kind: ParsingContext,\n      parseElement: () => T,\n      bracket: boolean,\n      skipFirstToken: boolean,\n      refTrailingCommaPos?: {\n        value: number;\n      },\n    ): T[] {\n      if (!skipFirstToken) {\n        if (bracket) {\n          this.expect(tt.bracketL);\n        } else {\n          this.expect(tt.lt);\n        }\n      }\n\n      const result = this.tsParseDelimitedList(\n        kind,\n        parseElement,\n        refTrailingCommaPos,\n      );\n\n      if (bracket) {\n        this.expect(tt.bracketR);\n      } else {\n        this.expect(tt.gt);\n      }\n\n      return result;\n    }\n\n    tsParseImportType(): N.TsImportType {\n      const node = this.startNode<N.TsImportType>();\n      this.expect(tt._import);\n      this.expect(tt.parenL);\n      if (!this.match(tt.string)) {\n        this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);\n        if (process.env.BABEL_8_BREAKING) {\n          // Consume as an non-conditional type so that we can recover from this error\n          node.argument = this.tsParseNonConditionalType() as any;\n        } else {\n          node.argument = super.parseExprAtom() as any;\n        }\n      } else {\n        if (process.env.BABEL_8_BREAKING) {\n          node.argument = this.tsParseLiteralTypeNode();\n        } else {\n          // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n          node.argument = this.parseStringLiteral(this.state.value);\n        }\n      }\n      if (this.eat(tt.comma) && !this.match(tt.parenR)) {\n        node.options = super.parseMaybeAssignAllowIn();\n        this.eat(tt.comma);\n      } else {\n        node.options = null;\n      }\n      this.expect(tt.parenR);\n\n      if (this.eat(tt.dot)) {\n        // In this instance, the entity name will actually itself be a\n        // qualifier, so allow it to be a reserved word as well.\n        node.qualifier = this.tsParseEntityName(\n          tsParseEntityNameFlags.ALLOW_RESERVED_WORDS |\n            tsParseEntityNameFlags.LEADING_THIS_AS_IDENTIFIER,\n        );\n      }\n      if (this.match(tt.lt)) {\n        if (process.env.BABEL_8_BREAKING) {\n          node.typeArguments = this.tsParseTypeArguments();\n        } else {\n          node.typeParameters = this.tsParseTypeArguments();\n        }\n      }\n      return this.finishNode(node, \"TSImportType\");\n    }\n\n    tsParseEntityName(flags: tsParseEntityNameFlags): N.TsEntityName {\n      let entity: N.TsEntityName;\n      if (\n        flags & tsParseEntityNameFlags.ALLOW_RESERVED_WORDS &&\n        this.match(tt._this)\n      ) {\n        if (flags & tsParseEntityNameFlags.LEADING_THIS_AS_IDENTIFIER) {\n          entity = this.parseIdentifier(true);\n        } else {\n          const node = this.startNode<N.ThisExpression>();\n          this.next();\n          entity = this.finishNode(node, \"ThisExpression\");\n        }\n      } else {\n        entity = this.parseIdentifier(\n          !!(flags & tsParseEntityNameFlags.ALLOW_RESERVED_WORDS),\n        );\n      }\n      while (this.eat(tt.dot)) {\n        const node: Undone<N.TsQualifiedName> =\n          this.startNodeAtNode<N.TsQualifiedName>(entity);\n        node.left = entity;\n        node.right = this.parseIdentifier(\n          !!(flags & tsParseEntityNameFlags.ALLOW_RESERVED_WORDS),\n        );\n        entity = this.finishNode(node, \"TSQualifiedName\");\n      }\n      return entity;\n    }\n\n    tsParseTypeReference(): N.TsTypeReference {\n      const node = this.startNode<N.TsTypeReference>();\n      node.typeName = this.tsParseEntityName(\n        tsParseEntityNameFlags.ALLOW_RESERVED_WORDS,\n      );\n      if (!this.hasPrecedingLineBreak() && this.match(tt.lt)) {\n        if (process.env.BABEL_8_BREAKING) {\n          node.typeArguments = this.tsParseTypeArguments();\n        } else {\n          node.typeParameters = this.tsParseTypeArguments();\n        }\n      }\n      return this.finishNode(node, \"TSTypeReference\");\n    }\n\n    tsParseThisTypePredicate(lhs: N.TsThisType): N.TsTypePredicate {\n      this.next();\n      const node = this.startNodeAtNode<N.TsTypePredicate>(lhs);\n      node.parameterName = lhs;\n      node.typeAnnotation = this.tsParseTypeAnnotation(/* eatColon */ false);\n      node.asserts = false;\n      return this.finishNode(node, \"TSTypePredicate\");\n    }\n\n    tsParseThisTypeNode(): N.TsThisType {\n      const node = this.startNode<N.TsThisType>();\n      this.next();\n      return this.finishNode(node, \"TSThisType\");\n    }\n\n    tsParseTypeQuery(): N.TsTypeQuery {\n      const node = this.startNode<N.TsTypeQuery>();\n      this.expect(tt._typeof);\n      if (this.match(tt._import)) {\n        node.exprName = this.tsParseImportType();\n      } else {\n        if (process.env.BABEL_8_BREAKING) {\n          node.exprName = this.tsParseEntityName(\n            tsParseEntityNameFlags.ALLOW_RESERVED_WORDS,\n          );\n        } else {\n          node.exprName = this.tsParseEntityName(\n            tsParseEntityNameFlags.ALLOW_RESERVED_WORDS |\n              tsParseEntityNameFlags.LEADING_THIS_AS_IDENTIFIER,\n          );\n        }\n      }\n      if (!this.hasPrecedingLineBreak() && this.match(tt.lt)) {\n        if (process.env.BABEL_8_BREAKING) {\n          node.typeArguments = this.tsParseTypeArguments();\n        } else {\n          node.typeParameters = this.tsParseTypeArguments();\n        }\n      }\n      return this.finishNode(node, \"TSTypeQuery\");\n    }\n\n    tsParseInOutModifiers = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"in\", \"out\"],\n      disallowedModifiers: [\n        \"const\",\n        \"public\",\n        \"private\",\n        \"protected\",\n        \"readonly\",\n        \"declare\",\n        \"abstract\",\n        \"override\",\n      ],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameter,\n    });\n\n    tsParseConstModifier = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"const\"],\n      // for better error recovery\n      disallowedModifiers: [\"in\", \"out\"],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions,\n    });\n\n    tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {\n      allowedModifiers: [\"in\", \"out\", \"const\"],\n      disallowedModifiers: [\n        \"public\",\n        \"private\",\n        \"protected\",\n        \"readonly\",\n        \"declare\",\n        \"abstract\",\n        \"override\",\n      ],\n      errorTemplate: TSErrors.InvalidModifierOnTypeParameter,\n    });\n\n    tsParseTypeParameter(\n      parseModifiers: (node: Undone<N.TsTypeParameter>) => void,\n    ): N.TsTypeParameter {\n      const node = this.startNode<N.TsTypeParameter>();\n\n      parseModifiers(node);\n\n      node.name = this.tsParseTypeParameterName();\n      node.constraint = this.tsEatThenParseType(tt._extends);\n      node.default = this.tsEatThenParseType(tt.eq);\n      return this.finishNode(node, \"TSTypeParameter\");\n    }\n\n    tsTryParseTypeParameters(\n      parseModifiers: (node: N.TsTypeParameter) => void,\n    ): N.TsTypeParameterDeclaration | undefined | null {\n      if (this.match(tt.lt)) {\n        return this.tsParseTypeParameters(parseModifiers);\n      }\n    }\n\n    tsParseTypeParameters(parseModifiers: (node: N.TsTypeParameter) => void) {\n      const node = this.startNode<N.TsTypeParameterDeclaration>();\n\n      if (this.match(tt.lt) || this.match(tt.jsxTagStart)) {\n        this.next();\n      } else {\n        this.unexpected();\n      }\n\n      const refTrailingCommaPos = { value: -1 };\n\n      node.params = this.tsParseBracketedList(\n        \"TypeParametersOrArguments\",\n        this.tsParseTypeParameter.bind(this, parseModifiers),\n        /* bracket */ false,\n        /* skipFirstToken */ true,\n        refTrailingCommaPos,\n      );\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\n    // Note: In TypeScript implementation we must provide `yieldContext` and `awaitContext`,\n    // but here it's always false, because this is only used for types.\n    tsFillSignature(\n      returnToken: TokenType,\n      signature: Undone<N.TsSignatureDeclaration>,\n    ): void {\n      // Arrow fns *must* have return token (`=>`). Normal functions can omit it.\n      const returnTokenRequired = returnToken === tt.arrow;\n\n      // https://github.com/babel/babel/issues/9231\n      const paramsKey = process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\";\n      const returnTypeKey = process.env.BABEL_8_BREAKING\n        ? \"returnType\"\n        : \"typeAnnotation\";\n\n      signature.typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      this.expect(tt.parenL);\n      signature[paramsKey] = this.tsParseBindingListForSignature();\n      if (returnTokenRequired) {\n        signature[returnTypeKey] =\n          this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n      } else if (this.match(returnToken)) {\n        signature[returnTypeKey] =\n          this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n      }\n    }\n\n    tsParseBindingListForSignature(): Array<\n      N.Identifier | N.RestElement | N.ObjectPattern | N.ArrayPattern\n    > {\n      const list = super.parseBindingList(\n        tt.parenR,\n        charCodes.rightParenthesis,\n        ParseBindingListFlags.IS_FUNCTION_PARAMS,\n      );\n      for (const pattern of list) {\n        const { type } = pattern;\n        if (type === \"AssignmentPattern\" || type === \"TSParameterProperty\") {\n          this.raise(TSErrors.UnsupportedSignatureParameterKind, pattern, {\n            type,\n          });\n        }\n      }\n      return list as Exclude<\n        (typeof list)[0],\n        N.AssignmentPattern | N.TSParameterProperty\n      >[];\n    }\n\n    tsParseTypeMemberSemicolon(): void {\n      if (!this.eat(tt.comma) && !this.isLineTerminator()) {\n        this.expect(tt.semi);\n      }\n    }\n\n    tsParseSignatureMember(\n      kind: \"TSCallSignatureDeclaration\" | \"TSConstructSignatureDeclaration\",\n      node: Undone<\n        N.TsCallSignatureDeclaration | N.TsConstructSignatureDeclaration\n      >,\n    ): N.TsCallSignatureDeclaration | N.TsConstructSignatureDeclaration {\n      this.tsFillSignature(tt.colon, node);\n      this.tsParseTypeMemberSemicolon();\n      return this.finishNode(node, kind);\n    }\n\n    tsIsUnambiguouslyIndexSignature() {\n      this.next(); // Skip '{'\n      if (tokenIsIdentifier(this.state.type)) {\n        this.next();\n        return this.match(tt.colon);\n      }\n      return false;\n    }\n\n    tsTryParseIndexSignature(\n      node: Undone<N.TsIndexSignature>,\n    ): N.TsIndexSignature | undefined {\n      if (\n        !(\n          this.match(tt.bracketL) &&\n          this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this))\n        )\n      ) {\n        return;\n      }\n\n      this.expect(tt.bracketL);\n      const id = this.parseIdentifier();\n      id.typeAnnotation = this.tsParseTypeAnnotation();\n      this.resetEndLocation(id); // set end position to end of type\n\n      this.expect(tt.bracketR);\n      node.parameters = [id];\n\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) node.typeAnnotation = type;\n      this.tsParseTypeMemberSemicolon();\n      return this.finishNode(node, \"TSIndexSignature\");\n    }\n\n    tsParsePropertyOrMethodSignature(\n      node: N.TsPropertySignature | N.TsMethodSignature,\n      readonly: boolean,\n    ): N.TsPropertySignature | N.TsMethodSignature {\n      if (this.eat(tt.question)) node.optional = true;\n      const nodeAny: any = node;\n\n      if (this.match(tt.parenL) || this.match(tt.lt)) {\n        if (readonly) {\n          this.raise(TSErrors.ReadonlyForMethodSignature, node);\n        }\n        const method: N.TsMethodSignature = nodeAny;\n        if (method.kind && this.match(tt.lt)) {\n          this.raise(\n            TSErrors.AccessorCannotHaveTypeParameters,\n            this.state.curPosition(),\n          );\n        }\n        this.tsFillSignature(tt.colon, method);\n        this.tsParseTypeMemberSemicolon();\n        const paramsKey = process.env.BABEL_8_BREAKING\n          ? \"params\"\n          : \"parameters\";\n        const returnTypeKey = process.env.BABEL_8_BREAKING\n          ? \"returnType\"\n          : \"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(\n                TSErrors.AccessorCannotDeclareThisParameter,\n                this.state.curPosition(),\n              );\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(\n                TSErrors.AccessorCannotDeclareThisParameter,\n                this.state.curPosition(),\n              );\n            }\n            if (\n              firstParameter.type === \"Identifier\" &&\n              firstParameter.optional\n            ) {\n              this.raise(\n                TSErrors.SetAccessorCannotHaveOptionalParameter,\n                this.state.curPosition(),\n              );\n            }\n            if (firstParameter.type === \"RestElement\") {\n              this.raise(\n                TSErrors.SetAccessorCannotHaveRestParameter,\n                this.state.curPosition(),\n              );\n            }\n          }\n          if (method[returnTypeKey]) {\n            this.raise(\n              TSErrors.SetAccessorCannotHaveReturnType,\n              method[returnTypeKey],\n            );\n          }\n        } else {\n          method.kind = \"method\";\n        }\n        return this.finishNode(method, \"TSMethodSignature\");\n      } else {\n        const property: N.TsPropertySignature = 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\n    tsParseTypeMember(): N.TsTypeElement {\n      const node: any = this.startNode();\n\n      if (this.match(tt.parenL) || this.match(tt.lt)) {\n        return this.tsParseSignatureMember(\"TSCallSignatureDeclaration\", node);\n      }\n\n      if (this.match(tt._new)) {\n        const id = this.startNode<N.Identifier>();\n        this.next();\n        if (this.match(tt.parenL) || this.match(tt.lt)) {\n          return this.tsParseSignatureMember(\n            \"TSConstructSignatureDeclaration\",\n            node,\n          );\n        } else {\n          node.key = this.createIdentifier(id, \"new\");\n          return this.tsParsePropertyOrMethodSignature(node, false);\n        }\n      }\n\n      this.tsParseModifiers(\n        {\n          allowedModifiers: [\"readonly\"],\n          disallowedModifiers: [\n            \"declare\",\n            \"abstract\",\n            \"private\",\n            \"protected\",\n            \"public\",\n            \"static\",\n            \"override\",\n          ],\n        },\n        node,\n      );\n\n      const idx = this.tsTryParseIndexSignature(node);\n      if (idx) {\n        return idx;\n      }\n\n      super.parsePropertyName(node);\n      if (\n        !node.computed &&\n        node.key.type === \"Identifier\" &&\n        (node.key.name === \"get\" || node.key.name === \"set\") &&\n        this.tsTokenCanFollowModifier()\n      ) {\n        node.kind = node.key.name;\n        super.parsePropertyName(node);\n      }\n      return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);\n    }\n\n    tsParseTypeLiteral(): N.TsTypeLiteral {\n      const node = this.startNode<N.TsTypeLiteral>();\n      node.members = this.tsParseObjectTypeMembers();\n      return this.finishNode(node, \"TSTypeLiteral\");\n    }\n\n    tsParseObjectTypeMembers(): Array<N.TsTypeElement> {\n      this.expect(tt.braceL);\n      const members = this.tsParseList(\n        \"TypeMembers\",\n        this.tsParseTypeMember.bind(this),\n      );\n      this.expect(tt.braceR);\n      return members;\n    }\n\n    tsIsStartOfMappedType(): boolean {\n      this.next();\n      if (this.eat(tt.plusMin)) {\n        return this.isContextual(tt._readonly);\n      }\n      if (this.isContextual(tt._readonly)) {\n        this.next();\n      }\n      if (!this.match(tt.bracketL)) {\n        return false;\n      }\n      this.next();\n      if (!this.tsIsIdentifier()) {\n        return false;\n      }\n      this.next();\n      return this.match(tt._in);\n    }\n\n    tsParseMappedType(): N.TsMappedType {\n      const node = this.startNode<N.TsMappedType>();\n\n      this.expect(tt.braceL);\n\n      if (this.match(tt.plusMin)) {\n        node.readonly = this.state.value;\n        this.next();\n        this.expectContextual(tt._readonly);\n      } else if (this.eatContextual(tt._readonly)) {\n        node.readonly = true;\n      }\n\n      this.expect(tt.bracketL);\n      if (process.env.BABEL_8_BREAKING) {\n        node.key = this.tsParseTypeParameterName() as N.Identifier;\n        node.constraint = this.tsExpectThenParseType(tt._in);\n      } else {\n        const typeParameter = this.startNode<N.TsTypeParameter>();\n        typeParameter.name = this.tsParseTypeParameterName();\n        typeParameter.constraint = this.tsExpectThenParseType(tt._in);\n        // @ts-expect-error for Babel 7\n        node.typeParameter = this.finishNode(typeParameter, \"TSTypeParameter\");\n      }\n      node.nameType = this.eatContextual(tt._as) ? this.tsParseType() : null;\n\n      this.expect(tt.bracketR);\n\n      if (this.match(tt.plusMin)) {\n        node.optional = this.state.value;\n        this.next();\n        this.expect(tt.question);\n      } else if (this.eat(tt.question)) {\n        node.optional = true;\n      }\n\n      node.typeAnnotation = this.tsTryParseType();\n      this.semicolon();\n      this.expect(tt.braceR);\n\n      return this.finishNode(node, \"TSMappedType\");\n    }\n\n    tsParseTupleType(): N.TsTupleType {\n      const node = this.startNode<N.TsTupleType>();\n      node.elementTypes = this.tsParseBracketedList(\n        \"TupleElementTypes\",\n        this.tsParseTupleElementType.bind(this),\n        /* bracket */ true,\n        /* skipFirstToken */ false,\n      );\n\n      // Validate the elementTypes to ensure that no mandatory elements\n      // follow optional elements\n      let seenOptionalElement = false;\n      node.elementTypes.forEach(elementNode => {\n        const { type } = elementNode;\n\n        if (\n          seenOptionalElement &&\n          type !== \"TSRestType\" &&\n          type !== \"TSOptionalType\" &&\n          !(type === \"TSNamedTupleMember\" && elementNode.optional)\n        ) {\n          this.raise(TSErrors.OptionalTypeBeforeRequired, elementNode);\n        }\n\n        seenOptionalElement ||=\n          (type === \"TSNamedTupleMember\" && elementNode.optional) ||\n          type === \"TSOptionalType\";\n      });\n\n      return this.finishNode(node, \"TSTupleType\");\n    }\n\n    tsParseTupleElementType(): N.TsNamedTupleMember | N.TsType {\n      // parses `...TsType[]`\n\n      const { startLoc } = this.state;\n\n      const rest = this.eat(tt.ellipsis);\n\n      let labeled: boolean;\n      let label: N.Identifier;\n      let optional: boolean;\n      let type: N.TsNamedTupleMember | N.TsType;\n\n      const isWord = tokenIsKeywordOrIdentifier(this.state.type);\n      const chAfterWord = isWord ? this.lookaheadCharCode() : null;\n      if (chAfterWord === charCodes.colon) {\n        labeled = true;\n        optional = false;\n        label = this.parseIdentifier(true);\n        this.expect(tt.colon);\n        type = this.tsParseType();\n      } else if (chAfterWord === charCodes.questionMark) {\n        optional = true;\n        const startLoc = this.state.startLoc;\n        const wordName = this.state.value;\n        const typeOrLabel = this.tsParseNonArrayType();\n\n        if (this.lookaheadCharCode() === charCodes.colon) {\n          labeled = true;\n          label = this.createIdentifier(\n            this.startNodeAt<N.Identifier>(startLoc),\n            wordName,\n          );\n          this.expect(tt.question);\n          this.expect(tt.colon);\n          type = this.tsParseType();\n        } else {\n          labeled = false;\n          type = typeOrLabel;\n          this.expect(tt.question);\n        }\n      } else {\n        type = this.tsParseType();\n        optional = this.eat(tt.question);\n        // In this case (labeled === true) could be only in invalid label.\n        // E.g. [x.y:type]\n        // An error is raised while processing node.\n        labeled = this.eat(tt.colon);\n      }\n\n      if (labeled) {\n        let labeledNode: Undone<N.TsNamedTupleMember>;\n        if (label) {\n          labeledNode = this.startNodeAtNode<N.TsNamedTupleMember>(label);\n          labeledNode.optional = optional;\n          labeledNode.label = label;\n          labeledNode.elementType = type;\n\n          if (this.eat(tt.question)) {\n            labeledNode.optional = true;\n            this.raise(\n              TSErrors.TupleOptionalAfterType,\n              this.state.lastTokStartLoc,\n            );\n          }\n        } else {\n          labeledNode = this.startNodeAtNode<N.TsNamedTupleMember>(type);\n          labeledNode.optional = optional;\n          this.raise(TSErrors.InvalidTupleMemberLabel, type);\n          // @ts-expect-error This produces an invalid AST, but at least we don't drop\n          // nodes representing the invalid source.\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<N.TsOptionalType>(type);\n        optionalTypeNode.typeAnnotation = type;\n        type = this.finishNode(optionalTypeNode, \"TSOptionalType\");\n      }\n\n      if (rest) {\n        const restNode = this.startNodeAt<N.TsRestType>(startLoc);\n        restNode.typeAnnotation = type;\n        type = this.finishNode(restNode, \"TSRestType\");\n      }\n\n      return type;\n    }\n\n    tsParseParenthesizedType(): N.TsParenthesizedType {\n      const node = this.startNode<N.TsParenthesizedType>();\n      this.expect(tt.parenL);\n      node.typeAnnotation = this.tsParseType();\n      this.expect(tt.parenR);\n      return this.finishNode(node, \"TSParenthesizedType\");\n    }\n\n    tsParseFunctionOrConstructorType(\n      type: \"TSFunctionType\" | \"TSConstructorType\",\n      abstract?: boolean,\n    ): N.TsFunctionOrConstructorType {\n      const node = this.startNode<\n        N.TsFunctionOrConstructorType | N.TsConstructorType\n      >();\n      if (type === \"TSConstructorType\") {\n        (node as Undone<N.TsConstructorType>).abstract = !!abstract;\n        if (abstract) this.next();\n        this.next(); // eat `new`\n      }\n      this.tsInAllowConditionalTypesContext(() =>\n        this.tsFillSignature(tt.arrow, node),\n      );\n      return this.finishNode(node, type);\n    }\n\n    tsParseLiteralTypeNode(): N.TsLiteralType {\n      const node = this.startNode<N.TsLiteralType>();\n      switch (this.state.type) {\n        case tt.num:\n        case tt.bigint:\n        case tt.string:\n        case tt._true:\n        case tt._false:\n          // For compatibility to estree we cannot call parseLiteral directly here\n          // @ts-expect-error refine typings\n          node.literal = super.parseExprAtom();\n          break;\n        default:\n          this.unexpected();\n      }\n      return this.finishNode(node, \"TSLiteralType\");\n    }\n\n    tsParseTemplateLiteralType(): N.TsLiteralType {\n      const node = this.startNode<N.TsLiteralType>();\n      node.literal = super.parseTemplate(false);\n      return this.finishNode(node, \"TSLiteralType\");\n    }\n\n    parseTemplateSubstitution(): N.TsType | N.Expression {\n      if (this.state.inType) return this.tsParseType();\n      return super.parseTemplateSubstitution();\n    }\n\n    tsParseThisTypeOrThisTypePredicate(): N.TsThisType | N.TsTypePredicate {\n      const thisKeyword = this.tsParseThisTypeNode();\n      if (this.isContextual(tt._is) && !this.hasPrecedingLineBreak()) {\n        return this.tsParseThisTypePredicate(thisKeyword);\n      } else {\n        return thisKeyword;\n      }\n    }\n\n    tsParseNonArrayType(): N.TsType {\n      switch (this.state.type) {\n        case tt.string:\n        case tt.num:\n        case tt.bigint:\n        case tt._true:\n        case tt._false:\n          return this.tsParseLiteralTypeNode();\n        case tt.plusMin:\n          if (this.state.value === \"-\") {\n            const node = this.startNode<N.TsLiteralType>();\n            const nextToken = this.lookahead();\n            if (nextToken.type !== tt.num && nextToken.type !== tt.bigint) {\n              this.unexpected();\n            }\n            // @ts-expect-error: parseMaybeUnary must returns unary expression\n            node.literal = this.parseMaybeUnary();\n            return this.finishNode(node, \"TSLiteralType\");\n          }\n          break;\n        case tt._this:\n          return this.tsParseThisTypeOrThisTypePredicate();\n        case tt._typeof:\n          return this.tsParseTypeQuery();\n        case tt._import:\n          return this.tsParseImportType();\n        case tt.braceL:\n          return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this))\n            ? this.tsParseMappedType()\n            : this.tsParseTypeLiteral();\n        case tt.bracketL:\n          return this.tsParseTupleType();\n        case tt.parenL:\n          if (process.env.BABEL_8_BREAKING) {\n            if (\n              !(this.optionFlags & OptionFlags.CreateParenthesizedExpressions)\n            ) {\n              const startLoc = this.state.startLoc;\n              this.next();\n              const type = this.tsParseType();\n              this.expect(tt.parenR);\n              this.addExtra(type, \"parenthesized\", true);\n              this.addExtra(type, \"parenStart\", startLoc.index);\n              return type;\n            }\n          }\n\n          return this.tsParseParenthesizedType();\n        case tt.templateNonTail:\n        case tt.templateTail:\n          return this.tsParseTemplateLiteralType();\n        default: {\n          const { type } = this.state;\n          if (\n            tokenIsIdentifier(type) ||\n            type === tt._void ||\n            type === tt._null\n          ) {\n            const nodeType =\n              type === tt._void\n                ? \"TSVoidKeyword\"\n                : type === tt._null\n                  ? \"TSNullKeyword\"\n                  : keywordTypeFromName(this.state.value);\n            if (\n              nodeType !== undefined &&\n              this.lookaheadCharCode() !== charCodes.dot\n            ) {\n              const node = this.startNode<N.TsKeywordType>();\n              this.next();\n              return this.finishNode(node, nodeType);\n            }\n            return this.tsParseTypeReference();\n          }\n        }\n      }\n\n      this.unexpected();\n    }\n\n    tsParseArrayTypeOrHigher(): N.TsType {\n      let type = this.tsParseNonArrayType();\n      while (!this.hasPrecedingLineBreak() && this.eat(tt.bracketL)) {\n        if (this.match(tt.bracketR)) {\n          const node = this.startNodeAtNode<N.TsArrayType>(type);\n          node.elementType = type;\n          this.expect(tt.bracketR);\n          type = this.finishNode(node, \"TSArrayType\");\n        } else {\n          const node = this.startNodeAtNode<N.TsIndexedAccessType>(type);\n          node.objectType = type;\n          node.indexType = this.tsParseType();\n          this.expect(tt.bracketR);\n          type = this.finishNode(node, \"TSIndexedAccessType\");\n        }\n      }\n      return type;\n    }\n\n    tsParseTypeOperator(): N.TsTypeOperator {\n      const node = this.startNode<N.TsTypeOperator>();\n      const operator = this.state.value;\n      this.next(); // eat operator\n      node.operator = operator;\n      node.typeAnnotation = this.tsParseTypeOperatorOrHigher();\n\n      if (operator === \"readonly\") {\n        this.tsCheckTypeAnnotationForReadOnly(node);\n      }\n\n      return this.finishNode(node, \"TSTypeOperator\");\n    }\n\n    tsCheckTypeAnnotationForReadOnly(node: Undone<N.TsTypeOperator>) {\n      switch (node.typeAnnotation.type) {\n        case \"TSTupleType\":\n        case \"TSArrayType\":\n          return;\n        default:\n          this.raise(TSErrors.UnexpectedReadonly, node);\n      }\n    }\n\n    tsParseInferType(): N.TsInferType {\n      const node = this.startNode<N.TsInferType>();\n      this.expectContextual(tt._infer);\n      const typeParameter = this.startNode<N.TsTypeParameter>();\n      typeParameter.name = this.tsParseTypeParameterName();\n      typeParameter.constraint = this.tsTryParse(() =>\n        this.tsParseConstraintForInferType(),\n      );\n      node.typeParameter = this.finishNode(typeParameter, \"TSTypeParameter\");\n      return this.finishNode(node, \"TSInferType\");\n    }\n\n    tsParseConstraintForInferType() {\n      if (this.eat(tt._extends)) {\n        const constraint = this.tsInDisallowConditionalTypesContext(() =>\n          this.tsParseType(),\n        );\n        if (\n          this.state.inDisallowConditionalTypesContext ||\n          !this.match(tt.question)\n        ) {\n          return constraint;\n        }\n      }\n    }\n\n    tsParseTypeOperatorOrHigher(): N.TsType {\n      const isTypeOperator =\n        tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;\n      return isTypeOperator\n        ? this.tsParseTypeOperator()\n        : this.isContextual(tt._infer)\n          ? this.tsParseInferType()\n          : this.tsInAllowConditionalTypesContext(() =>\n              this.tsParseArrayTypeOrHigher(),\n            );\n    }\n\n    tsParseUnionOrIntersectionType(\n      kind: \"TSUnionType\" | \"TSIntersectionType\",\n      parseConstituentType: () => N.TsType,\n      operator: TokenType,\n    ): N.TsType {\n      const node = this.startNode<N.TsUnionType | N.TsIntersectionType>();\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\n    tsParseIntersectionTypeOrHigher(): N.TsType {\n      return this.tsParseUnionOrIntersectionType(\n        \"TSIntersectionType\",\n        this.tsParseTypeOperatorOrHigher.bind(this),\n        tt.bitwiseAND,\n      );\n    }\n\n    tsParseUnionTypeOrHigher() {\n      return this.tsParseUnionOrIntersectionType(\n        \"TSUnionType\",\n        this.tsParseIntersectionTypeOrHigher.bind(this),\n        tt.bitwiseOR,\n      );\n    }\n\n    tsIsStartOfFunctionType() {\n      if (this.match(tt.lt)) {\n        return true;\n      }\n      return (\n        this.match(tt.parenL) &&\n        this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this))\n      );\n    }\n\n    tsSkipParameterStart(): boolean {\n      if (tokenIsIdentifier(this.state.type) || this.match(tt._this)) {\n        this.next();\n        return true;\n      }\n\n      if (this.match(tt.braceL)) {\n        // Return true if we can parse an object pattern without errors\n        const { errors } = this.state;\n        const previousErrorCount = errors.length;\n        try {\n          this.parseObjectLike(tt.braceR, true);\n          return errors.length === previousErrorCount;\n        } catch {\n          return false;\n        }\n      }\n\n      if (this.match(tt.bracketL)) {\n        this.next();\n        // Return true if we can parse an array pattern without errors\n        const { errors } = this.state;\n        const previousErrorCount = errors.length;\n        try {\n          super.parseBindingList(\n            tt.bracketR,\n            charCodes.rightSquareBracket,\n            ParseBindingListFlags.ALLOW_EMPTY,\n          );\n          return errors.length === previousErrorCount;\n        } catch {\n          return false;\n        }\n      }\n\n      return false;\n    }\n\n    tsIsUnambiguouslyStartOfFunctionType(): boolean {\n      this.next();\n      if (this.match(tt.parenR) || this.match(tt.ellipsis)) {\n        // ( )\n        // ( ...\n        return true;\n      }\n      if (this.tsSkipParameterStart()) {\n        if (\n          this.match(tt.colon) ||\n          this.match(tt.comma) ||\n          this.match(tt.question) ||\n          this.match(tt.eq)\n        ) {\n          // ( xxx :\n          // ( xxx ,\n          // ( xxx ?\n          // ( xxx =\n          return true;\n        }\n        if (this.match(tt.parenR)) {\n          this.next();\n          if (this.match(tt.arrow)) {\n            // ( xxx ) =>\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n\n    tsParseTypeOrTypePredicateAnnotation(\n      returnToken: TokenType,\n    ): N.TsTypeAnnotation {\n      return this.tsInType(() => {\n        const t = this.startNode<N.TsTypeAnnotation>();\n        this.expect(returnToken);\n\n        const node = this.startNode<N.TsTypePredicate>();\n\n        const asserts = !!this.tsTryParse(\n          this.tsParseTypePredicateAsserts.bind(this),\n        );\n\n        if (asserts && this.match(tt._this)) {\n          // When asserts is false, thisKeyword is handled by tsParseNonArrayType\n          // : asserts this is type\n          let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();\n          // if it turns out to be a `TSThisType`, wrap it with `TSTypePredicate`\n          // : asserts this\n          if (thisTypePredicate.type === \"TSThisType\") {\n            node.parameterName = thisTypePredicate;\n            node.asserts = true;\n            (node as N.TsTypePredicate).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\n        const typePredicateVariable =\n          this.tsIsIdentifier() &&\n          this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));\n\n        if (!typePredicateVariable) {\n          if (!asserts) {\n            // : type\n            return this.tsParseTypeAnnotation(/* eatColon */ false, t);\n          }\n\n          // : asserts foo\n          node.parameterName = this.parseIdentifier();\n          node.asserts = asserts;\n          (node as N.TsTypePredicate).typeAnnotation = null;\n          t.typeAnnotation = this.finishNode(node, \"TSTypePredicate\");\n          return this.finishNode(t, \"TSTypeAnnotation\");\n        }\n\n        // : asserts foo is type\n        const type = this.tsParseTypeAnnotation(/* eatColon */ 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\n    tsTryParseTypeOrTypePredicateAnnotation(): N.TsTypeAnnotation | undefined {\n      if (this.match(tt.colon)) {\n        return this.tsParseTypeOrTypePredicateAnnotation(tt.colon);\n      }\n    }\n\n    tsTryParseTypeAnnotation(): N.TsTypeAnnotation | undefined {\n      if (this.match(tt.colon)) {\n        return this.tsParseTypeAnnotation();\n      }\n    }\n\n    tsTryParseType(): N.TsType | undefined {\n      return this.tsEatThenParseType(tt.colon);\n    }\n\n    tsParseTypePredicatePrefix(): N.Identifier | undefined {\n      const id = this.parseIdentifier();\n      if (this.isContextual(tt._is) && !this.hasPrecedingLineBreak()) {\n        this.next();\n        return id;\n      }\n    }\n\n    tsParseTypePredicateAsserts(): boolean {\n      if (this.state.type !== tt._asserts) {\n        return false;\n      }\n      const containsEsc = this.state.containsEsc;\n      this.next();\n      if (!tokenIsIdentifier(this.state.type) && !this.match(tt._this)) {\n        return false;\n      }\n\n      if (containsEsc) {\n        this.raise(\n          Errors.InvalidEscapedReservedWord,\n          this.state.lastTokStartLoc,\n          {\n            reservedWord: \"asserts\",\n          },\n        );\n      }\n\n      return true;\n    }\n\n    tsParseTypeAnnotation(\n      eatColon = true,\n      t: Undone<N.TsTypeAnnotation> = this.startNode<N.TsTypeAnnotation>(),\n    ): N.TsTypeAnnotation {\n      this.tsInType(() => {\n        if (eatColon) this.expect(tt.colon);\n        t.typeAnnotation = this.tsParseType();\n      });\n      return this.finishNode(t, \"TSTypeAnnotation\");\n    }\n\n    /** Be sure to be in a type context before calling this, using `tsInType`. */\n    tsParseType(): N.TsType {\n      // Need to set `state.inType` so that we don't parse JSX in a type context.\n      assert(this.state.inType);\n      const type = this.tsParseNonConditionalType();\n\n      if (\n        this.state.inDisallowConditionalTypesContext ||\n        this.hasPrecedingLineBreak() ||\n        !this.eat(tt._extends)\n      ) {\n        return type;\n      }\n      const node = this.startNodeAtNode<N.TsConditionalType>(type);\n      node.checkType = type;\n\n      node.extendsType = this.tsInDisallowConditionalTypesContext(() =>\n        this.tsParseNonConditionalType(),\n      );\n\n      this.expect(tt.question);\n      node.trueType = this.tsInAllowConditionalTypesContext(() =>\n        this.tsParseType(),\n      );\n\n      this.expect(tt.colon);\n      node.falseType = this.tsInAllowConditionalTypesContext(() =>\n        this.tsParseType(),\n      );\n\n      return this.finishNode(node, \"TSConditionalType\");\n    }\n\n    isAbstractConstructorSignature(): boolean {\n      return (\n        this.isContextual(tt._abstract) && this.lookahead().type === tt._new\n      );\n    }\n\n    tsParseNonConditionalType(): N.TsType {\n      if (this.tsIsStartOfFunctionType()) {\n        return this.tsParseFunctionOrConstructorType(\"TSFunctionType\");\n      }\n      if (this.match(tt._new)) {\n        // As in `new () => Date`\n        return this.tsParseFunctionOrConstructorType(\"TSConstructorType\");\n      } else if (this.isAbstractConstructorSignature()) {\n        // As in `abstract new () => Date`\n        return this.tsParseFunctionOrConstructorType(\n          \"TSConstructorType\",\n          /* abstract */ true,\n        );\n      }\n      return this.tsParseUnionTypeOrHigher();\n    }\n\n    tsParseTypeAssertion(): N.TsTypeAssertion {\n      if (this.getPluginOption(\"typescript\", \"disallowAmbiguousJSXLike\")) {\n        this.raise(TSErrors.ReservedTypeAssertion, this.state.startLoc);\n      }\n\n      const node = this.startNode<N.TsTypeAssertion>();\n      node.typeAnnotation = this.tsInType(() => {\n        this.next(); // \"<\"\n        return this.match(tt._const)\n          ? this.tsParseTypeReference()\n          : this.tsParseType();\n      });\n      this.expect(tt.gt);\n      node.expression = this.parseMaybeUnary();\n      return this.finishNode(node, \"TSTypeAssertion\");\n    }\n\n    tsParseHeritageClause(token: \"extends\"): Array<N.TSInterfaceHeritage>;\n    tsParseHeritageClause(token: \"implements\"): Array<N.TSClassImplements>;\n    tsParseHeritageClause(\n      token: \"extends\" | \"implements\",\n    ): Array<N.TSClassImplements> | Array<N.TSInterfaceHeritage> {\n      const originalStartLoc = this.state.startLoc;\n\n      const delimitedList = this.tsParseDelimitedList(\n        \"HeritageClauseElement\",\n        () => {\n          const node = this.startNode<\n            N.TSClassImplements | N.TSInterfaceHeritage\n          >();\n          if (process.env.BABEL_8_BREAKING) {\n            node.expression = this.tsParseEntityName(\n              tsParseEntityNameFlags.ALLOW_RESERVED_WORDS,\n            );\n            if (this.match(tt.lt)) {\n              node.typeArguments = this.tsParseTypeArguments();\n            }\n            return this.finishNode(\n              node,\n              token === \"extends\" ? \"TSInterfaceHeritage\" : \"TSClassImplements\",\n            );\n          } else {\n            node.expression = this.tsParseEntityName(\n              tsParseEntityNameFlags.ALLOW_RESERVED_WORDS |\n                tsParseEntityNameFlags.LEADING_THIS_AS_IDENTIFIER,\n            );\n            if (this.match(tt.lt)) {\n              // @ts-expect-error Babel 7 vs Babel 8\n              node.typeParameters = this.tsParseTypeArguments();\n            }\n\n            return this.finishNode(\n              node,\n              // @ts-expect-error Babel 7 vs Babel 8\n              \"TSExpressionWithTypeArguments\",\n            );\n          }\n        },\n      );\n\n      if (!delimitedList.length) {\n        this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, {\n          token,\n        });\n      }\n\n      return delimitedList as\n        | Array<N.TSClassImplements>\n        | Array<N.TSInterfaceHeritage>;\n    }\n\n    tsParseInterfaceDeclaration(\n      node: Undone<N.TsInterfaceDeclaration>,\n      properties: {\n        declare?: true;\n      } = {},\n    ): N.TsInterfaceDeclaration | null {\n      if (this.hasFollowingLineBreak()) return null;\n      this.expectContextual(tt._interface);\n      if (properties.declare) node.declare = true;\n      if (tokenIsIdentifier(this.state.type)) {\n        node.id = this.parseIdentifier();\n        this.checkIdentifier(node.id, BindingFlag.TYPE_TS_INTERFACE);\n      } else {\n        node.id = null;\n        this.raise(TSErrors.MissingInterfaceName, this.state.startLoc);\n      }\n\n      node.typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseInOutConstModifiers,\n      );\n      if (this.eat(tt._extends)) {\n        node.extends = this.tsParseHeritageClause(\"extends\");\n      }\n      const body = this.startNode<N.TSInterfaceBody>();\n      body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));\n      node.body = this.finishNode(body, \"TSInterfaceBody\");\n      return this.finishNode(node, \"TSInterfaceDeclaration\");\n    }\n\n    tsParseTypeAliasDeclaration(\n      node: N.TsTypeAliasDeclaration,\n    ): N.TsTypeAliasDeclaration {\n      node.id = this.parseIdentifier();\n      this.checkIdentifier(node.id, BindingFlag.TYPE_TS_TYPE);\n\n      node.typeAnnotation = this.tsInType(() => {\n        node.typeParameters = this.tsTryParseTypeParameters(\n          this.tsParseInOutModifiers,\n        );\n\n        this.expect(tt.eq);\n\n        if (\n          this.isContextual(tt._intrinsic) &&\n          this.lookahead().type !== tt.dot\n        ) {\n          const node = this.startNode<N.TsKeywordType>();\n          this.next();\n          return this.finishNode(node, \"TSIntrinsicKeyword\");\n        }\n\n        return this.tsParseType();\n      });\n\n      this.semicolon();\n      return this.finishNode(node, \"TSTypeAliasDeclaration\");\n    }\n\n    // Parse in top level normal context if we are in a JSX context\n    tsInTopLevelContext<T>(cb: () => T): T {\n      if (this.curContext() !== tc.brace) {\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      } else {\n        return cb();\n      }\n    }\n\n    /**\n     * Runs `cb` in a type context.\n     * This should be called one token *before* the first type token,\n     * so that the call to `next()` is run in type context.\n     */\n    tsInType<T>(cb: () => T): T {\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\n    tsInDisallowConditionalTypesContext<T>(cb: () => T): T {\n      const oldInDisallowConditionalTypesContext =\n        this.state.inDisallowConditionalTypesContext;\n      this.state.inDisallowConditionalTypesContext = true;\n      try {\n        return cb();\n      } finally {\n        this.state.inDisallowConditionalTypesContext =\n          oldInDisallowConditionalTypesContext;\n      }\n    }\n\n    tsInAllowConditionalTypesContext<T>(cb: () => T): T {\n      const oldInDisallowConditionalTypesContext =\n        this.state.inDisallowConditionalTypesContext;\n      this.state.inDisallowConditionalTypesContext = false;\n      try {\n        return cb();\n      } finally {\n        this.state.inDisallowConditionalTypesContext =\n          oldInDisallowConditionalTypesContext;\n      }\n    }\n\n    tsEatThenParseType(token: TokenType): N.TsType | undefined {\n      if (this.match(token)) {\n        return this.tsNextThenParseType();\n      }\n    }\n\n    tsExpectThenParseType(token: TokenType): N.TsType {\n      return this.tsInType(() => {\n        this.expect(token);\n        return this.tsParseType();\n      });\n    }\n\n    tsNextThenParseType(): N.TsType {\n      return this.tsInType(() => {\n        this.next();\n        return this.tsParseType();\n      });\n    }\n\n    tsParseEnumMember(): N.TsEnumMember {\n      const node = this.startNode<N.TsEnumMember>();\n      // Computed property names are grammar errors in an enum, so accept just string literal or identifier.\n      node.id = this.match(tt.string)\n        ? super.parseStringLiteral(this.state.value)\n        : this.parseIdentifier(/* liberal */ true);\n      if (this.eat(tt.eq)) {\n        node.initializer = super.parseMaybeAssignAllowIn();\n      }\n      return this.finishNode(node, \"TSEnumMember\");\n    }\n\n    tsParseEnumDeclaration(\n      node: Undone<N.TsEnumDeclaration>,\n      properties: {\n        const?: true;\n        declare?: true;\n      } = {},\n    ): N.TsEnumDeclaration {\n      if (properties.const) node.const = true;\n      if (properties.declare) node.declare = true;\n      this.expectContextual(tt._enum);\n      node.id = this.parseIdentifier();\n      this.checkIdentifier(\n        node.id,\n        node.const ? BindingFlag.TYPE_TS_CONST_ENUM : BindingFlag.TYPE_TS_ENUM,\n      );\n\n      if (process.env.BABEL_8_BREAKING) {\n        node.body = this.tsParseEnumBody();\n      } else {\n        this.expect(tt.braceL);\n        node.members = this.tsParseDelimitedList(\n          \"EnumMembers\",\n          this.tsParseEnumMember.bind(this),\n        );\n        this.expect(tt.braceR);\n      }\n      return this.finishNode(node, \"TSEnumDeclaration\");\n    }\n\n    tsParseEnumBody(): N.TsEnumBody {\n      const node = this.startNode<N.TsEnumBody>();\n      this.expect(tt.braceL);\n      node.members = this.tsParseDelimitedList(\n        \"EnumMembers\",\n        this.tsParseEnumMember.bind(this),\n      );\n      this.expect(tt.braceR);\n      return this.finishNode(node, \"TSEnumBody\");\n    }\n\n    tsParseModuleBlock(): N.TsModuleBlock {\n      const node = this.startNode<N.TsModuleBlock>();\n      this.scope.enter(ScopeFlag.OTHER);\n\n      this.expect(tt.braceL);\n      // Inside of a module block is considered \"top-level\", meaning it can have imports and exports.\n      super.parseBlockOrModuleBlockBody(\n        (node.body = []),\n        /* directives */ undefined,\n        /* topLevel */ true,\n        /* end */ tt.braceR,\n      );\n      this.scope.exit();\n      return this.finishNode(node, \"TSModuleBlock\");\n    }\n\n    tsParseModuleOrNamespaceDeclaration(\n      node: Undone<N.TsModuleDeclaration>,\n      nested: boolean = false,\n    ): N.TsModuleDeclaration {\n      node.id = process.env.BABEL_8_BREAKING\n        ? this.tsParseEntityName(tsParseEntityNameFlags.ALLOW_RESERVED_WORDS)\n        : this.parseIdentifier();\n\n      if (\n        process.env.BABEL_8_BREAKING ? node.id.type === \"Identifier\" : !nested\n      ) {\n        // @ts-expect-error checked above\n        this.checkIdentifier(node.id, BindingFlag.TYPE_TS_NAMESPACE);\n      }\n\n      if (!process.env.BABEL_8_BREAKING && this.eat(tt.dot)) {\n        const inner = this.startNode<N.TsModuleDeclaration>();\n        this.tsParseModuleOrNamespaceDeclaration(inner, true);\n        // @ts-expect-error Fixme: refine typings\n        node.body = inner;\n      } else {\n        this.scope.enter(ScopeFlag.TS_MODULE);\n        this.prodParam.enter(ParamKind.PARAM);\n        node.body = this.tsParseModuleBlock();\n        this.prodParam.exit();\n        this.scope.exit();\n      }\n      return this.finishNode(node, \"TSModuleDeclaration\");\n    }\n\n    tsParseAmbientExternalModuleDeclaration(\n      node: N.TsModuleDeclaration,\n    ): N.TsModuleDeclaration {\n      if (this.isContextual(tt._global)) {\n        node.kind = \"global\";\n        if (!process.env.BABEL_8_BREAKING) {\n          node.global = true;\n        }\n        node.id = this.parseIdentifier();\n      } else if (this.match(tt.string)) {\n        node.kind = \"module\";\n        node.id = super.parseStringLiteral(this.state.value);\n      } else {\n        this.unexpected();\n      }\n      if (this.match(tt.braceL)) {\n        this.scope.enter(ScopeFlag.TS_MODULE);\n        this.prodParam.enter(ParamKind.PARAM);\n        node.body = this.tsParseModuleBlock();\n        this.prodParam.exit();\n        this.scope.exit();\n      } else {\n        this.semicolon();\n      }\n\n      return this.finishNode(node, \"TSModuleDeclaration\");\n    }\n\n    tsParseImportEqualsDeclaration(\n      node: Undone<N.TsImportEqualsDeclaration>,\n      maybeDefaultIdentifier?: N.Identifier | null,\n      isExport?: boolean,\n    ): N.TsImportEqualsDeclaration {\n      node.isExport = isExport || false;\n      node.id = maybeDefaultIdentifier || this.parseIdentifier();\n      this.checkIdentifier(node.id, BindingFlag.TYPE_TS_VALUE_IMPORT);\n      this.expect(tt.eq);\n      const moduleReference = this.tsParseModuleReference();\n      if (\n        node.importKind === \"type\" &&\n        moduleReference.type !== \"TSExternalModuleReference\"\n      ) {\n        this.raise(TSErrors.ImportAliasHasImportType, moduleReference);\n      }\n      node.moduleReference = moduleReference;\n      this.semicolon();\n      return this.finishNode(node, \"TSImportEqualsDeclaration\");\n    }\n\n    tsIsExternalModuleReference(): boolean {\n      return (\n        this.isContextual(tt._require) &&\n        this.lookaheadCharCode() === charCodes.leftParenthesis\n      );\n    }\n\n    tsParseModuleReference(): N.TsModuleReference {\n      return this.tsIsExternalModuleReference()\n        ? this.tsParseExternalModuleReference()\n        : this.tsParseEntityName(tsParseEntityNameFlags.NONE);\n    }\n\n    tsParseExternalModuleReference(): N.TsExternalModuleReference {\n      const node = this.startNode<N.TsExternalModuleReference>();\n      this.expectContextual(tt._require);\n      this.expect(tt.parenL);\n      if (!this.match(tt.string)) {\n        this.unexpected();\n      }\n      // For compatibility to estree we cannot call parseLiteral directly here\n      node.expression = super.parseExprAtom() as N.StringLiteral;\n      this.expect(tt.parenR);\n      this.sawUnambiguousESM = true;\n      return this.finishNode(node, \"TSExternalModuleReference\");\n    }\n\n    // Utilities\n\n    tsLookAhead<T>(f: () => T): T {\n      const state = this.state.clone();\n      const res = f();\n      this.state = state;\n      return res;\n    }\n\n    tsTryParseAndCatch<T extends N.NodeBase | undefined | null>(\n      f: () => T,\n    ): T | undefined | null {\n      const result = this.tryParse(\n        abort =>\n          // @ts-expect-error todo(flow->ts)\n          f() || abort(),\n      );\n\n      if (result.aborted || !result.node) return;\n      if (result.error) this.state = result.failState;\n      // @ts-expect-error refine typings\n      return result.node;\n    }\n\n    tsTryParse<T>(f: () => T | undefined | false): T | undefined {\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\n    tsTryParseDeclare(nany: any): N.Declaration | undefined {\n      if (this.isLineTerminator()) {\n        return;\n      }\n      let startType = this.state.type;\n      let kind: \"let\" | null;\n\n      if (this.isContextual(tt._let)) {\n        startType = tt._var;\n        kind = \"let\";\n      }\n\n      // @ts-expect-error refine typings\n      return this.tsInAmbientContext(() => {\n        switch (startType) {\n          case tt._function:\n            nany.declare = true;\n            return super.parseFunctionStatement(\n              nany,\n              /* async */ false,\n              /* isHangingDeclaration */ false,\n            );\n          case tt._class:\n            // While this is also set by tsParseExpressionStatement, we need to set it\n            // before parsing the class declaration to know how to register it in the scope.\n            nany.declare = true;\n            return this.parseClass(\n              nany,\n              /* isStatement */ true,\n              /* optionalId */ false,\n            );\n          case tt._enum:\n            return this.tsParseEnumDeclaration(nany, { declare: true });\n          case tt._global:\n            return this.tsParseAmbientExternalModuleDeclaration(nany);\n          case tt._const:\n          case tt._var:\n            if (!this.match(tt._const) || !this.isLookaheadContextual(\"enum\")) {\n              nany.declare = true;\n              return this.parseVarStatement(\n                nany,\n                kind || this.state.value,\n                true,\n              );\n            }\n\n            // `const enum = 0;` not allowed because \"enum\" is a strict mode reserved word.\n            this.expect(tt._const);\n            return this.tsParseEnumDeclaration(nany, {\n              const: true,\n              declare: true,\n            });\n          case tt._interface: {\n            const result = this.tsParseInterfaceDeclaration(nany, {\n              declare: true,\n            });\n            if (result) return result;\n          }\n          // fallthrough\n          default:\n            if (tokenIsIdentifier(startType)) {\n              return this.tsParseDeclaration(\n                nany,\n                this.state.value,\n                /* next */ true,\n                /* decorators */ null,\n              );\n            }\n        }\n      });\n    }\n\n    // Note: this won't be called unless the keyword is allowed in `shouldParseExportDeclaration`.\n    tsTryParseExportDeclaration(): N.Declaration | undefined {\n      return this.tsParseDeclaration(\n        this.startNode(),\n        this.state.value,\n        /* next */ true,\n        /* decorators */ null,\n      );\n    }\n\n    tsParseExpressionStatement(\n      node: Undone<N.TsModuleDeclaration>,\n      expr: N.Identifier,\n      decorators: N.Decorator[] | null,\n    ): N.Declaration | undefined {\n      switch (expr.name) {\n        case \"declare\": {\n          const declaration = this.tsTryParseDeclare(node);\n          if (declaration) {\n            declaration.declare = true;\n          }\n          return declaration;\n        }\n        case \"global\":\n          // `global { }` (with no `declare`) may appear inside an ambient module declaration.\n          // Would like to use tsParseAmbientExternalModuleDeclaration here, but already ran past \"global\".\n          if (this.match(tt.braceL)) {\n            this.scope.enter(ScopeFlag.TS_MODULE);\n            this.prodParam.enter(ParamKind.PARAM);\n            const mod = node;\n            mod.kind = \"global\";\n            if (!process.env.BABEL_8_BREAKING) {\n              node.global = true;\n            }\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\n        default:\n          return this.tsParseDeclaration(\n            node,\n            expr.name,\n            /* next */ false,\n            decorators,\n          );\n      }\n    }\n\n    // Common to tsTryParseDeclare, tsTryParseExportDeclaration, and tsParseExpressionStatement.\n    tsParseDeclaration(\n      node: any,\n      value: string,\n      next: boolean,\n      decorators: N.Decorator[] | null,\n    ): N.Declaration | undefined | null {\n      // no declaration apart from enum can be followed by a line break.\n      switch (value) {\n        case \"abstract\":\n          if (\n            this.tsCheckLineTerminator(next) &&\n            (this.match(tt._class) || tokenIsIdentifier(this.state.type))\n          ) {\n            return this.tsParseAbstractDeclaration(node, decorators);\n          }\n          break;\n\n        case \"module\":\n          if (this.tsCheckLineTerminator(next)) {\n            if (this.match(tt.string)) {\n              return this.tsParseAmbientExternalModuleDeclaration(node);\n            } else if (tokenIsIdentifier(this.state.type)) {\n              node.kind = \"module\";\n              return this.tsParseModuleOrNamespaceDeclaration(node);\n            }\n          }\n          break;\n\n        case \"namespace\":\n          if (\n            this.tsCheckLineTerminator(next) &&\n            tokenIsIdentifier(this.state.type)\n          ) {\n            node.kind = \"namespace\";\n            return this.tsParseModuleOrNamespaceDeclaration(node);\n          }\n          break;\n\n        case \"type\":\n          if (\n            this.tsCheckLineTerminator(next) &&\n            tokenIsIdentifier(this.state.type)\n          ) {\n            return this.tsParseTypeAliasDeclaration(node);\n          }\n          break;\n      }\n    }\n\n    tsCheckLineTerminator(next: boolean) {\n      if (next) {\n        if (this.hasFollowingLineBreak()) return false;\n        this.next();\n        return true;\n      }\n      return !this.isLineTerminator();\n    }\n\n    tsTryParseGenericAsyncArrowFunction(\n      startLoc: Position,\n    ): N.ArrowFunctionExpression | undefined {\n      if (!this.match(tt.lt)) return;\n\n      const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n      this.state.maybeInArrowParameters = true;\n\n      const res: Undone<N.ArrowFunctionExpression> | undefined =\n        this.tsTryParseAndCatch(() => {\n          const node = this.startNodeAt<N.ArrowFunctionExpression>(startLoc);\n          node.typeParameters = this.tsParseTypeParameters(\n            this.tsParseConstModifier,\n          );\n          // Don't use overloaded parseFunctionParams which would look for \"<\" again.\n          super.parseFunctionParams(node);\n          node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();\n          this.expect(tt.arrow);\n          return node;\n        });\n\n      this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n\n      if (!res) return;\n\n      return super.parseArrowExpression(\n        res,\n        /* params are already set */ null,\n        /* async */ true,\n      );\n    }\n\n    // Used when parsing type arguments from ES or JSX productions, where the first token\n    // has been created without state.inType. Thus we need to re-scan the lt token.\n    tsParseTypeArgumentsInExpression():\n      | N.TsTypeParameterInstantiation\n      | undefined {\n      if (this.reScan_lt() !== tt.lt) return;\n      return this.tsParseTypeArguments();\n    }\n\n    tsParseTypeArguments(): N.TsTypeParameterInstantiation {\n      const node = this.startNode<N.TsTypeParameterInstantiation>();\n      node.params = this.tsInType(() =>\n        this.tsInTopLevelContext(() => {\n          this.expect(tt.lt);\n          return this.tsParseDelimitedList(\n            \"TypeParametersOrArguments\",\n            this.tsParseType.bind(this),\n          );\n        }),\n      );\n      if (node.params.length === 0) {\n        this.raise(TSErrors.EmptyTypeArguments, node);\n      } else if (!this.state.inType && this.curContext() === tc.brace) {\n        // rescan `>` when we are no longer in type context and JSX parsing context\n        // since it was tokenized when `inType` is `true`.\n        this.reScan_lt_gt();\n      }\n      this.expect(tt.gt);\n      return this.finishNode(node, \"TSTypeParameterInstantiation\");\n    }\n\n    tsIsDeclarationStart(): boolean {\n      return tokenIsTSDeclarationStart(this.state.type);\n    }\n\n    // ======================================================\n    // OVERRIDES\n    // ======================================================\n\n    isExportDefaultSpecifier(): boolean {\n      if (this.tsIsDeclarationStart()) return false;\n      return super.isExportDefaultSpecifier();\n    }\n\n    parseAssignableListItem(\n      flags: ParseBindingListFlags,\n      decorators: N.Decorator[],\n    ): N.Pattern | N.TSParameterProperty {\n      // Store original location to include modifiers in range\n      const startLoc = this.state.startLoc;\n\n      const modified: ModifierBase = {};\n      this.tsParseModifiers(\n        {\n          allowedModifiers: [\n            \"public\",\n            \"private\",\n            \"protected\",\n            \"override\",\n            \"readonly\",\n          ],\n        },\n        modified,\n      );\n      const accessibility = modified.accessibility;\n      const override = modified.override;\n      const readonly = modified.readonly;\n      if (\n        !(flags & ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS) &&\n        (accessibility || readonly || override)\n      ) {\n        this.raise(TSErrors.UnexpectedParameterModifier, startLoc);\n      }\n\n      const left = this.parseMaybeDefault();\n      if (flags & ParseBindingListFlags.IS_FUNCTION_PARAMS) {\n        this.parseFunctionParamType(left);\n      }\n      const elt = this.parseMaybeDefault(left.loc.start, left);\n      if (accessibility || readonly || override) {\n        const pp = this.startNodeAt<N.TSParameterProperty>(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 as any as N.Identifier | N.AssignmentPattern;\n        return this.finishNode(pp, \"TSParameterProperty\");\n      }\n\n      if (decorators.length) {\n        left.decorators = decorators;\n      }\n\n      return elt;\n    }\n\n    isSimpleParameter(node: N.Pattern | N.TSParameterProperty): boolean {\n      return (\n        (node.type === \"TSParameterProperty\" &&\n          super.isSimpleParameter(node.parameter)) ||\n        super.isSimpleParameter(node)\n      );\n    }\n\n    tsDisallowOptionalPattern(node: Undone<N.Function>) {\n      for (const param of node.params) {\n        if (\n          param.type !== \"Identifier\" &&\n          (param as any).optional &&\n          !this.state.isAmbientContext\n        ) {\n          this.raise(TSErrors.PatternIsOptional, param);\n        }\n      }\n    }\n\n    setArrowFunctionParameters(\n      node: Undone<N.ArrowFunctionExpression>,\n      params: N.Expression[],\n      trailingCommaLoc?: Position | null,\n    ): void {\n      super.setArrowFunctionParameters(node, params, trailingCommaLoc);\n      this.tsDisallowOptionalPattern(node);\n    }\n\n    parseFunctionBodyAndFinish<\n      T extends\n        | N.Function\n        | N.TSDeclareMethod\n        | N.TSDeclareFunction\n        | N.ClassPrivateMethod,\n    >(node: Undone<T>, type: T[\"type\"], isMethod: boolean = false): T {\n      if (this.match(tt.colon)) {\n        node.returnType = this.tsParseTypeOrTypePredicateAnnotation(tt.colon);\n      }\n\n      const bodilessType =\n        type === \"FunctionDeclaration\"\n          ? \"TSDeclareFunction\"\n          : type === \"ClassMethod\" || type === \"ClassPrivateMethod\"\n            ? \"TSDeclareMethod\"\n            : undefined;\n      if (bodilessType && !this.match(tt.braceL) && 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 as Undone<N.FunctionDeclaration>).declare) {\n          return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);\n        }\n      }\n      this.tsDisallowOptionalPattern(node);\n\n      return super.parseFunctionBodyAndFinish(node, type, isMethod);\n    }\n\n    registerFunctionStatementId(node: N.Function): void {\n      if (!node.body && node.id) {\n        // Function ids are validated after parsing their body.\n        // For bodiless function, we need to do it here.\n        this.checkIdentifier(node.id, BindingFlag.TYPE_TS_AMBIENT);\n      } else {\n        super.registerFunctionStatementId(node);\n      }\n    }\n\n    tsCheckForInvalidTypeCasts(items: Array<N.Expression | N.SpreadElement>) {\n      items.forEach(node => {\n        if (node?.type === \"TSTypeCastExpression\") {\n          this.raise(TSErrors.UnexpectedTypeAnnotation, node.typeAnnotation);\n        }\n      });\n    }\n\n    toReferencedList(\n      exprList: Array<N.Expression | undefined | null>,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      isInParens?: boolean,\n    ): Array<N.Expression | undefined | null> {\n      // Handles invalid scenarios like: `f(a:b)`, `(a:b);`, and `(a:b,c:d)`.\n      //\n      // Note that `f<T>(a:b)` goes through a different path and is handled\n      // in `parseSubscript` directly.\n      this.tsCheckForInvalidTypeCasts(exprList);\n      return exprList;\n    }\n\n    parseArrayLike(\n      close: TokenType,\n      canBePattern: boolean,\n      isTuple: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.ArrayExpression | N.TupleExpression {\n      const node = super.parseArrayLike(\n        close,\n        canBePattern,\n        isTuple,\n        refExpressionErrors,\n      );\n\n      if (node.type === \"ArrayExpression\") {\n        this.tsCheckForInvalidTypeCasts(node.elements);\n      }\n\n      return node;\n    }\n\n    parseSubscript(\n      base: N.Expression,\n\n      startLoc: Position,\n      noCalls: boolean | undefined | null,\n      state: N.ParseSubscriptState,\n    ): N.Expression {\n      if (!this.hasPrecedingLineBreak() && this.match(tt.bang)) {\n        // When ! is consumed as a postfix operator (non-null assertion),\n        // disallow JSX tag forming after. e.g. When parsing `p! < n.p!`\n        // `<n.p` can not be a start of JSX tag\n        this.state.canStartJSXElement = false;\n        this.next();\n\n        const nonNullExpression =\n          this.startNodeAt<N.TsNonNullExpression>(startLoc);\n        nonNullExpression.expression = base;\n        return this.finishNode(nonNullExpression, \"TSNonNullExpression\");\n      }\n\n      let isOptionalCall = false;\n      if (\n        this.match(tt.questionDot) &&\n        this.lookaheadCharCode() === charCodes.lessThan\n      ) {\n        if (noCalls) {\n          state.stop = true;\n          return base;\n        }\n        state.optionalChainMember = isOptionalCall = true;\n        this.next();\n      }\n\n      // handles 'f<<T>'\n      if (this.match(tt.lt) || this.match(tt.bitShiftL)) {\n        let missingParenErrorLoc;\n        // tsTryParseAndCatch is expensive, so avoid if not necessary.\n        // There are number of things we are going to \"maybe\" parse, like type arguments on\n        // tagged template expressions. If any of them fail, walk it back and continue.\n        const result = this.tsTryParseAndCatch(() => {\n          if (!noCalls && this.atPossibleAsyncArrow(base)) {\n            // Almost certainly this is a generic async function `async <T>() => ...\n            // But it might be a call with a type argument `async<T>();`\n            const asyncArrowFn =\n              this.tsTryParseGenericAsyncArrowFunction(startLoc);\n            if (asyncArrowFn) {\n              return asyncArrowFn;\n            }\n          }\n\n          const typeArguments = this.tsParseTypeArgumentsInExpression();\n          if (!typeArguments) return;\n\n          if (isOptionalCall && !this.match(tt.parenL)) {\n            missingParenErrorLoc = this.state.curPosition();\n            return;\n          }\n\n          if (tokenIsTemplate(this.state.type)) {\n            const result = super.parseTaggedTemplateExpression(\n              base,\n              startLoc,\n              state,\n            );\n            if (process.env.BABEL_8_BREAKING) {\n              result.typeArguments = typeArguments;\n            } else {\n              result.typeParameters = typeArguments;\n            }\n            return result;\n          }\n\n          if (!noCalls && this.eat(tt.parenL)) {\n            const node = this.startNodeAt<\n              N.CallExpression | N.OptionalCallExpression\n            >(startLoc);\n            node.callee = base;\n            // @ts-expect-error (won't be any undefined arguments)\n            node.arguments = this.parseCallExpressionArguments(tt.parenR);\n\n            // Handles invalid case: `f<T>(a:b)`\n            this.tsCheckForInvalidTypeCasts(node.arguments);\n\n            if (process.env.BABEL_8_BREAKING) {\n              node.typeArguments = typeArguments;\n            } else {\n              node.typeParameters = typeArguments;\n            }\n\n            if (state.optionalChainMember) {\n              (node as Undone<N.OptionalCallExpression>).optional =\n                isOptionalCall;\n            }\n\n            return this.finishCallExpression(node, state.optionalChainMember);\n          }\n\n          const tokenType = this.state.type;\n          if (\n            // a<b>>c is not (a<b>)>c, but a<(b>>c)\n            tokenType === tt.gt ||\n            // a<b>>>c is not (a<b>)>>c, but a<(b>>>c)\n            tokenType === tt.bitShiftR ||\n            // a<b>c is (a<b)>c\n            (tokenType !== tt.parenL &&\n              tokenCanStartExpression(tokenType) &&\n              !this.hasPrecedingLineBreak())\n          ) {\n            // Bail out.\n            return;\n          }\n\n          const node = this.startNodeAt<N.TsInstantiationExpression>(startLoc);\n          node.expression = base;\n          if (process.env.BABEL_8_BREAKING) {\n            node.typeArguments = typeArguments;\n          } else {\n            node.typeParameters = typeArguments;\n          }\n          return this.finishNode(node, \"TSInstantiationExpression\");\n        });\n\n        if (missingParenErrorLoc) {\n          this.unexpected(missingParenErrorLoc, tt.parenL);\n        }\n\n        if (result) {\n          if (\n            result.type === \"TSInstantiationExpression\" &&\n            (this.match(tt.dot) ||\n              (this.match(tt.questionDot) &&\n                this.lookaheadCharCode() !== charCodes.leftParenthesis))\n          ) {\n            this.raise(\n              TSErrors.InvalidPropertyAccessAfterInstantiationExpression,\n              this.state.startLoc,\n            );\n          }\n          return result;\n        }\n      }\n\n      return super.parseSubscript(base, startLoc, noCalls, state);\n    }\n\n    parseNewCallee(node: N.NewExpression): void {\n      super.parseNewCallee(node);\n\n      const { callee } = node;\n      if (\n        callee.type === \"TSInstantiationExpression\" &&\n        !callee.extra?.parenthesized\n      ) {\n        if (process.env.BABEL_8_BREAKING) {\n          node.typeArguments = callee.typeArguments;\n        } else {\n          node.typeParameters = callee.typeParameters;\n        }\n        node.callee = callee.expression;\n      }\n    }\n\n    parseExprOp(\n      left: N.Expression,\n      leftStartLoc: Position,\n      minPrec: number,\n    ): N.Expression {\n      let isSatisfies: boolean;\n      if (\n        tokenOperatorPrecedence(tt._in) > minPrec &&\n        !this.hasPrecedingLineBreak() &&\n        (this.isContextual(tt._as) ||\n          (isSatisfies = this.isContextual(tt._satisfies)))\n      ) {\n        const node = this.startNodeAt<\n          N.TsAsExpression | N.TsSatisfiesExpression\n        >(leftStartLoc);\n        node.expression = left;\n        node.typeAnnotation = this.tsInType(() => {\n          this.next(); // \"as\" or \"satisfies\"\n          if (this.match(tt._const)) {\n            if (isSatisfies) {\n              this.raise(Errors.UnexpectedKeyword, this.state.startLoc, {\n                keyword: \"const\",\n              });\n            }\n            return this.tsParseTypeReference();\n          }\n\n          return this.tsParseType();\n        });\n        this.finishNode(\n          node,\n          isSatisfies ? \"TSSatisfiesExpression\" : \"TSAsExpression\",\n        );\n        // rescan `<`, `>` because they were scanned when this.state.inType was true\n        this.reScan_lt_gt();\n        return this.parseExprOp(\n          // @ts-expect-error todo(flow->ts)\n          node,\n          leftStartLoc,\n          minPrec,\n        );\n      }\n\n      return super.parseExprOp(left, leftStartLoc, minPrec);\n    }\n\n    checkReservedWord(\n      word: string,\n      startLoc: Position,\n      checkKeywords: boolean,\n      isBinding: boolean,\n    ): void {\n      // Strict mode words may be allowed as in `declare namespace N { const static: number; }`.\n      // And we have a type checker anyway, so don't bother having the parser do it.\n      if (!this.state.isAmbientContext) {\n        super.checkReservedWord(word, startLoc, checkKeywords, isBinding);\n      }\n    }\n\n    checkImportReflection(node: Undone<N.ImportDeclaration>) {\n      super.checkImportReflection(node);\n      if (node.module && node.importKind !== \"value\") {\n        this.raise(\n          TSErrors.ImportReflectionHasImportType,\n          node.specifiers[0].loc.start,\n        );\n      }\n    }\n\n    /*\n    Don't bother doing this check in TypeScript code because:\n    1. We may have a nested export statement with the same name:\n      export const x = 0;\n      export namespace N {\n        export const x = 1;\n      }\n    2. We have a type checker to warn us about this sort of thing.\n    */\n    checkDuplicateExports() {}\n\n    isPotentialImportPhase(isExport: boolean): boolean {\n      if (super.isPotentialImportPhase(isExport)) return true;\n      if (this.isContextual(tt._type)) {\n        const ch = this.lookaheadCharCode();\n        return isExport\n          ? ch === charCodes.leftCurlyBrace || ch === charCodes.asterisk\n          : ch !== charCodes.equalsTo;\n      }\n      return !isExport && this.isContextual(tt._typeof);\n    }\n\n    applyImportPhase(\n      node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n      isExport: boolean,\n      phase: string | null,\n      loc?: Position,\n    ): void {\n      super.applyImportPhase(node, isExport, phase, loc);\n      if (isExport) {\n        (node as N.ExportNamedDeclaration).exportKind =\n          phase === \"type\" ? \"type\" : \"value\";\n      } else {\n        (node as N.ImportDeclaration).importKind =\n          phase === \"type\" || phase === \"typeof\" ? phase : \"value\";\n      }\n    }\n\n    parseImport(\n      node: Undone<N.ImportDeclaration | N.TsImportEqualsDeclaration>,\n    ): N.AnyImport {\n      if (this.match(tt.string)) {\n        node.importKind = \"value\";\n        return super.parseImport(node as Undone<N.ImportDeclaration>);\n      }\n\n      let importNode;\n      if (\n        tokenIsIdentifier(this.state.type) &&\n        this.lookaheadCharCode() === charCodes.equalsTo\n      ) {\n        node.importKind = \"value\";\n        return this.tsParseImportEqualsDeclaration(\n          node as Undone<N.TsImportEqualsDeclaration>,\n        );\n      } else if (this.isContextual(tt._type)) {\n        const maybeDefaultIdentifier = this.parseMaybeImportPhase(\n          node as Undone<N.ImportDeclaration>,\n          /* isExport */ false,\n        );\n        if (this.lookaheadCharCode() === charCodes.equalsTo) {\n          return this.tsParseImportEqualsDeclaration(\n            node as Undone<N.TsImportEqualsDeclaration>,\n            maybeDefaultIdentifier,\n          );\n        } else {\n          importNode = super.parseImportSpecifiersAndAfter(\n            node as Undone<N.ImportDeclaration>,\n            maybeDefaultIdentifier,\n          );\n        }\n      } else {\n        importNode = super.parseImport(node as Undone<N.ImportDeclaration>);\n      }\n\n      // `import type` can only be used on imports with named imports or with a\n      // default import - but not both\n      if (\n        importNode.importKind === \"type\" &&\n        // @ts-expect-error refine typings\n        importNode.specifiers.length > 1 &&\n        // @ts-expect-error refine typings\n        importNode.specifiers[0].type === \"ImportDefaultSpecifier\"\n      ) {\n        this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, importNode);\n      }\n\n      return importNode;\n    }\n\n    parseExport(\n      node: Undone<\n        | N.ExportDefaultDeclaration\n        | N.ExportAllDeclaration\n        | N.ExportNamedDeclaration\n      >,\n      decorators: N.Decorator[] | null,\n    ): N.AnyExport {\n      if (this.match(tt._import)) {\n        // `export import A = B;`\n        this.next(); // eat `tt._import`\n        const nodeImportEquals = node as Undone<N.TsImportEqualsDeclaration>;\n        let maybeDefaultIdentifier: N.Identifier | null = null;\n        if (\n          this.isContextual(tt._type) &&\n          // We pass false here, because we are parsing an `import ... =`\n          this.isPotentialImportPhase(/* isExport */ false)\n        ) {\n          maybeDefaultIdentifier = this.parseMaybeImportPhase(\n            nodeImportEquals,\n            /* isExport */ false,\n          );\n        } else {\n          nodeImportEquals.importKind = \"value\";\n        }\n        return this.tsParseImportEqualsDeclaration(\n          nodeImportEquals,\n          maybeDefaultIdentifier,\n          /* isExport */ true,\n        );\n      } else if (this.eat(tt.eq)) {\n        // `export = x;`\n        const assign = node as Undone<N.TsExportAssignment>;\n        assign.expression = super.parseExpression();\n        this.semicolon();\n        this.sawUnambiguousESM = true;\n        return this.finishNode(assign, \"TSExportAssignment\");\n      } else if (this.eatContextual(tt._as)) {\n        // `export as namespace A;`\n        const decl = node as Undone<N.TsNamespaceExportDeclaration>;\n        // See `parseNamespaceExportDeclaration` in TypeScript's own parser\n        this.expectContextual(tt._namespace);\n        decl.id = this.parseIdentifier();\n        this.semicolon();\n        return this.finishNode(decl, \"TSNamespaceExportDeclaration\");\n      } else {\n        return super.parseExport(\n          node as Undone<N.ExportAllDeclaration | N.ExportDefaultDeclaration>,\n          decorators,\n        );\n      }\n    }\n\n    isAbstractClass(): boolean {\n      return (\n        this.isContextual(tt._abstract) && this.lookahead().type === tt._class\n      );\n    }\n\n    parseExportDefaultExpression(): N.ExportDefaultDeclaration[\"declaration\"] {\n      if (this.isAbstractClass()) {\n        const cls = this.startNode<N.Class>();\n        this.next(); // Skip \"abstract\"\n        cls.abstract = true;\n        return this.parseClass(cls, true, true);\n      }\n\n      // export default interface allowed in:\n      // https://github.com/Microsoft/TypeScript/pull/16040\n      if (this.match(tt._interface)) {\n        const result = this.tsParseInterfaceDeclaration(\n          this.startNode<N.TsInterfaceDeclaration>(),\n        );\n        if (result) return result;\n      }\n\n      return super.parseExportDefaultExpression();\n    }\n\n    parseVarStatement(\n      node: N.VariableDeclaration,\n      kind: \"var\" | \"let\" | \"const\" | \"using\",\n      allowMissingInitializer: boolean = false,\n    ) {\n      const { isAmbientContext } = this.state;\n      const declaration = super.parseVarStatement(\n        node,\n        kind,\n        allowMissingInitializer || isAmbientContext,\n      );\n\n      if (!isAmbientContext) return declaration;\n\n      for (const { id, init } of declaration.declarations) {\n        // Empty initializer is the easy case that we want.\n        if (!init) continue;\n\n        // var and let aren't ever allowed initializers.\n        if (kind !== \"const\" || !!id.typeAnnotation) {\n          this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);\n        } else if (\n          !isValidAmbientConstInitializer(init, this.hasPlugin(\"estree\"))\n        ) {\n          this.raise(\n            TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference,\n            init,\n          );\n        }\n      }\n\n      return declaration;\n    }\n\n    parseStatementContent(\n      flags: ParseStatementFlag,\n      decorators?: N.Decorator[] | null,\n    ): N.Statement {\n      if (this.match(tt._const) && this.isLookaheadContextual(\"enum\")) {\n        const node = this.startNode<N.TsEnumDeclaration>();\n        this.expect(tt._const); // eat 'const'\n        return this.tsParseEnumDeclaration(node, { const: true });\n      }\n\n      if (this.isContextual(tt._enum)) {\n        return this.tsParseEnumDeclaration(\n          this.startNode<N.TsEnumDeclaration>(),\n        );\n      }\n\n      if (this.isContextual(tt._interface)) {\n        const result = this.tsParseInterfaceDeclaration(this.startNode());\n        if (result) return result;\n      }\n\n      return super.parseStatementContent(flags, decorators);\n    }\n\n    parseAccessModifier(): N.Accessibility | undefined | null {\n      return this.tsParseModifier([\"public\", \"protected\", \"private\"]);\n    }\n\n    tsHasSomeModifiers(member: any, modifiers: readonly TsModifier[]): boolean {\n      return modifiers.some(modifier => {\n        if (tsIsAccessModifier(modifier)) {\n          return member.accessibility === modifier;\n        }\n        return !!member[modifier];\n      });\n    }\n\n    tsIsStartOfStaticBlocks() {\n      return (\n        this.isContextual(tt._static) &&\n        this.lookaheadCharCode() === charCodes.leftCurlyBrace\n      );\n    }\n\n    parseClassMember(\n      classBody: N.ClassBody,\n      member: any,\n      state: N.ParseClassMemberState,\n    ): void {\n      const modifiers = [\n        \"declare\",\n        \"private\",\n        \"public\",\n        \"protected\",\n        \"override\",\n        \"abstract\",\n        \"readonly\",\n        \"static\",\n      ] as const;\n      this.tsParseModifiers(\n        {\n          allowedModifiers: modifiers,\n          disallowedModifiers: [\"in\", \"out\"],\n          stopOnStartOfClassStaticBlock: true,\n          errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions,\n        },\n        member,\n      );\n\n      const callParseClassMemberWithIsStatic = () => {\n        if (this.tsIsStartOfStaticBlocks()) {\n          this.next(); // eat \"static\"\n          this.next(); // eat \"{\"\n          if (this.tsHasSomeModifiers(member, modifiers)) {\n            this.raise(\n              TSErrors.StaticBlockCannotHaveModifier,\n              this.state.curPosition(),\n            );\n          }\n          super.parseClassStaticBlock(classBody, member as N.StaticBlock);\n        } else {\n          this.parseClassMemberWithIsStatic(\n            classBody,\n            member,\n            state,\n            !!member.static,\n          );\n        }\n      };\n      if (member.declare) {\n        this.tsInAmbientContext(callParseClassMemberWithIsStatic);\n      } else {\n        callParseClassMemberWithIsStatic();\n      }\n    }\n\n    parseClassMemberWithIsStatic(\n      classBody: N.ClassBody,\n      member: Undone<N.ClassMember | N.TsIndexSignature>,\n      state: N.ParseClassMemberState,\n      isStatic: boolean,\n    ): void {\n      const idx = this.tsTryParseIndexSignature(\n        member as Undone<N.TsIndexSignature>,\n      );\n      if (idx) {\n        classBody.body.push(idx);\n\n        if ((member as any).abstract) {\n          this.raise(TSErrors.IndexSignatureHasAbstract, member);\n        }\n        if ((member as any).accessibility) {\n          this.raise(TSErrors.IndexSignatureHasAccessibility, member, {\n            modifier: (member as any).accessibility,\n          });\n        }\n        if ((member as any).declare) {\n          this.raise(TSErrors.IndexSignatureHasDeclare, member);\n        }\n        if ((member as any).override) {\n          this.raise(TSErrors.IndexSignatureHasOverride, member);\n        }\n\n        return;\n      }\n\n      if (!this.state.inAbstractClass && (member as any).abstract) {\n        this.raise(TSErrors.NonAbstractClassHasAbstractMethod, member);\n      }\n\n      if ((member as any).override) {\n        if (!state.hadSuperClass) {\n          this.raise(TSErrors.OverrideNotInSubClass, member);\n        }\n      }\n\n      /*:: invariant(member.type !== \"TSIndexSignature\") */\n\n      super.parseClassMemberWithIsStatic(\n        classBody,\n        member as Undone<N.ClassMember>,\n        state,\n        isStatic,\n      );\n    }\n\n    parsePostMemberNameModifiers(\n      methodOrProp: N.ClassMethod | N.ClassProperty | N.ClassPrivateProperty,\n    ): void {\n      const optional = this.eat(tt.question);\n      if (optional) methodOrProp.optional = true;\n\n      if ((methodOrProp as any).readonly && this.match(tt.parenL)) {\n        this.raise(TSErrors.ClassMethodHasReadonly, methodOrProp);\n      }\n\n      if ((methodOrProp as any).declare && this.match(tt.parenL)) {\n        this.raise(TSErrors.ClassMethodHasDeclare, methodOrProp);\n      }\n    }\n\n    // Note: The reason we do this in `parseExpressionStatement` and not `parseStatement`\n    // is that e.g. `type()` is valid JS, so we must try parsing that first.\n    // If it's really a type, we will parse `type` as the statement, and can correct it here\n    // by parsing the rest.\n    // @ts-expect-error plugin overrides interfaces\n    parseExpressionStatement(\n      node: Undone<N.ExpressionStatement>,\n      expr: N.Expression,\n      decorators: N.Decorator[] | null,\n    ): N.Statement {\n      const decl =\n        expr.type === \"Identifier\"\n          ? // @ts-expect-error refine typings\n            this.tsParseExpressionStatement(node, expr, decorators)\n          : undefined;\n      return decl || super.parseExpressionStatement(node, expr, decorators);\n    }\n\n    // export type\n    // Should be true for anything parsed by `tsTryParseExportDeclaration`.\n    shouldParseExportDeclaration(): boolean {\n      if (this.tsIsDeclarationStart()) return true;\n      return super.shouldParseExportDeclaration();\n    }\n\n    // An apparent conditional expression could actually be an optional parameter in an arrow function.\n    parseConditional(\n      expr: N.Expression,\n\n      startLoc: Position,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): N.Expression {\n      // only do the expensive clone if there is a question mark\n      // and if we come from inside parens\n      if (!this.state.maybeInArrowParameters || !this.match(tt.question)) {\n        return super.parseConditional(\n          expr,\n\n          startLoc,\n          refExpressionErrors,\n        );\n      }\n\n      const result = this.tryParse(() =>\n        super.parseConditional(expr, startLoc),\n      );\n\n      if (!result.node) {\n        if (result.error) {\n          /*:: invariant(refExpressionErrors != null) */\n          super.setOptionalParametersError(refExpressionErrors, result.error);\n        }\n\n        return expr;\n      }\n      if (result.error) this.state = result.failState;\n      return result.node;\n    }\n\n    // Note: These \"type casts\" are *not* valid TS expressions.\n    // But we parse them here and change them when completing the arrow function.\n    parseParenItem<T extends N.Expression | N.RestElement | N.SpreadElement>(\n      node: T,\n      startLoc: Position,\n    ): T | N.TsTypeCastExpression {\n      const newNode = super.parseParenItem(node, startLoc);\n      if (this.eat(tt.question)) {\n        (newNode as N.Identifier).optional = true;\n        // Include questionmark in location of node\n        // Don't use this.finishNode() as otherwise we might process comments twice and\n        // include already consumed parens\n        this.resetEndLocation(node);\n      }\n\n      if (this.match(tt.colon)) {\n        const typeCastNode = this.startNodeAt<N.TsTypeCastExpression>(startLoc);\n        typeCastNode.expression = node as N.Expression;\n        typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();\n\n        return this.finishNode(typeCastNode, \"TSTypeCastExpression\");\n      }\n\n      return node;\n    }\n\n    parseExportDeclaration(\n      node: N.ExportNamedDeclaration,\n    ): N.Declaration | undefined | null {\n      if (!this.state.isAmbientContext && this.isContextual(tt._declare)) {\n        return this.tsInAmbientContext(() => this.parseExportDeclaration(node));\n      }\n\n      // Store original location\n      const startLoc = this.state.startLoc;\n\n      const isDeclare = this.eatContextual(tt._declare);\n\n      if (\n        isDeclare &&\n        (this.isContextual(tt._declare) || !this.shouldParseExportDeclaration())\n      ) {\n        throw this.raise(\n          TSErrors.ExpectedAmbientAfterExportDeclare,\n          this.state.startLoc,\n        );\n      }\n\n      const isIdentifier = tokenIsIdentifier(this.state.type);\n      const declaration: N.Declaration | undefined | null =\n        (isIdentifier && this.tsTryParseExportDeclaration()) ||\n        super.parseExportDeclaration(node);\n\n      if (!declaration) return null;\n\n      if (\n        declaration.type === \"TSInterfaceDeclaration\" ||\n        declaration.type === \"TSTypeAliasDeclaration\" ||\n        isDeclare\n      ) {\n        node.exportKind = \"type\";\n      }\n\n      if (isDeclare) {\n        // Reset location to include `declare` in range\n        this.resetStartLocation(declaration, startLoc);\n\n        declaration.declare = true;\n      }\n\n      return declaration;\n    }\n\n    parseClassId(\n      node: N.Class,\n      isStatement: boolean,\n      optionalId?: boolean | null,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      bindingType?: BindingFlag,\n    ): void {\n      if ((!isStatement || optionalId) && this.isContextual(tt._implements)) {\n        return;\n      }\n\n      super.parseClassId(\n        node,\n        isStatement,\n        optionalId,\n        (node as any).declare\n          ? BindingFlag.TYPE_TS_AMBIENT\n          : BindingFlag.TYPE_CLASS,\n      );\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseInOutConstModifiers,\n      );\n      if (typeParameters) node.typeParameters = typeParameters;\n    }\n\n    parseClassPropertyAnnotation(\n      node: N.ClassProperty | N.ClassPrivateProperty | N.ClassAccessorProperty,\n    ): void {\n      if (!node.optional) {\n        if (this.eat(tt.bang)) {\n          node.definite = true;\n        } else if (this.eat(tt.question)) {\n          node.optional = true;\n        }\n      }\n\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) node.typeAnnotation = type;\n    }\n\n    parseClassProperty(node: N.ClassProperty): N.ClassProperty {\n      this.parseClassPropertyAnnotation(node);\n\n      if (\n        this.state.isAmbientContext &&\n        !(node.readonly && !node.typeAnnotation) &&\n        this.match(tt.eq)\n      ) {\n        this.raise(\n          TSErrors.DeclareClassFieldHasInitializer,\n          this.state.startLoc,\n        );\n      }\n      if (node.abstract && this.match(tt.eq)) {\n        const { key } = node;\n        this.raise(\n          TSErrors.AbstractPropertyHasInitializer,\n          this.state.startLoc,\n          {\n            propertyName:\n              key.type === \"Identifier\" && !node.computed\n                ? key.name\n                : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]`,\n          },\n        );\n      }\n\n      return super.parseClassProperty(node);\n    }\n\n    parseClassPrivateProperty(\n      node: N.ClassPrivateProperty,\n    ): N.ClassPrivateProperty {\n      if (node.abstract) {\n        this.raise(TSErrors.PrivateElementHasAbstract, node);\n      }\n\n      if (node.accessibility) {\n        this.raise(TSErrors.PrivateElementHasAccessibility, node, {\n          modifier: node.accessibility,\n        });\n      }\n\n      this.parseClassPropertyAnnotation(node);\n      return super.parseClassPrivateProperty(node);\n    }\n\n    parseClassAccessorProperty(\n      node: N.ClassAccessorProperty,\n    ): N.ClassAccessorProperty {\n      this.parseClassPropertyAnnotation(node);\n      if (node.optional) {\n        this.raise(TSErrors.AccessorCannotBeOptional, node);\n      }\n      return super.parseClassAccessorProperty(node);\n    }\n\n    pushClassMethod(\n      classBody: N.ClassBody,\n      method: N.ClassMethod,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isConstructor: boolean,\n      allowsDirectSuper: boolean,\n    ): void {\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters && isConstructor) {\n        this.raise(TSErrors.ConstructorHasTypeParameters, typeParameters);\n      }\n\n      // @ts-expect-error declare does not exist in ClassMethod\n      const { declare = false, kind } = method;\n\n      if (declare && (kind === \"get\" || kind === \"set\")) {\n        this.raise(TSErrors.DeclareAccessor, method, { kind });\n      }\n      if (typeParameters) method.typeParameters = typeParameters;\n      super.pushClassMethod(\n        classBody,\n        method,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowsDirectSuper,\n      );\n    }\n\n    pushClassPrivateMethod(\n      classBody: N.ClassBody,\n      method: N.ClassPrivateMethod,\n      isGenerator: boolean,\n      isAsync: boolean,\n    ): void {\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters) method.typeParameters = typeParameters;\n      super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);\n    }\n\n    declareClassPrivateMethodInScope(\n      node: N.ClassPrivateMethod | N.TSDeclareMethod,\n      kind: number,\n    ) {\n      if (node.type === \"TSDeclareMethod\") return;\n      // This happens when using the \"estree\" plugin.\n      if (\n        (node as N.Node).type === \"MethodDefinition\" &&\n        !Object.hasOwn(\n          (node as unknown as N.EstreeMethodDefinition).value,\n          \"body\",\n        )\n      ) {\n        return;\n      }\n\n      super.declareClassPrivateMethodInScope(node, kind);\n    }\n\n    parseClassSuper(node: N.Class): void {\n      super.parseClassSuper(node);\n      // handle `extends f<<T>\n      if (node.superClass && (this.match(tt.lt) || this.match(tt.bitShiftL))) {\n        if (process.env.BABEL_8_BREAKING) {\n          node.superTypeArguments = this.tsParseTypeArgumentsInExpression();\n        } else {\n          node.superTypeParameters = this.tsParseTypeArgumentsInExpression();\n        }\n      }\n      if (this.eatContextual(tt._implements)) {\n        node.implements = this.tsParseHeritageClause(\"implements\");\n      }\n    }\n\n    parseObjPropValue<T extends N.ObjectMember>(\n      prop: Undone<T>,\n      startLoc: Position | undefined | null,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isPattern: boolean,\n      isAccessor: boolean,\n      refExpressionErrors?: ExpressionErrors | null,\n    ): T {\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters) prop.typeParameters = typeParameters;\n\n      return super.parseObjPropValue(\n        prop,\n\n        startLoc,\n        isGenerator,\n        isAsync,\n        isPattern,\n        isAccessor,\n        refExpressionErrors,\n      );\n    }\n\n    parseFunctionParams(node: N.Function, isConstructor: boolean): void {\n      const typeParameters = this.tsTryParseTypeParameters(\n        this.tsParseConstModifier,\n      );\n      if (typeParameters) node.typeParameters = typeParameters;\n      super.parseFunctionParams(node, isConstructor);\n    }\n\n    // `let x: number;`\n    parseVarId(\n      decl: N.VariableDeclarator,\n      kind: \"var\" | \"let\" | \"const\" | \"using\",\n    ): void {\n      super.parseVarId(decl, kind);\n      if (\n        decl.id.type === \"Identifier\" &&\n        !this.hasPrecedingLineBreak() &&\n        this.eat(tt.bang)\n      ) {\n        decl.definite = true;\n      }\n\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) {\n        decl.id.typeAnnotation = type;\n        this.resetEndLocation(decl.id); // set end position to end of type\n      }\n    }\n\n    // parse the return type of an async arrow function - let foo = (async (): number => {});\n    parseAsyncArrowFromCallExpression(\n      node: N.ArrowFunctionExpression,\n      call: N.CallExpression,\n    ): N.ArrowFunctionExpression {\n      if (this.match(tt.colon)) {\n        node.returnType = this.tsParseTypeAnnotation();\n      }\n      return super.parseAsyncArrowFromCallExpression(node, call);\n    }\n\n    parseMaybeAssign(\n      refExpressionErrors?: ExpressionErrors | null,\n      afterLeftParse?: Function,\n    ): N.Expression {\n      // Note: When the JSX plugin is on, type assertions (`<T> x`) aren't valid syntax.\n\n      let state: State | undefined | null;\n      let jsx;\n      let typeCast;\n\n      if (\n        this.hasPlugin(\"jsx\") &&\n        (this.match(tt.jsxTagStart) || this.match(tt.lt))\n      ) {\n        // Prefer to parse JSX if possible. But may be an arrow fn.\n        state = this.state.clone();\n\n        jsx = this.tryParse(\n          () => super.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n          state,\n        );\n\n        /*:: invariant(!jsx.aborted) */\n        /*:: invariant(jsx.node != null) */\n        if (!jsx.error) return jsx.node;\n\n        // Remove `tc.j_expr` or `tc.j_oTag` from context added\n        // by parsing `jsxTagStart` to stop the JSX plugin from\n        // messing with the tokens\n        const { context } = this.state;\n        const currentContext = context[context.length - 1];\n        if (currentContext === tc.j_oTag || currentContext === tc.j_expr) {\n          context.pop();\n        }\n      }\n\n      if (!jsx?.error && !this.match(tt.lt)) {\n        return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n      }\n\n      // Either way, we're looking at a '<': tt.jsxTagStart or relational.\n\n      // If the state was cloned in the JSX parsing branch above but there\n      // have been any error in the tryParse call, this.state is set to state\n      // so we still need to clone it.\n      if (!state || state === this.state) state = this.state.clone();\n\n      let typeParameters: N.TsTypeParameterDeclaration | undefined | null;\n      // We need to explicitly annotate 'abort' for microsoft/TypeScript#58170\n      const arrow = this.tryParse((abort: () => never) => {\n        // This is similar to TypeScript's `tryParseParenthesizedArrowFunctionExpression`.\n        typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);\n        const expr = super.parseMaybeAssign(\n          refExpressionErrors,\n          afterLeftParse,\n        );\n\n        if (\n          expr.type !== \"ArrowFunctionExpression\" ||\n          expr.extra?.parenthesized\n        ) {\n          abort();\n        }\n\n        // Correct TypeScript code should have at least 1 type parameter, but don't crash on bad code.\n        if (typeParameters?.params.length !== 0) {\n          this.resetStartLocationFromNode(expr, typeParameters);\n        }\n        expr.typeParameters = typeParameters;\n\n        if (process.env.BABEL_8_BREAKING) {\n          if (\n            this.hasPlugin(\"jsx\") &&\n            expr.typeParameters.params.length === 1 &&\n            !expr.typeParameters.extra?.trailingComma\n          ) {\n            // report error if single type parameter used without trailing comma.\n            const parameter = expr.typeParameters\n              .params[0] as N.TsTypeParameter;\n            if (!parameter.constraint) {\n              // A single type parameter must either have constraints\n              // or a trailing comma, otherwise it's ambiguous with JSX.\n              this.raise(\n                TSErrors.SingleTypeParameterWithoutTrailingComma,\n                createPositionWithColumnOffset(parameter.loc.end, 1),\n                {\n                  typeParameterName: process.env.BABEL_8_BREAKING\n                    ? (parameter.name as N.Identifier).name\n                    : (parameter.name as string),\n                },\n              );\n            }\n          }\n        }\n\n        return expr;\n      }, state);\n\n      /*:: invariant(arrow.node != null) */\n      if (!arrow.error && !arrow.aborted) {\n        // This error is reported outside of the this.tryParse call so that\n        // in case of <T>(x) => 2, we don't consider <T>(x) as a type assertion\n        // because of this error.\n        if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);\n        return arrow.node;\n      }\n\n      if (!jsx) {\n        // Try parsing a type cast instead of an arrow function.\n        // This will never happen outside of JSX.\n        // (Because in JSX the '<' should be a jsxTagStart and not a relational.\n        assert(!this.hasPlugin(\"jsx\"));\n\n        // This will start with a type assertion (via parseMaybeUnary).\n        // But don't directly call `this.tsParseTypeAssertion` because we want to handle any binary after it.\n        typeCast = this.tryParse(\n          () => super.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n          state,\n        );\n        /*:: invariant(!typeCast.aborted) */\n        /*:: invariant(typeCast.node != null) */\n        if (!typeCast.error) return typeCast.node;\n      }\n\n      if (jsx?.node) {\n        /*:: invariant(jsx.failState) */\n        this.state = jsx.failState;\n        return jsx.node;\n      }\n\n      if (arrow.node) {\n        /*:: invariant(arrow.failState) */\n        this.state = arrow.failState;\n        if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);\n        return arrow.node;\n      }\n\n      if (typeCast?.node) {\n        /*:: invariant(typeCast.failState) */\n        this.state = typeCast.failState;\n        return typeCast.node;\n      }\n\n      throw jsx?.error || arrow.error || typeCast?.error;\n    }\n\n    reportReservedArrowTypeParam(node: any) {\n      if (\n        node.params.length === 1 &&\n        !node.params[0].constraint &&\n        !node.extra?.trailingComma &&\n        this.getPluginOption(\"typescript\", \"disallowAmbiguousJSXLike\")\n      ) {\n        this.raise(TSErrors.ReservedArrowTypeParam, node);\n      }\n    }\n\n    // Handle type assertions\n    parseMaybeUnary(\n      refExpressionErrors?: ExpressionErrors | null,\n      sawUnary?: boolean,\n    ): N.Expression {\n      if (!this.hasPlugin(\"jsx\") && this.match(tt.lt)) {\n        return this.tsParseTypeAssertion();\n      }\n      return super.parseMaybeUnary(refExpressionErrors, sawUnary);\n    }\n\n    parseArrow(\n      node: Undone<N.ArrowFunctionExpression>,\n    ): Undone<N.ArrowFunctionExpression> | undefined | null {\n      if (this.match(tt.colon)) {\n        // This is different from how the TS parser does it.\n        // TS uses lookahead. The Babel Parser parses it as a parenthesized expression and converts.\n\n        const result = this.tryParse(abort => {\n          const returnType = this.tsParseTypeOrTypePredicateAnnotation(\n            tt.colon,\n          );\n          if (this.canInsertSemicolon() || !this.match(tt.arrow)) abort();\n          return returnType;\n        });\n\n        if (result.aborted) return;\n\n        if (!result.thrown) {\n          if (result.error) this.state = result.failState;\n          // @ts-expect-error refine typings\n          node.returnType = result.node;\n        }\n      }\n\n      return super.parseArrow(node);\n    }\n\n    // Allow type annotations inside of a parameter list.\n    parseFunctionParamType(param: N.Pattern) {\n      if (this.eat(tt.question)) {\n        (param as any as N.Identifier).optional = true;\n      }\n      const type = this.tsTryParseTypeAnnotation();\n      if (type) param.typeAnnotation = type;\n      this.resetEndLocation(param);\n\n      return param;\n    }\n\n    isAssignable(node: N.Node, isBinding?: boolean): boolean {\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\n    toAssignable(node: N.Node, isLHS: boolean = false): void {\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(\n              TSErrors.UnexpectedTypeCastInParameter,\n              node,\n            );\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) as N.Assignable;\n          }\n        /* fall through */\n        default:\n          super.toAssignable(node, isLHS);\n      }\n    }\n\n    toAssignableParenthesizedExpression(\n      node: N.ParenthesizedExpression,\n      isLHS: boolean,\n    ): void {\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\n    checkToRestConversion(node: N.Node, allowPattern: boolean): void {\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\n    isValidLVal(\n      type:\n        | \"TSTypeCastExpression\"\n        | \"TSParameterProperty\"\n        | \"TSNonNullExpression\"\n        | \"TSInstantiationExpression\"\n        | \"TSAsExpression\"\n        | \"TSSatisfiesExpression\"\n        | \"TSTypeAssertion\",\n      isUnparenthesizedInAssign: boolean,\n      binding: BindingFlag,\n    ) {\n      switch (type) {\n        // Allow \"typecasts\" to appear on the left of assignment expressions,\n        // because it may be in an arrow function.\n        // e.g. `const f = (foo: number = 0) => foo;`\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 (\n            (binding !== BindingFlag.TYPE_NONE || !isUnparenthesizedInAssign) &&\n            ([\"expression\", true] as [string, boolean])\n          );\n        default:\n          return super.isValidLVal(type, isUnparenthesizedInAssign, binding);\n      }\n    }\n\n    parseBindingAtom(): N.Pattern {\n      if (this.state.type === tt._this) {\n        return this.parseIdentifier(/* liberal */ true);\n      }\n      return super.parseBindingAtom();\n    }\n\n    parseMaybeDecoratorArguments(\n      expr: N.Expression,\n      startLoc: Position,\n    ): N.Expression {\n      // handles `@f<<T>`\n      if (this.match(tt.lt) || this.match(tt.bitShiftL)) {\n        const typeArguments = this.tsParseTypeArgumentsInExpression();\n\n        if (this.match(tt.parenL)) {\n          const call = super.parseMaybeDecoratorArguments(\n            expr,\n            startLoc,\n          ) as N.CallExpression;\n          if (process.env.BABEL_8_BREAKING) {\n            call.typeArguments = typeArguments;\n          } else {\n            call.typeParameters = typeArguments;\n          }\n\n          return call;\n        }\n\n        this.unexpected(null, tt.parenL);\n      }\n\n      return super.parseMaybeDecoratorArguments(expr, startLoc);\n    }\n\n    checkCommaAfterRest(\n      close: (typeof charCodes)[keyof typeof charCodes],\n    ): boolean {\n      if (\n        this.state.isAmbientContext &&\n        this.match(tt.comma) &&\n        this.lookaheadCharCode() === close\n      ) {\n        this.next();\n        return false;\n      }\n      return super.checkCommaAfterRest(close);\n    }\n\n    // === === === === === === === === === === === === === === === ===\n    // Note: All below methods are duplicates of something in flow.js.\n    // Not sure what the best way to combine these is.\n    // === === === === === === === === === === === === === === === ===\n\n    isClassMethod(): boolean {\n      return this.match(tt.lt) || super.isClassMethod();\n    }\n\n    isClassProperty(): boolean {\n      return (\n        this.match(tt.bang) || this.match(tt.colon) || super.isClassProperty()\n      );\n    }\n\n    parseMaybeDefault(\n      startLoc?: Position | null,\n      left?: Pattern | null,\n    ): N.Pattern {\n      const node = super.parseMaybeDefault(startLoc, left);\n\n      if (\n        node.type === \"AssignmentPattern\" &&\n        node.typeAnnotation &&\n        node.right.start < node.typeAnnotation.start\n      ) {\n        this.raise(TSErrors.TypeAnnotationAfterAssign, node.typeAnnotation);\n      }\n\n      return node;\n    }\n\n    // ensure that inside types, we bypass the jsx parser plugin\n    getTokenFromCode(code: number): void {\n      if (this.state.inType) {\n        if (code === charCodes.greaterThan) {\n          this.finishOp(tt.gt, 1);\n          return;\n        }\n        if (code === charCodes.lessThan) {\n          this.finishOp(tt.lt, 1);\n          return;\n        }\n      }\n      super.getTokenFromCode(code);\n    }\n\n    // used after we have finished parsing types\n    reScan_lt_gt() {\n      const { type } = this.state;\n      if (type === tt.lt) {\n        this.state.pos -= 1;\n        this.readToken_lt();\n      } else if (type === tt.gt) {\n        this.state.pos -= 1;\n        this.readToken_gt();\n      }\n    }\n\n    reScan_lt() {\n      const { type } = this.state;\n      if (type === tt.bitShiftL) {\n        this.state.pos -= 2;\n        this.finishOp(tt.lt, 1);\n        return tt.lt;\n      }\n      return type;\n    }\n\n    toAssignableList(\n      exprList: Expression[],\n      trailingCommaLoc: Position | undefined | null,\n      isLHS: boolean,\n    ): void {\n      for (let i = 0; i < exprList.length; i++) {\n        const expr = exprList[i];\n        if (expr?.type === \"TSTypeCastExpression\") {\n          exprList[i] = this.typeCastToParameter(expr);\n        }\n      }\n      super.toAssignableList(exprList, trailingCommaLoc, isLHS);\n    }\n\n    typeCastToParameter(node: N.TsTypeCastExpression): N.Expression {\n      (node.expression as N.Identifier).typeAnnotation = node.typeAnnotation;\n\n      this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);\n\n      return node.expression;\n    }\n\n    shouldParseArrow(params: Array<N.Node>) {\n      if (this.match(tt.colon)) {\n        return params.every(expr => this.isAssignable(expr, true));\n      }\n      return super.shouldParseArrow(params);\n    }\n\n    shouldParseAsyncArrow(): boolean {\n      return this.match(tt.colon) || super.shouldParseAsyncArrow();\n    }\n\n    canHaveLeadingDecorator() {\n      // Avoid unnecessary lookahead in checking for abstract class unless needed!\n      return super.canHaveLeadingDecorator() || this.isAbstractClass();\n    }\n\n    jsxParseOpeningElementAfterName(\n      node: N.JSXOpeningElement,\n    ): N.JSXOpeningElement {\n      // handles `<Component<<T>`\n      if (this.match(tt.lt) || this.match(tt.bitShiftL)) {\n        const typeArguments = this.tsTryParseAndCatch(() =>\n          this.tsParseTypeArgumentsInExpression(),\n        );\n        if (typeArguments) {\n          if (process.env.BABEL_8_BREAKING) {\n            node.typeArguments = typeArguments;\n          } else {\n            node.typeParameters = typeArguments;\n          }\n        }\n      }\n      return super.jsxParseOpeningElementAfterName(node);\n    }\n\n    getGetterSetterExpectedParamCount(\n      method: N.ObjectMethod | N.ClassMethod,\n    ): number {\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\n      return hasContextParam ? baseCount + 1 : baseCount;\n    }\n\n    parseCatchClauseParam(): N.Pattern {\n      const param = super.parseCatchClauseParam();\n      const type = this.tsTryParseTypeAnnotation();\n\n      if (type) {\n        param.typeAnnotation = type;\n        this.resetEndLocation(param);\n      }\n\n      return param;\n    }\n\n    tsInAmbientContext<T>(cb: () => T): T {\n      const { isAmbientContext: oldIsAmbientContext, 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\n    parseClass<T extends N.Class>(\n      node: Undone<T>,\n      isStatement: boolean,\n      optionalId?: boolean,\n    ): T {\n      const oldInAbstractClass = this.state.inAbstractClass;\n      this.state.inAbstractClass = !!(node as any).abstract;\n      try {\n        return super.parseClass(node, isStatement, optionalId);\n      } finally {\n        this.state.inAbstractClass = oldInAbstractClass;\n      }\n    }\n\n    tsParseAbstractDeclaration(\n      node: any,\n      decorators: N.Decorator[] | null,\n    ): N.ClassDeclaration | N.TsInterfaceDeclaration | undefined | null {\n      if (this.match(tt._class)) {\n        node.abstract = true;\n        return this.maybeTakeDecorators(\n          decorators,\n          this.parseClass<N.ClassDeclaration>(\n            node as N.ClassDeclaration,\n            /* isStatement */ true,\n            /* optionalId */ false,\n          ),\n        );\n      } else if (this.isContextual(tt._interface)) {\n        // for invalid abstract interface\n\n        // To avoid\n        //   abstract interface\n        //   Foo {}\n        if (!this.hasFollowingLineBreak()) {\n          node.abstract = true;\n          this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, node);\n          return this.tsParseInterfaceDeclaration(\n            node as N.TsInterfaceDeclaration,\n          );\n        }\n      } else {\n        this.unexpected(null, tt._class);\n      }\n    }\n\n    parseMethod<\n      T extends N.ObjectMethod | N.ClassMethod | N.ClassPrivateMethod,\n    >(\n      node: Undone<T>,\n      isGenerator: boolean,\n      isAsync: boolean,\n      isConstructor: boolean,\n      allowDirectSuper: boolean,\n      type: T[\"type\"],\n      inClassScope?: boolean,\n    ) {\n      const method = super.parseMethod<T>(\n        node,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowDirectSuper,\n        type,\n        inClassScope,\n      );\n      // @ts-expect-error todo(flow->ts) property not defined for all types in union\n      if (method.abstract) {\n        const hasEstreePlugin = this.hasPlugin(\"estree\");\n        const methodFn = hasEstreePlugin\n          ? // @ts-expect-error estree typings\n            method.value\n          : method;\n        if (methodFn.body) {\n          const { key } = method;\n          this.raise(TSErrors.AbstractMethodHasImplementation, method, {\n            methodName:\n              key.type === \"Identifier\" && !method.computed\n                ? key.name\n                : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]`,\n          });\n        }\n      }\n      return method;\n    }\n\n    tsParseTypeParameterName(): N.Identifier | string {\n      const typeName: N.Identifier = this.parseIdentifier();\n      return process.env.BABEL_8_BREAKING ? typeName : typeName.name;\n    }\n\n    shouldParseAsAmbientContext(): boolean {\n      return !!this.getPluginOption(\"typescript\", \"dts\");\n    }\n\n    parse() {\n      if (this.shouldParseAsAmbientContext()) {\n        this.state.isAmbientContext = true;\n      }\n      return super.parse();\n    }\n\n    getExpression() {\n      if (this.shouldParseAsAmbientContext()) {\n        this.state.isAmbientContext = true;\n      }\n      return super.getExpression();\n    }\n\n    parseExportSpecifier(\n      node: Undone<N.ExportSpecifier>,\n      isString: boolean,\n      isInTypeExport: boolean,\n      isMaybeTypeOnly: boolean,\n    ) {\n      if (!isString && isMaybeTypeOnly) {\n        this.parseTypeOnlyImportExportSpecifier(\n          node,\n          /* isImport */ false,\n          isInTypeExport,\n        );\n        return this.finishNode<N.ExportSpecifier>(node, \"ExportSpecifier\");\n      }\n      node.exportKind = \"value\";\n      return super.parseExportSpecifier(\n        node,\n        isString,\n        isInTypeExport,\n        isMaybeTypeOnly,\n      );\n    }\n\n    parseImportSpecifier(\n      specifier: Undone<N.ImportSpecifier>,\n      importedIsString: boolean,\n      isInTypeOnlyImport: boolean,\n      isMaybeTypeOnly: boolean,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      bindingType: BindingFlag | undefined,\n    ): N.ImportSpecifier {\n      if (!importedIsString && isMaybeTypeOnly) {\n        this.parseTypeOnlyImportExportSpecifier(\n          specifier,\n          /* isImport */ true,\n          isInTypeOnlyImport,\n        );\n        return this.finishNode<N.ImportSpecifier>(specifier, \"ImportSpecifier\");\n      }\n      specifier.importKind = \"value\";\n      return super.parseImportSpecifier(\n        specifier,\n        importedIsString,\n        isInTypeOnlyImport,\n        isMaybeTypeOnly,\n        isInTypeOnlyImport\n          ? BindingFlag.TYPE_TS_TYPE_IMPORT\n          : BindingFlag.TYPE_TS_VALUE_IMPORT,\n      );\n    }\n\n    parseTypeOnlyImportExportSpecifier(\n      node: any,\n      isImport: boolean,\n      isInTypeOnlyImportExport: boolean,\n    ): void {\n      const leftOfAsKey = isImport ? \"imported\" : \"local\";\n      const rightOfAsKey = isImport ? \"local\" : \"exported\";\n\n      let leftOfAs = node[leftOfAsKey];\n      let rightOfAs;\n\n      let hasTypeSpecifier = false;\n      let canParseAsKeyword = true;\n\n      const loc = leftOfAs.loc.start;\n\n      // https://github.com/microsoft/TypeScript/blob/fc4f9d83d5939047aa6bb2a43965c6e9bbfbc35b/src/compiler/parser.ts#L7411-L7456\n      // import { type } from \"mod\";          - hasTypeSpecifier: false, leftOfAs: type\n      // import { type as } from \"mod\";       - hasTypeSpecifier: true,  leftOfAs: as\n      // import { type as as } from \"mod\";    - hasTypeSpecifier: false, leftOfAs: type, rightOfAs: as\n      // import { type as as as } from \"mod\"; - hasTypeSpecifier: true,  leftOfAs: as,   rightOfAs: as\n      if (this.isContextual(tt._as)) {\n        // { type as ...? }\n        const firstAs = this.parseIdentifier();\n        if (this.isContextual(tt._as)) {\n          // { type as as ...? }\n          const secondAs = this.parseIdentifier();\n          if (tokenIsKeywordOrIdentifier(this.state.type)) {\n            // { type as as something }\n            hasTypeSpecifier = true;\n            leftOfAs = firstAs;\n            rightOfAs = isImport\n              ? this.parseIdentifier()\n              : this.parseModuleExportName();\n            canParseAsKeyword = false;\n          } else {\n            // { type as as }\n            rightOfAs = secondAs;\n            canParseAsKeyword = false;\n          }\n        } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n          // { type as something }\n          canParseAsKeyword = false;\n          rightOfAs = isImport\n            ? this.parseIdentifier()\n            : this.parseModuleExportName();\n        } else {\n          // { type as }\n          hasTypeSpecifier = true;\n          leftOfAs = firstAs;\n        }\n      } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n        // { type something ...? }\n        hasTypeSpecifier = true;\n        if (isImport) {\n          leftOfAs = this.parseIdentifier(true);\n          if (!this.isContextual(tt._as)) {\n            this.checkReservedWord(\n              leftOfAs.name,\n              leftOfAs.loc.start,\n              true,\n              true,\n            );\n          }\n        } else {\n          leftOfAs = this.parseModuleExportName();\n        }\n      }\n      if (hasTypeSpecifier && isInTypeOnlyImportExport) {\n        this.raise(\n          isImport\n            ? TSErrors.TypeModifierIsUsedInTypeImports\n            : TSErrors.TypeModifierIsUsedInTypeExports,\n          loc,\n        );\n      }\n\n      node[leftOfAsKey] = leftOfAs;\n      node[rightOfAsKey] = rightOfAs;\n\n      const kindKey = isImport ? \"importKind\" : \"exportKind\";\n      node[kindKey] = hasTypeSpecifier ? \"type\" : \"value\";\n\n      if (canParseAsKeyword && this.eatContextual(tt._as)) {\n        node[rightOfAsKey] = isImport\n          ? this.parseIdentifier()\n          : this.parseModuleExportName();\n      }\n      if (!node[rightOfAsKey]) {\n        node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]);\n      }\n      if (isImport) {\n        this.checkIdentifier(\n          node[rightOfAsKey],\n          hasTypeSpecifier\n            ? BindingFlag.TYPE_TS_TYPE_IMPORT\n            : BindingFlag.TYPE_TS_VALUE_IMPORT,\n        );\n      }\n    }\n  };\n\nfunction isPossiblyLiteralEnum(expression: N.Expression): boolean {\n  if (expression.type !== \"MemberExpression\") return false;\n\n  const { computed, property } = expression;\n\n  if (\n    computed &&\n    property.type !== \"StringLiteral\" &&\n    (property.type !== \"TemplateLiteral\" || property.expressions.length > 0)\n  ) {\n    return false;\n  }\n\n  return isUncomputedMemberExpressionChain(expression.object);\n}\n\n// If a const declaration has no type annotation and is initialized to\n// a string literal, numeric literal, or enum reference, then it is\n// allowed. In an ideal world, we'd check whether init was *actually* an\n// enum reference, but we allow anything that \"could be\" a literal enum\n// in `isPossiblyLiteralEnum` since we don't have all the information\n// that the typescript compiler has.\nfunction isValidAmbientConstInitializer(\n  expression: N.Expression,\n  estree: boolean,\n): boolean {\n  const { type } = expression;\n  if (expression.extra?.parenthesized) {\n    return false;\n  }\n  if (estree) {\n    if (type === \"Literal\") {\n      const { value } = 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}\n\nfunction isNumber(expression: N.Expression, estree: boolean): boolean {\n  if (estree) {\n    return (\n      expression.type === \"Literal\" &&\n      (typeof expression.value === \"number\" || \"bigint\" in expression)\n    );\n  }\n  return (\n    expression.type === \"NumericLiteral\" || expression.type === \"BigIntLiteral\"\n  );\n}\n\nfunction isNegativeNumber(expression: N.Expression, estree: boolean): boolean {\n  if (expression.type === \"UnaryExpression\") {\n    const { operator, argument } = expression;\n    if (operator === \"-\" && isNumber(argument, estree)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction isUncomputedMemberExpressionChain(expression: N.Expression): boolean {\n  if (expression.type === \"Identifier\") return true;\n  if (expression.type !== \"MemberExpression\" || expression.computed) {\n    return false;\n  }\n\n  return isUncomputedMemberExpressionChain(expression.object);\n}\n","import * as charCodes from \"charcodes\";\n\nimport { tokenLabelName, tt } from \"../tokenizer/types.ts\";\nimport type Parser from \"../parser/index.ts\";\nimport type * as N from \"../types.ts\";\nimport { ParseErrorEnum } from \"../parse-error.ts\";\nimport type { Undone } from \"../parser/node.ts\";\nimport type { ExpressionErrors } from \"../parser/util.ts\";\nimport type { BindingFlag } from \"../util/scopeflags.ts\";\nimport type { Position } from \"../util/location.ts\";\n\ntype PossiblePlaceholders = {\n  Identifier: N.Identifier;\n  StringLiteral: N.StringLiteral;\n  Expression: N.Expression;\n  Statement: N.Statement;\n  Declaration: N.Declaration;\n  BlockStatement: N.BlockStatement;\n  ClassBody: N.ClassBody;\n  Pattern: N.Pattern;\n};\nexport type PlaceholderTypes = keyof PossiblePlaceholders;\n\ntype NodeOf<T extends keyof PossiblePlaceholders> = PossiblePlaceholders[T];\n// todo: when there  is proper union type for Node\n// type NodeOf<T extends PlaceholderTypes> = Extract<N.Node, { type: T }>;\n\n// todo: Placeholder<T> breaks everything, because its type is incompatible with\n// the substituted nodes.\ntype MaybePlaceholder<T extends PlaceholderTypes> = NodeOf<T>; // | Placeholder<T>\n\n/* eslint sort-keys: \"error\" */\nconst PlaceholderErrors = ParseErrorEnum`placeholders`({\n  ClassNameIsRequired: \"A class name is required.\",\n  UnexpectedSpace: \"Unexpected space in placeholder.\",\n});\n\nexport default (superClass: typeof Parser) =>\n  class PlaceholdersParserMixin extends superClass implements Parser {\n    parsePlaceholder<T extends PlaceholderTypes>(\n      expectedNode: T,\n    ): /*?N.Placeholder<T>*/ MaybePlaceholder<T> | undefined {\n      if (this.match(tt.placeholder)) {\n        const node = this.startNode<N.Placeholder<T>>();\n        this.next();\n        this.assertNoSpace();\n\n        // We can't use this.parseIdentifier because\n        // we don't want nested placeholders.\n        node.name = super.parseIdentifier(/* liberal */ true);\n\n        this.assertNoSpace();\n        this.expect(tt.placeholder);\n        return this.finishPlaceholder(node, expectedNode);\n      }\n    }\n\n    finishPlaceholder<T extends PlaceholderTypes>(\n      node: Undone<N.Placeholder> | Undone<NodeOf<PlaceholderTypes>>,\n      expectedNode: T,\n    ): /*N.Placeholder<T>*/ MaybePlaceholder<T> {\n      let placeholder = node as unknown as N.Placeholder<T>;\n\n      if (!placeholder.expectedNode || !placeholder.type) {\n        placeholder = this.finishNode(\n          placeholder,\n          \"Placeholder\",\n        ) as unknown as N.Placeholder<T>;\n      }\n\n      placeholder.expectedNode = expectedNode;\n      return placeholder as unknown as MaybePlaceholder<T>;\n    }\n\n    /* ============================================================ *\n     * tokenizer/index.js                                           *\n     * ============================================================ */\n\n    getTokenFromCode(code: number) {\n      if (\n        code === charCodes.percentSign &&\n        this.input.charCodeAt(this.state.pos + 1) === charCodes.percentSign\n      ) {\n        this.finishOp(tt.placeholder, 2);\n      } else {\n        super.getTokenFromCode(code);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/expression.js                                         *\n     * ============================================================ */\n\n    parseExprAtom(\n      refExpressionErrors?: ExpressionErrors | null,\n    ): MaybePlaceholder<\"Expression\"> {\n      return (\n        this.parsePlaceholder(\"Expression\") ||\n        super.parseExprAtom(refExpressionErrors)\n      );\n    }\n\n    parseIdentifier(liberal?: boolean): MaybePlaceholder<\"Identifier\"> {\n      // NOTE: This function only handles identifiers outside of\n      // expressions and binding patterns, since they are already\n      // handled by the parseExprAtom and parseBindingAtom functions.\n      // This is needed, for example, to parse \"class %%NAME%% {}\".\n      return (\n        this.parsePlaceholder(\"Identifier\") || super.parseIdentifier(liberal)\n      );\n    }\n\n    checkReservedWord(\n      word: string,\n      startLoc: Position,\n      checkKeywords: boolean,\n      isBinding: boolean,\n    ) {\n      // Sometimes we call #checkReservedWord(node.name), expecting\n      // that node is an Identifier. If it is a Placeholder, name\n      // will be undefined.\n      if (word !== undefined) {\n        super.checkReservedWord(word, startLoc, checkKeywords, isBinding);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/lval.js                                               *\n     * ============================================================ */\n\n    parseBindingAtom(): MaybePlaceholder<\"Pattern\"> {\n      return this.parsePlaceholder(\"Pattern\") || super.parseBindingAtom();\n    }\n\n    isValidLVal(type: string, isParenthesized: boolean, binding: BindingFlag) {\n      return (\n        type === \"Placeholder\" ||\n        super.isValidLVal(type, isParenthesized, binding)\n      );\n    }\n\n    toAssignable(node: N.Node, isLHS: boolean): void {\n      if (\n        node &&\n        node.type === \"Placeholder\" &&\n        node.expectedNode === \"Expression\"\n      ) {\n        node.expectedNode = \"Pattern\";\n      } else {\n        super.toAssignable(node, isLHS);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/statement.js                                          *\n     * ============================================================ */\n\n    chStartsBindingIdentifier(ch: number, pos: number): boolean {\n      if (super.chStartsBindingIdentifier(ch, pos)) {\n        return true;\n      }\n\n      // Accept \"let %%\" as the start of \"let %%placeholder%%\", as though the\n      // placeholder were an identifier.\n      const nextToken = this.lookahead();\n      if (nextToken.type === tt.placeholder) {\n        return true;\n      }\n\n      return false;\n    }\n\n    verifyBreakContinue(\n      node: N.BreakStatement | N.ContinueStatement,\n      isBreak: boolean,\n    ) {\n      // @ts-expect-error: node.label could be Placeholder\n      if (node.label && node.label.type === \"Placeholder\") return;\n      super.verifyBreakContinue(node, isBreak);\n    }\n\n    // @ts-expect-error Plugin will override parser interface\n    parseExpressionStatement(\n      node: MaybePlaceholder<\"Statement\">,\n      expr: MaybePlaceholder<\"Expression\">,\n    ): MaybePlaceholder<\"Statement\"> {\n      // @ts-expect-error placeholder typings\n      if (expr.type !== \"Placeholder\" || expr.extra?.parenthesized) {\n        // @ts-expect-error placeholder typings\n        return super.parseExpressionStatement(node, expr);\n      }\n\n      if (this.match(tt.colon)) {\n        // @ts-expect-error placeholder typings\n        const stmt: N.LabeledStatement = node;\n        stmt.label = this.finishPlaceholder(expr, \"Identifier\");\n        this.next();\n        stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();\n        return this.finishNode(stmt, \"LabeledStatement\");\n      }\n\n      this.semicolon();\n      const stmtPlaceholder = node as unknown as N.Placeholder<\"Statement\">;\n      stmtPlaceholder.name = (expr as N.Placeholder).name;\n      return this.finishPlaceholder(stmtPlaceholder, \"Statement\");\n    }\n\n    parseBlock(\n      allowDirectives?: boolean,\n      createNewLexicalScope?: boolean,\n      afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n    ): MaybePlaceholder<\"BlockStatement\"> {\n      return (\n        this.parsePlaceholder(\"BlockStatement\") ||\n        super.parseBlock(\n          allowDirectives,\n          createNewLexicalScope,\n          afterBlockParse,\n        )\n      );\n    }\n\n    parseFunctionId(\n      requireId?: boolean,\n    ): MaybePlaceholder<\"Identifier\"> | undefined | null {\n      return (\n        this.parsePlaceholder(\"Identifier\") || super.parseFunctionId(requireId)\n      );\n    }\n    // @ts-expect-error Plugin will override parser interface\n    parseClass<T extends N.Class>(\n      node: T,\n      isStatement: /* T === ClassDeclaration */ boolean,\n      optionalId?: boolean,\n    ): T {\n      const type = isStatement ? \"ClassDeclaration\" : \"ClassExpression\";\n\n      this.next();\n      const oldStrict = this.state.strict;\n\n      const placeholder = this.parsePlaceholder(\"Identifier\");\n      if (placeholder) {\n        if (\n          this.match(tt._extends) ||\n          this.match(tt.placeholder) ||\n          this.match(tt.braceL)\n        ) {\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(\n            PlaceholderErrors.ClassNameIsRequired,\n            this.state.startLoc,\n          );\n        }\n      } else {\n        this.parseClassId(node, isStatement, optionalId);\n      }\n\n      super.parseClassSuper(node);\n      node.body =\n        this.parsePlaceholder(\"ClassBody\") ||\n        super.parseClassBody(!!node.superClass, oldStrict);\n      return this.finishNode(node, type);\n    }\n\n    parseExport(\n      node: Undone<\n        | N.ExportDefaultDeclaration\n        | N.ExportAllDeclaration\n        | N.ExportNamedDeclaration\n      >,\n      decorators: N.Decorator[] | null,\n    ): N.AnyExport {\n      const placeholder = this.parsePlaceholder(\"Identifier\");\n      if (!placeholder) return super.parseExport(node, decorators);\n\n      const node2 = node as Undone<N.ExportNamedDeclaration>;\n\n      if (!this.isContextual(tt._from) && !this.match(tt.comma)) {\n        // export %%DECL%%;\n        node2.specifiers = [];\n        node2.source = null;\n        node2.declaration = this.finishPlaceholder(placeholder, \"Declaration\");\n        return this.finishNode(node2, \"ExportNamedDeclaration\");\n      }\n\n      // export %%NAME%% from \"foo\";\n      this.expectPlugin(\"exportDefaultFrom\");\n      const specifier = this.startNode<N.ExportDefaultSpecifier>();\n      specifier.exported = placeholder;\n      node2.specifiers = [this.finishNode(specifier, \"ExportDefaultSpecifier\")];\n\n      return super.parseExport(node2, decorators);\n    }\n\n    isExportDefaultSpecifier(): boolean {\n      if (this.match(tt._default)) {\n        const next = this.nextTokenStart();\n        if (this.isUnparsedContextual(next, \"from\")) {\n          if (\n            this.input.startsWith(\n              tokenLabelName(tt.placeholder),\n              this.nextTokenStartSince(next + 4),\n            )\n          ) {\n            return true;\n          }\n        }\n      }\n      return super.isExportDefaultSpecifier();\n    }\n\n    maybeParseExportDefaultSpecifier(\n      node: Undone<\n        | N.ExportDefaultDeclaration\n        | N.ExportAllDeclaration\n        | N.ExportNamedDeclaration\n      >,\n      maybeDefaultIdentifier: N.Identifier | null,\n    ): node is Undone<N.ExportNamedDeclaration> {\n      if ((node as N.ExportNamedDeclaration).specifiers?.length) {\n        // \"export %%NAME%%\" has already been parsed by #parseExport.\n        return true;\n      }\n      return super.maybeParseExportDefaultSpecifier(\n        node,\n        maybeDefaultIdentifier,\n      );\n    }\n\n    checkExport(node: N.ExportNamedDeclaration): void {\n      const { specifiers } = node;\n      if (specifiers?.length) {\n        node.specifiers = specifiers.filter(\n          // @ts-expect-error placeholder typings\n          node => node.exported.type === \"Placeholder\",\n        );\n      }\n      super.checkExport(node);\n      node.specifiers = specifiers;\n    }\n\n    parseImport(\n      node: Undone<N.ImportDeclaration>,\n    ): N.ImportDeclaration | N.TsImportEqualsDeclaration {\n      const placeholder = this.parsePlaceholder(\"Identifier\");\n      if (!placeholder) return super.parseImport(node);\n\n      node.specifiers = [];\n\n      if (!this.isContextual(tt._from) && !this.match(tt.comma)) {\n        // import %%STRING%%;\n        node.source = this.finishPlaceholder(placeholder, \"StringLiteral\");\n        this.semicolon();\n        return this.finishNode(node, \"ImportDeclaration\");\n      }\n\n      // import %%DEFAULT%% ...\n      const specifier =\n        this.startNodeAtNode<N.ImportDefaultSpecifier>(placeholder);\n      specifier.local = placeholder;\n      node.specifiers.push(\n        this.finishNode(specifier, \"ImportDefaultSpecifier\"),\n      );\n\n      if (this.eat(tt.comma)) {\n        // import %%DEFAULT%%, * as ...\n        const hasStarImport = this.maybeParseStarImportSpecifier(node);\n\n        // import %%DEFAULT%%, { ...\n        if (!hasStarImport) this.parseNamedImportSpecifiers(node);\n      }\n\n      this.expectContextual(tt._from);\n      node.source = this.parseImportSource();\n      this.semicolon();\n      return this.finishNode(node, \"ImportDeclaration\");\n    }\n\n    parseImportSource(): MaybePlaceholder<\"StringLiteral\"> {\n      // import ... from %%STRING%%;\n\n      return (\n        this.parsePlaceholder(\"StringLiteral\") || super.parseImportSource()\n      );\n    }\n\n    // Throws if the current token and the prev one are separated by a space.\n    assertNoSpace(): void {\n      if (\n        this.state.start >\n        this.offsetToSourcePos(this.state.lastTokEndLoc.index)\n      ) {\n        this.raise(PlaceholderErrors.UnexpectedSpace, this.state.lastTokEndLoc);\n      }\n    }\n  };\n","import type Parser from \"../parser/index.ts\";\nimport { tokenIsIdentifier, tt } from \"../tokenizer/types.ts\";\nimport type * as N from \"../types.ts\";\nimport type { ExpressionErrors } from \"../parser/util.ts\";\n\nexport default (superClass: typeof Parser) =>\n  class V8IntrinsicMixin extends superClass implements Parser {\n    parseV8Intrinsic(): N.Expression {\n      if (this.match(tt.modulo)) {\n        const v8IntrinsicStartLoc = this.state.startLoc;\n        // let the `loc` of Identifier starts from `%`\n        const node = this.startNode<N.Identifier>();\n        this.next(); // eat '%'\n        if (tokenIsIdentifier(this.state.type)) {\n          const name = this.parseIdentifierName();\n          const identifier = this.createIdentifier(node, name);\n          // @ts-expect-error: avoid mutating AST types\n          identifier.type = \"V8IntrinsicIdentifier\";\n          if (this.match(tt.parenL)) {\n            return identifier;\n          }\n        }\n        this.unexpected(v8IntrinsicStartLoc);\n      }\n    }\n\n    /* ============================================================ *\n     * parser/expression.js                                         *\n     * ============================================================ */\n\n    parseExprAtom(refExpressionErrors?: ExpressionErrors | null): N.Expression {\n      return (\n        this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors)\n      );\n    }\n  };\n","import type Parser from \"./parser/index.ts\";\nimport type { PluginConfig } from \"./typings.ts\";\n\nexport type Plugin = PluginConfig;\n\nexport type PluginList = PluginConfig[];\n\nexport type MixinPlugin = (\n  superClass: new (...args: any) => Parser,\n) => new (...args: any) => Parser;\n\nconst PIPELINE_PROPOSALS = process.env.BABEL_8_BREAKING\n  ? [\"fsharp\", \"hack\"]\n  : [\"minimal\", \"fsharp\", \"hack\", \"smart\"];\nconst TOPIC_TOKENS = [\"^^\", \"@@\", \"^\", \"%\", \"#\"];\n\nexport function validatePlugins(pluginsMap: Map<string, any>) {\n  if (pluginsMap.has(\"decorators\")) {\n    if (pluginsMap.has(\"decorators-legacy\")) {\n      throw new Error(\n        \"Cannot use the decorators and decorators-legacy plugin together\",\n      );\n    }\n\n    const decoratorsBeforeExport =\n      pluginsMap.get(\"decorators\").decoratorsBeforeExport;\n    if (\n      decoratorsBeforeExport != null &&\n      typeof decoratorsBeforeExport !== \"boolean\"\n    ) {\n      throw new Error(\n        \"'decoratorsBeforeExport' must be a boolean, if specified.\",\n      );\n    }\n\n    const allowCallParenthesized =\n      pluginsMap.get(\"decorators\").allowCallParenthesized;\n    if (\n      allowCallParenthesized != null &&\n      typeof allowCallParenthesized !== \"boolean\"\n    ) {\n      throw new Error(\"'allowCallParenthesized' must be a boolean.\");\n    }\n  }\n\n  if (pluginsMap.has(\"flow\") && pluginsMap.has(\"typescript\")) {\n    throw new Error(\"Cannot combine flow and typescript plugins.\");\n  }\n\n  if (pluginsMap.has(\"placeholders\") && pluginsMap.has(\"v8intrinsic\")) {\n    throw new Error(\"Cannot combine placeholders and v8intrinsic plugins.\");\n  }\n\n  if (pluginsMap.has(\"pipelineOperator\")) {\n    const proposal = pluginsMap.get(\"pipelineOperator\").proposal;\n\n    if (!PIPELINE_PROPOSALS.includes(proposal)) {\n      const proposalList = PIPELINE_PROPOSALS.map(p => `\"${p}\"`).join(\", \");\n      throw new Error(\n        `\"pipelineOperator\" requires \"proposal\" option whose value must be one of: ${proposalList}.`,\n      );\n    }\n\n    const tupleSyntaxIsHash = process.env.BABEL_8_BREAKING\n      ? pluginsMap.has(\"recordAndTuple\")\n      : pluginsMap.get(\"recordAndTuple\")?.syntaxType === \"hash\";\n\n    if (proposal === \"hack\") {\n      if (pluginsMap.has(\"placeholders\")) {\n        throw new Error(\n          \"Cannot combine placeholders plugin and Hack-style pipes.\",\n        );\n      }\n\n      if (pluginsMap.has(\"v8intrinsic\")) {\n        throw new Error(\n          \"Cannot combine v8intrinsic plugin and Hack-style pipes.\",\n        );\n      }\n\n      const topicToken = pluginsMap.get(\"pipelineOperator\").topicToken;\n\n      if (!TOPIC_TOKENS.includes(topicToken)) {\n        const tokenList = TOPIC_TOKENS.map(t => `\"${t}\"`).join(\", \");\n\n        throw new Error(\n          `\"pipelineOperator\" in \"proposal\": \"hack\" mode also requires a \"topicToken\" option whose value must be one of: ${tokenList}.`,\n        );\n      }\n\n      if (topicToken === \"#\" && tupleSyntaxIsHash) {\n        throw new Error(\n          `Plugin conflict between \\`[\"pipelineOperator\", { proposal: \"hack\", topicToken: \"#\" }]\\` and \\`${JSON.stringify([\"recordAndTuple\", pluginsMap.get(\"recordAndTuple\")])}\\`.`,\n        );\n      }\n    } else if (\n      !process.env.BABEL_8_BREAKING &&\n      proposal === \"smart\" &&\n      tupleSyntaxIsHash\n    ) {\n      throw new Error(\n        `Plugin conflict between \\`[\"pipelineOperator\", { proposal: \"smart\" }]\\` and \\`${JSON.stringify([\"recordAndTuple\", pluginsMap.get(\"recordAndTuple\")])}\\`.`,\n      );\n    }\n  }\n\n  if (pluginsMap.has(\"moduleAttributes\")) {\n    if (process.env.BABEL_8_BREAKING) {\n      throw new Error(\n        \"`moduleAttributes` has been removed in Babel 8, please migrate to import attributes instead.\",\n      );\n    } else {\n      if (\n        pluginsMap.has(\"deprecatedImportAssert\") ||\n        pluginsMap.has(\"importAssertions\")\n      ) {\n        throw new Error(\n          \"Cannot combine importAssertions, deprecatedImportAssert and moduleAttributes plugins.\",\n        );\n      }\n      const moduleAttributesVersionPluginOption =\n        pluginsMap.get(\"moduleAttributes\").version;\n      if (moduleAttributesVersionPluginOption !== \"may-2020\") {\n        throw new Error(\n          \"The 'moduleAttributes' plugin requires a 'version' option,\" +\n            \" representing the last proposal update. Currently, the\" +\n            \" only supported value is 'may-2020'.\",\n        );\n      }\n    }\n  }\n  if (pluginsMap.has(\"importAssertions\")) {\n    if (process.env.BABEL_8_BREAKING) {\n      throw new Error(\n        \"`importAssertions` has been removed in Babel 8, please use import attributes instead.\" +\n          \" To use the non-standard `assert` syntax you can enable the `deprecatedImportAssert` parser plugin.\",\n      );\n    } else if (pluginsMap.has(\"deprecatedImportAssert\")) {\n      throw new Error(\n        \"Cannot combine importAssertions and deprecatedImportAssert plugins.\",\n      );\n    }\n  }\n  if (\n    !pluginsMap.has(\"deprecatedImportAssert\") &&\n    pluginsMap.has(\"importAttributes\") &&\n    pluginsMap.get(\"importAttributes\").deprecatedAssertSyntax\n  ) {\n    if (process.env.BABEL_8_BREAKING) {\n      throw new Error(\n        \"The 'importAttributes' plugin has been removed in Babel 8. If you need to enable support \" +\n          \"for the deprecated `assert` syntax, you can enable the `deprecatedImportAssert` parser plugin.\",\n      );\n    } else {\n      pluginsMap.set(\"deprecatedImportAssert\", {});\n    }\n  }\n\n  if (pluginsMap.has(\"recordAndTuple\")) {\n    const syntaxType = pluginsMap.get(\"recordAndTuple\").syntaxType;\n    if (syntaxType != null) {\n      if (process.env.BABEL_8_BREAKING) {\n        if (syntaxType === \"hash\") {\n          throw new Error(\n            'The syntaxType option is no longer required in Babel 8. You can safely remove { syntaxType: \"hash\" } from the recordAndTuple config.',\n          );\n        } else {\n          throw new Error(\n            'The syntaxType option is no longer required in Babel 8. Please remove { syntaxType: \"bar\" } from the recordAndTuple config and migrate to the hash syntax #{} and #[].',\n          );\n        }\n      } else {\n        const RECORD_AND_TUPLE_SYNTAX_TYPES = [\"hash\", \"bar\"];\n        if (!RECORD_AND_TUPLE_SYNTAX_TYPES.includes(syntaxType)) {\n          throw new Error(\n            \"The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: \" +\n              RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(\", \"),\n          );\n        }\n      }\n    }\n  }\n\n  if (\n    pluginsMap.has(\"asyncDoExpressions\") &&\n    !pluginsMap.has(\"doExpressions\")\n  ) {\n    const error = new Error(\n      \"'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.\",\n    );\n    // @ts-expect-error so @babel/core can provide better error message\n    error.missingPlugins = \"doExpressions\";\n    throw error;\n  }\n\n  if (\n    pluginsMap.has(\"optionalChainingAssign\") &&\n    pluginsMap.get(\"optionalChainingAssign\").version !== \"2023-07\"\n  ) {\n    throw new Error(\n      \"The 'optionalChainingAssign' plugin requires a 'version' option,\" +\n        \" representing the last proposal update. Currently, the\" +\n        \" only supported value is '2023-07'.\",\n    );\n  }\n\n  if (process.env.BABEL_8_BREAKING) {\n    if (pluginsMap.has(\"decimal\")) {\n      throw new Error(\n        \"The 'decimal' plugin has been removed in Babel 8. Please remove it from your configuration.\",\n      );\n    }\n    if (pluginsMap.has(\"importReflection\")) {\n      throw new Error(\n        \"The 'importReflection' plugin has been removed in Babel 8. Use 'sourcePhaseImports' instead, and \" +\n          \"replace 'import module' with 'import source' in your code.\",\n      );\n    }\n  }\n}\n\n// These plugins are defined using a mixin which extends the parser class.\n\nimport estree from \"./plugins/estree.ts\";\nimport flow from \"./plugins/flow/index.ts\";\nimport jsx from \"./plugins/jsx/index.ts\";\nimport typescript from \"./plugins/typescript/index.ts\";\nimport placeholders from \"./plugins/placeholders.ts\";\nimport v8intrinsic from \"./plugins/v8intrinsic.ts\";\n\n// NOTE: order is important. estree must come first; placeholders must come last.\nexport const mixinPlugins = {\n  estree,\n  jsx,\n  flow,\n  typescript,\n  v8intrinsic,\n  placeholders,\n};\n\nexport const mixinPluginNames = Object.keys(mixinPlugins) as ReadonlyArray<\n  \"estree\" | \"jsx\" | \"flow\" | \"typescript\" | \"v8intrinsic\" | \"placeholders\"\n>;\n","// A recursive descent parser operates by defining functions for all\n// syntactic elements, and recursively calling those, each function\n// advancing the input stream and returning an AST node. Precedence\n// of constructs (for example, the fact that `!x[1]` means `!(x[1])`\n// instead of `(!x)[1]` is handled by the fact that the parser\n// function that parses unary prefix operators is called first, and\n// in turn calls the function that parses `[]` subscripts — that\n// way, it'll receive the node for `x[1]` already parsed, and wraps\n// *that* in the unary operator node.\n//\n// Acorn uses an [operator precedence parser][opp] to handle binary\n// operator precedence, because it is much more compact than using\n// the technique outlined above, which uses different, nesting\n// functions to specify precedence, for all of the ten binary\n// precedence levels that JavaScript defines.\n//\n// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser\n\nimport {\n  tokenCanStartExpression,\n  tokenIsAssignment,\n  tokenIsIdentifier,\n  tokenIsKeywordOrIdentifier,\n  tokenIsOperator,\n  tokenIsPostfix,\n  tokenIsPrefix,\n  tokenIsRightAssociative,\n  tokenIsTemplate,\n  tokenKeywordOrIdentifierIsKeyword,\n  tokenLabelName,\n  tokenOperatorPrecedence,\n  tt,\n  type TokenType,\n} from \"../tokenizer/types.ts\";\nimport type * as N from \"../types.ts\";\nimport LValParser from \"./lval.ts\";\nimport {\n  isKeyword,\n  isReservedWord,\n  isStrictReservedWord,\n  isStrictBindReservedWord,\n  isIdentifierStart,\n  canBeReservedWord,\n} from \"../util/identifier.ts\";\nimport {\n  type Position,\n  createPositionWithColumnOffset,\n} from \"../util/location.ts\";\nimport * as charCodes from \"charcodes\";\nimport { ScopeFlag, BindingFlag } from \"../util/scopeflags.ts\";\nimport { ExpressionErrors } from \"./util.ts\";\nimport { ParamKind, functionFlags } from \"../util/production-parameter.ts\";\nimport {\n  newArrowHeadScope,\n  newAsyncArrowScope,\n  newExpressionScope,\n} from \"../util/expression-scope.ts\";\nimport { Errors, type ParseError } from \"../parse-error.ts\";\nimport {\n  UnparenthesizedPipeBodyDescriptions,\n  type UnparenthesizedPipeBodyTypes,\n} from \"../parse-error/pipeline-operator-errors.ts\";\nimport { setInnerComments } from \"./comments.ts\";\nimport { cloneIdentifier, type Undone } from \"./node.ts\";\nimport type Parser from \"./index.ts\";\n\nimport { OptionFlags, type SourceType } from \"../options.ts\";\n\nexport default abstract class ExpressionParser extends LValParser {\n  // Forward-declaration: defined in statement.js\n  abstract parseBlock(\n    allowDirectives?: boolean,\n    createNewLexicalScope?: boolean,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): N.BlockStatement;\n  abstract parseClass(\n    node: N.Class,\n    isStatement: boolean,\n    optionalId?: boolean,\n  ): N.Class;\n  abstract parseDecorators(allowExport?: boolean): void;\n  abstract parseFunction<T extends N.NormalFunction>(\n    node: T,\n    statement?: number,\n    allowExpressionBody?: boolean,\n    isAsync?: boolean,\n  ): T;\n  abstract parseFunctionParams(node: N.Function, isConstructor?: boolean): void;\n  abstract parseBlockOrModuleBlockBody(\n    body: N.Statement[],\n    directives: N.Directive[] | null | undefined,\n    topLevel: boolean,\n    end: TokenType,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): void;\n  abstract parseProgram(\n    program: N.Program,\n    end: TokenType,\n    sourceType?: SourceType,\n  ): N.Program;\n\n  // For object literal, check if property __proto__ has been used more than once.\n  // If the expression is a destructuring assignment, then __proto__ may appear\n  // multiple times. Otherwise, __proto__ is a duplicated key.\n\n  // For record expression, check if property __proto__ exists\n\n  checkProto(\n    prop: N.ObjectMember | N.SpreadElement,\n    isRecord: boolean | undefined | null,\n    protoRef: {\n      used: boolean;\n    },\n    refExpressionErrors?: ExpressionErrors | null,\n  ): void {\n    if (\n      prop.type === \"SpreadElement\" ||\n      this.isObjectMethod(prop) ||\n      prop.computed ||\n      prop.shorthand\n    ) {\n      return;\n    }\n\n    const key = prop.key as\n      | N.Identifier\n      | N.StringLiteral\n      | N.NumericLiteral\n      | N.BigIntLiteral;\n    // It is either an Identifier or a String/NumericLiteral\n    const name = key.type === \"Identifier\" ? key.name : key.value;\n\n    if (name === \"__proto__\") {\n      if (isRecord) {\n        this.raise(Errors.RecordNoProto, key);\n        return;\n      }\n      if (protoRef.used) {\n        if (refExpressionErrors) {\n          // Store the first redefinition's position, otherwise ignore because\n          // we are parsing ambiguous pattern\n          if (refExpressionErrors.doubleProtoLoc === null) {\n            refExpressionErrors.doubleProtoLoc = key.loc.start;\n          }\n        } else {\n          this.raise(Errors.DuplicateProto, key);\n        }\n      }\n\n      protoRef.used = true;\n    }\n  }\n\n  shouldExitDescending(\n    expr: N.Expression | N.PrivateName,\n    potentialArrowAt: number,\n  ): expr is N.ArrowFunctionExpression {\n    return (\n      expr.type === \"ArrowFunctionExpression\" &&\n      this.offsetToSourcePos(expr.start) === potentialArrowAt\n    );\n  }\n\n  // Convenience method to parse an Expression only\n  getExpression(this: Parser): N.Expression & N.ParserOutput {\n    this.enterInitialScopes();\n    this.nextToken();\n    const expr = this.parseExpression() as N.Expression & N.ParserOutput;\n    if (!this.match(tt.eof)) {\n      this.unexpected();\n    }\n    // Unlike parseTopLevel, we need to drain remaining commentStacks\n    // because the top level node is _not_ Program.\n    this.finalizeRemainingComments();\n    expr.comments = this.comments;\n    expr.errors = this.state.errors;\n    if (this.optionFlags & OptionFlags.Tokens) {\n      expr.tokens = this.tokens;\n    }\n    return expr;\n  }\n\n  // ### Expression parsing\n\n  // These nest, from the most general expression type at the top to\n  // 'atomic', nondivisible expression types at the bottom. Most of\n  // the functions will simply let the function (s) below them parse,\n  // and, *if* the syntactic construct they handle is present, wrap\n  // the AST node that the inner parser gave them in another node.\n\n  // Parse a full expression.\n  // - `disallowIn`\n  //   is used to forbid the `in` operator (in for loops initialization expressions)\n  //   When `disallowIn` is true, the production parameter [In] is not present.\n\n  // - `refExpressionErrors `\n  //   provides reference for storing '=' operator inside shorthand\n  //   property assignment in contexts where both object expression\n  //   and object pattern might appear (so it's possible to raise\n  //   delayed syntax error at correct position).\n\n  parseExpression(\n    this: Parser,\n    disallowIn?: boolean,\n    refExpressionErrors?: ExpressionErrors,\n  ): N.Expression {\n    if (disallowIn) {\n      return this.disallowInAnd(() =>\n        this.parseExpressionBase(refExpressionErrors),\n      );\n    }\n    return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));\n  }\n\n  // https://tc39.es/ecma262/#prod-Expression\n  parseExpressionBase(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const expr = this.parseMaybeAssign(refExpressionErrors);\n    if (this.match(tt.comma)) {\n      const node = this.startNodeAt<N.SequenceExpression>(startLoc);\n      node.expressions = [expr];\n      while (this.eat(tt.comma)) {\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\n  // Set [~In] parameter for assignment expression\n  parseMaybeAssignDisallowIn(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n  ) {\n    return this.disallowInAnd(() =>\n      this.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n    );\n  }\n\n  // Set [+In] parameter for assignment expression\n  parseMaybeAssignAllowIn(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n  ) {\n    return this.allowInAnd(() =>\n      this.parseMaybeAssign(refExpressionErrors, afterLeftParse),\n    );\n  }\n\n  // This method is only used by\n  // the typescript and flow plugins.\n  setOptionalParametersError(\n    refExpressionErrors: ExpressionErrors,\n    resultError?: ParseError<any>,\n  ) {\n    refExpressionErrors.optionalParametersLoc =\n      resultError?.loc ?? this.state.startLoc;\n  }\n\n  // Parse an assignment expression. This includes applications of\n  // operators like `+=`.\n  // https://tc39.es/ecma262/#prod-AssignmentExpression\n  parseMaybeAssign(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    afterLeftParse?: Function,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    if (this.isContextual(tt._yield)) {\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\n    let ownExpressionErrors;\n    if (refExpressionErrors) {\n      ownExpressionErrors = false;\n    } else {\n      refExpressionErrors = new ExpressionErrors();\n      ownExpressionErrors = true;\n    }\n    const { type } = this.state;\n\n    if (type === tt.parenL || tokenIsIdentifier(type)) {\n      this.state.potentialArrowAt = this.state.start;\n    }\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<N.AssignmentExpression>(startLoc);\n      const operator = this.state.value;\n      node.operator = operator;\n\n      if (this.match(tt.eq)) {\n        this.toAssignable(left, /* isLHS */ true);\n        node.left = left;\n\n        const startIndex = startLoc.index;\n        if (\n          refExpressionErrors.doubleProtoLoc != null &&\n          refExpressionErrors.doubleProtoLoc.index >= startIndex\n        ) {\n          refExpressionErrors.doubleProtoLoc = null; // reset because double __proto__ is valid in assignment expression\n        }\n        if (\n          refExpressionErrors.shorthandAssignLoc != null &&\n          refExpressionErrors.shorthandAssignLoc.index >= startIndex\n        ) {\n          refExpressionErrors.shorthandAssignLoc = null; // reset because shorthand default was used correctly\n        }\n        if (\n          refExpressionErrors.privateKeyLoc != null &&\n          refExpressionErrors.privateKeyLoc.index >= startIndex\n        ) {\n          this.checkDestructuringPrivate(refExpressionErrors);\n          refExpressionErrors.privateKeyLoc = null; // reset because `({ #x: x })` is an assignable pattern\n        }\n      } else {\n        node.left = left as unknown as N.Assignable; // checked a few lines further down\n      }\n\n      this.next();\n      node.right = this.parseMaybeAssign();\n      this.checkLVal(left, this.finishNode(node, \"AssignmentExpression\"));\n      // @ts-expect-error todo(flow->ts) improve node types\n      return node;\n    } else if (ownExpressionErrors) {\n      this.checkExpressionErrors(refExpressionErrors, true);\n    }\n\n    return left;\n  }\n\n  // Parse a ternary conditional (`?:`) operator.\n  // https://tc39.es/ecma262/#prod-ConditionalExpression\n\n  parseMaybeConditional(\n    this: Parser,\n    refExpressionErrors: ExpressionErrors,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseExprOps(refExpressionErrors);\n\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n\n    return this.parseConditional(expr, startLoc, refExpressionErrors);\n  }\n\n  parseConditional(\n    this: Parser,\n    expr: N.Expression,\n    startLoc: Position,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    if (this.eat(tt.question)) {\n      const node = this.startNodeAt<N.ConditionalExpression>(startLoc);\n      node.test = expr;\n      node.consequent = this.parseMaybeAssignAllowIn();\n      this.expect(tt.colon);\n      node.alternate = this.parseMaybeAssign();\n      return this.finishNode(node, \"ConditionalExpression\");\n    }\n    return expr;\n  }\n\n  parseMaybeUnaryOrPrivate(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors,\n  ): N.Expression | N.PrivateName {\n    return this.match(tt.privateName)\n      ? this.parsePrivateName()\n      : this.parseMaybeUnary(refExpressionErrors);\n  }\n\n  // Start the precedence parser.\n  // https://tc39.es/ecma262/#prod-ShortCircuitExpression\n\n  parseExprOps(\n    this: Parser,\n    refExpressionErrors: ExpressionErrors,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);\n\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n\n    return this.parseExprOp(expr, startLoc, -1);\n  }\n\n  // Parse binary operators with the operator precedence parsing\n  // algorithm. `left` is the left-hand side of the operator.\n  // `minPrec` provides context that allows the function to stop and\n  // defer further parser to one of its callers when it encounters an\n  // operator that has a lower precedence than the set it is parsing.\n\n  parseExprOp(\n    this: Parser,\n    left: N.Expression | N.PrivateName,\n    leftStartLoc: Position,\n    minPrec: number,\n  ): N.Expression {\n    if (this.isPrivateName(left)) {\n      // https://tc39.es/ecma262/#prod-RelationalExpression\n      // RelationalExpression [In, Yield, Await]\n      //   [+In] PrivateIdentifier in ShiftExpression[?Yield, ?Await]\n\n      const value = this.getPrivateNameSV(left);\n\n      if (\n        minPrec >= tokenOperatorPrecedence(tt._in) ||\n        !this.prodParam.hasIn ||\n        !this.match(tt._in)\n      ) {\n        this.raise(Errors.PrivateInExpectedIn, left, {\n          identifierName: value,\n        });\n      }\n\n      this.classScope.usePrivateName(value, left.loc.start);\n    }\n\n    const op = this.state.type;\n    if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(tt._in))) {\n      let prec = tokenOperatorPrecedence(op);\n      if (prec > minPrec) {\n        if (op === tt.pipeline) {\n          this.expectPlugin(\"pipelineOperator\");\n          if (this.state.inFSharpPipelineDirectBody) {\n            // PrivateName must be followed by `in`, but we have `|>`\n            return left as N.Expression;\n          }\n          this.checkPipelineAtInfixOperator(left as N.Expression, leftStartLoc);\n        }\n        const node = this.startNodeAt<N.LogicalExpression | N.BinaryExpression>(\n          leftStartLoc,\n        );\n        node.left = left;\n        node.operator = this.state.value;\n\n        const logical = op === tt.logicalOR || op === tt.logicalAND;\n        const coalesce = op === tt.nullishCoalescing;\n\n        if (coalesce) {\n          // Handle the precedence of `tt.coalesce` as equal to the range of logical expressions.\n          // In other words, `node.right` shouldn't contain logical expressions in order to check the mixed error.\n          prec = tokenOperatorPrecedence(tt.logicalAND);\n        }\n\n        this.next();\n\n        if (\n          !process.env.BABEL_8_BREAKING &&\n          op === tt.pipeline &&\n          // @ts-expect-error: Only in Babel 7\n          this.hasPlugin([\"pipelineOperator\", { proposal: \"minimal\" }])\n        ) {\n          if (this.state.type === tt._await && this.prodParam.hasAwait) {\n            throw this.raise(\n              Errors.UnexpectedAwaitAfterPipelineBody,\n              this.state.startLoc,\n            );\n          }\n        }\n\n        node.right = this.parseExprOpRightExpr(op, prec);\n        const finishedNode = this.finishNode(\n          node,\n          logical || coalesce ? \"LogicalExpression\" : \"BinaryExpression\",\n        );\n        /* this check is for all ?? operators\n         * a ?? b && c for this example\n         * when op is coalesce and nextOp is logical (&&), throw at the pos of nextOp that it can not be mixed.\n         * Symmetrically it also throws when op is logical and nextOp is coalesce\n         */\n        const nextOp = this.state.type;\n        if (\n          (coalesce && (nextOp === tt.logicalOR || nextOp === tt.logicalAND)) ||\n          (logical && nextOp === tt.nullishCoalescing)\n        ) {\n          throw this.raise(\n            Errors.MixingCoalesceWithLogical,\n            this.state.startLoc,\n          );\n        }\n\n        return this.parseExprOp(finishedNode, leftStartLoc, minPrec);\n      }\n    }\n    // PrivateName is followed by `in` and handled by the previous if statement\n    return left as N.Expression;\n  }\n\n  // Helper function for `parseExprOp`. Parse the right-hand side of binary-\n  // operator expressions, then apply any operator-specific functions.\n\n  parseExprOpRightExpr(\n    this: Parser,\n    op: TokenType,\n    prec: number,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    switch (op) {\n      case tt.pipeline:\n        switch (this.getPluginOption(\"pipelineOperator\", \"proposal\")) {\n          case \"hack\":\n            return this.withTopicBindingContext(() => {\n              return this.parseHackPipeBody();\n            });\n\n          case \"fsharp\":\n            return this.withSoloAwaitPermittingContext(() => {\n              return this.parseFSharpPipelineBody(prec);\n            });\n        }\n\n        if (\n          !process.env.BABEL_8_BREAKING &&\n          // @ts-expect-error: Babel 7 only\n          this.getPluginOption(\"pipelineOperator\", \"proposal\") === \"smart\"\n        ) {\n          return this.withTopicBindingContext(() => {\n            if (this.prodParam.hasYield && this.isContextual(tt._yield)) {\n              throw this.raise(Errors.PipeBodyIsTighter, this.state.startLoc);\n            }\n            return this.parseSmartPipelineBodyInStyle(\n              this.parseExprOpBaseRightExpr(op, prec),\n              startLoc,\n            );\n          });\n        }\n\n      // Falls through.\n      default:\n        return this.parseExprOpBaseRightExpr(op, prec);\n    }\n  }\n\n  // Helper function for `parseExprOpRightExpr`. Parse the right-hand side of\n  // binary-operator expressions without applying any operator-specific functions.\n\n  parseExprOpBaseRightExpr(\n    this: Parser,\n    op: TokenType,\n    prec: number,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n\n    return this.parseExprOp(\n      this.parseMaybeUnaryOrPrivate(),\n      startLoc,\n      tokenIsRightAssociative(op) ? prec - 1 : prec,\n    );\n  }\n\n  parseHackPipeBody(this: Parser): N.Expression {\n    const { startLoc } = this.state;\n    const body = this.parseMaybeAssign();\n    const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(\n      // @ts-expect-error TS2345: Argument of type 'string' is not assignable to parameter of type '\"ArrowFunctionExpression\" | \"YieldExpression\" | \"AssignmentExpression\" | \"ConditionalExpression\"'.\n      body.type,\n    );\n\n    // TODO: Check how to handle type casts in Flow and TS once they are supported\n    if (requiredParentheses && !body.extra?.parenthesized) {\n      this.raise(Errors.PipeUnparenthesizedBody, startLoc, {\n        type: body.type as UnparenthesizedPipeBodyTypes,\n      });\n    }\n    if (!this.topicReferenceWasUsedInCurrentContext()) {\n      // A Hack pipe body must use the topic reference at least once.\n      this.raise(Errors.PipeTopicUnused, startLoc);\n    }\n\n    return body;\n  }\n\n  checkExponentialAfterUnary(\n    node: N.AwaitExpression | Undone<N.UnaryExpression>,\n  ) {\n    if (this.match(tt.exponent)) {\n      this.raise(Errors.UnexpectedTokenUnaryExponentiation, node.argument);\n    }\n  }\n\n  // Parse unary operators, both prefix and postfix.\n  // https://tc39.es/ecma262/#prod-UnaryExpression\n  parseMaybeUnary(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n    sawUnary?: boolean,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const isAwait = this.isContextual(tt._await);\n\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(tt.incDec);\n    const node = this.startNode<N.UnaryExpression | N.UpdateExpression>();\n    if (tokenIsPrefix(this.state.type)) {\n      node.operator = this.state.value;\n      node.prefix = true;\n\n      if (this.match(tt._throw)) {\n        this.expectPlugin(\"throwExpressions\");\n      }\n      const isDelete = this.match(tt._delete);\n      this.next();\n\n      node.argument = this.parseMaybeUnary(null, true);\n\n      this.checkExpressionErrors(refExpressionErrors, true);\n\n      if (this.state.strict && isDelete) {\n        const arg = node.argument;\n\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\n      if (!update) {\n        if (!sawUnary) {\n          this.checkExponentialAfterUnary(node as Undone<N.UnaryExpression>);\n        }\n        return this.finishNode(node, \"UnaryExpression\");\n      }\n    }\n\n    const expr = this.parseUpdate(\n      // @ts-expect-error using \"Undone\" node as \"done\"\n      node,\n      update,\n      refExpressionErrors,\n    );\n\n    if (isAwait) {\n      const { type } = this.state;\n      const startsExpr = this.hasPlugin(\"v8intrinsic\")\n        ? tokenCanStartExpression(type)\n        : tokenCanStartExpression(type) && !this.match(tt.modulo);\n      if (startsExpr && !this.isAmbiguousAwait()) {\n        this.raiseOverwrite(Errors.AwaitNotInAsyncContext, startLoc);\n        return this.parseAwait(startLoc);\n      }\n    }\n\n    return expr;\n  }\n\n  // https://tc39.es/ecma262/#prod-UpdateExpression\n  parseUpdate(\n    this: Parser,\n    node: N.Expression,\n    update: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    if (update) {\n      const updateExpressionNode = node as Undone<N.UpdateExpression>;\n      this.checkLVal(\n        updateExpressionNode.argument,\n        this.finishNode(updateExpressionNode, \"UpdateExpression\"),\n      );\n      return node;\n    }\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<N.UpdateExpression>(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\n  // Parse call, dot, and `[]`-subscript expressions.\n  // https://tc39.es/ecma262/#prod-LeftHandSideExpression\n  parseExprSubscripts(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n    const potentialArrowAt = this.state.potentialArrowAt;\n    const expr = this.parseExprAtom(refExpressionErrors);\n\n    if (this.shouldExitDescending(expr, potentialArrowAt)) {\n      return expr;\n    }\n\n    return this.parseSubscripts(expr, startLoc);\n  }\n\n  parseSubscripts(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    noCalls?: boolean | null,\n  ): N.Expression {\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\n      // After parsing a subscript, this isn't \"async\" for sure.\n      state.maybeAsyncArrow = false;\n    } while (!state.stop);\n    return base;\n  }\n\n  /**\n   * @param state Set 'state.stop = true' to indicate that we should stop parsing subscripts.\n   *   state.optionalChainMember to indicate that the member is currently in OptionalChain\n   */\n  parseSubscript(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    noCalls: boolean | undefined | null,\n    state: N.ParseSubscriptState,\n  ): N.Expression {\n    const { type } = this.state;\n    if (!noCalls && type === tt.doubleColon) {\n      return this.parseBind(base, startLoc, noCalls, state);\n    } else if (tokenIsTemplate(type)) {\n      return this.parseTaggedTemplateExpression(base, startLoc, state);\n    }\n\n    let optional = false;\n\n    if (type === tt.questionDot) {\n      if (noCalls) {\n        this.raise(Errors.OptionalChainingNoNew, this.state.startLoc);\n        if (this.lookaheadCharCode() === charCodes.leftParenthesis) {\n          // stop at `?.` when parsing `new a?.()`\n          state.stop = true;\n          return base;\n        }\n      }\n      state.optionalChainMember = optional = true;\n      this.next();\n    }\n\n    if (!noCalls && this.match(tt.parenL)) {\n      return this.parseCoverCallAndAsyncArrowHead(\n        base,\n        startLoc,\n        state,\n        optional,\n      );\n    } else {\n      const computed = this.eat(tt.bracketL);\n      if (computed || optional || this.eat(tt.dot)) {\n        return this.parseMember(base, startLoc, state, computed, optional);\n      } else {\n        state.stop = true;\n        return base;\n      }\n    }\n  }\n\n  // base[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ]\n  // base[?Yield, ?Await] . IdentifierName\n  // base[?Yield, ?Await] . PrivateIdentifier\n  //   where `base` is one of CallExpression, MemberExpression and OptionalChain\n  parseMember(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    state: N.ParseSubscriptState,\n    computed: boolean,\n    optional: boolean,\n  ): N.OptionalMemberExpression | N.MemberExpression {\n    const node = this.startNodeAt<\n      N.OptionalMemberExpression | N.MemberExpression\n    >(startLoc);\n    node.object = base;\n    node.computed = computed;\n    if (computed) {\n      node.property = this.parseExpression();\n      this.expect(tt.bracketR);\n    } else if (this.match(tt.privateName)) {\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\n    if (state.optionalChainMember) {\n      (node as N.OptionalMemberExpression).optional = optional;\n      return this.finishNode(node, \"OptionalMemberExpression\");\n    } else {\n      return this.finishNode(node, \"MemberExpression\");\n    }\n  }\n\n  // https://github.com/tc39/proposal-bind-operator#syntax\n  parseBind(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    noCalls: boolean | undefined | null,\n    state: N.ParseSubscriptState,\n  ): N.Expression {\n    const node = this.startNodeAt<N.BindExpression>(startLoc);\n    node.object = base;\n    this.next(); // eat '::'\n    node.callee = this.parseNoCallExpr();\n    state.stop = true;\n    return this.parseSubscripts(\n      this.finishNode(node, \"BindExpression\"),\n      startLoc,\n      noCalls,\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-CoverCallExpressionAndAsyncArrowHead\n  // CoverCallExpressionAndAsyncArrowHead\n  // CallExpression[?Yield, ?Await] Arguments[?Yield, ?Await]\n  // OptionalChain[?Yield, ?Await] Arguments[?Yield, ?Await]\n  parseCoverCallAndAsyncArrowHead(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    state: N.ParseSubscriptState,\n    optional: boolean,\n  ): N.Expression {\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    let refExpressionErrors: ExpressionErrors | null = null;\n\n    this.state.maybeInArrowParameters = true;\n    this.next(); // eat `(`\n\n    const node = this.startNodeAt<N.CallExpression | N.OptionalCallExpression>(\n      startLoc,\n    );\n    node.callee = base;\n    const { maybeAsyncArrow, optionalChainMember } = state;\n\n    if (maybeAsyncArrow) {\n      this.expressionScope.enter(newAsyncArrowScope());\n      refExpressionErrors = new ExpressionErrors();\n    }\n\n    if (optionalChainMember) {\n      // @ts-expect-error when optionalChainMember is true, node must be an optional call\n      node.optional = optional;\n    }\n\n    if (optional) {\n      node.arguments = this.parseCallExpressionArguments(tt.parenR);\n    } else {\n      node.arguments = this.parseCallExpressionArguments(\n        tt.parenR,\n        base.type !== \"Super\",\n        node,\n        refExpressionErrors,\n      );\n    }\n    let finishedNode:\n      | N.CallExpression\n      | N.OptionalCallExpression\n      | N.ArrowFunctionExpression = this.finishCallExpression(\n      node,\n      optionalChainMember,\n    );\n\n    if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {\n      /*:: invariant(refExpressionErrors != null) */\n      state.stop = true;\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.expressionScope.validateAsPattern();\n      this.expressionScope.exit();\n      finishedNode = this.parseAsyncArrowFromCallExpression(\n        this.startNodeAt<N.ArrowFunctionExpression>(startLoc),\n        finishedNode as N.CallExpression,\n      );\n    } else {\n      if (maybeAsyncArrow) {\n        this.checkExpressionErrors(refExpressionErrors, true);\n        this.expressionScope.exit();\n      }\n      this.toReferencedArguments(finishedNode);\n    }\n\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n\n    return finishedNode;\n  }\n\n  toReferencedArguments(\n    node: N.CallExpression | N.OptionalCallExpression,\n    isParenthesizedExpr?: boolean,\n  ) {\n    this.toReferencedListDeep(node.arguments, isParenthesizedExpr);\n  }\n\n  // MemberExpression [?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged]\n  // CallExpression [?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged]\n  parseTaggedTemplateExpression(\n    this: Parser,\n    base: N.Expression,\n    startLoc: Position,\n    state: N.ParseSubscriptState,\n  ): N.TaggedTemplateExpression {\n    const node = this.startNodeAt<N.TaggedTemplateExpression>(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\n  atPossibleAsyncArrow(base: N.Expression): boolean {\n    return (\n      base.type === \"Identifier\" &&\n      base.name === \"async\" &&\n      this.state.lastTokEndLoc.index === base.end &&\n      !this.canInsertSemicolon() &&\n      // check there are no escape sequences, such as \\u{61}sync\n      base.end - base.start === 5 &&\n      this.offsetToSourcePos(base.start) === this.state.potentialArrowAt\n    );\n  }\n\n  finishCallExpression<T extends N.CallExpression | N.OptionalCallExpression>(\n    node: Undone<T>,\n    optional: boolean,\n  ): T {\n    if (node.callee.type === \"Import\") {\n      if (node.arguments.length === 0 || node.arguments.length > 2) {\n        this.raise(Errors.ImportCallArity, node);\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(\n      node,\n      optional ? \"OptionalCallExpression\" : \"CallExpression\",\n    );\n  }\n\n  parseCallExpressionArguments(\n    this: Parser,\n    close: TokenType,\n    allowPlaceholder?: boolean,\n    nodeForExtra?: Undone<N.Node> | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): Array<N.Expression> {\n    const elts: N.Expression[] = [];\n    let first = true;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.match(close)) {\n          if (nodeForExtra) {\n            this.addTrailingCommaExtraToNode(nodeForExtra);\n          }\n          this.next();\n          break;\n        }\n      }\n\n      elts.push(\n        this.parseExprListItem(false, refExpressionErrors, allowPlaceholder),\n      );\n    }\n\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n\n    return elts;\n  }\n\n  shouldParseAsyncArrow(): boolean {\n    return this.match(tt.arrow) && !this.canInsertSemicolon();\n  }\n\n  parseAsyncArrowFromCallExpression(\n    this: Parser,\n    node: Undone<N.ArrowFunctionExpression>,\n    call: N.CallExpression,\n  ): N.ArrowFunctionExpression {\n    this.resetPreviousNodeTrailingComments(call);\n    this.expect(tt.arrow);\n    this.parseArrowExpression(\n      node,\n      call.arguments,\n      true,\n      call.extra?.trailingCommaLoc,\n    );\n    // mark inner comments of `async()` as inner comments of `async () =>`\n    if (call.innerComments) {\n      setInnerComments(node, call.innerComments);\n    }\n    // mark trailing comments of `async` to be inner comments\n    if (call.callee.trailingComments) {\n      setInnerComments(node, call.callee.trailingComments);\n    }\n    return node as N.ArrowFunctionExpression;\n  }\n\n  // Parse a no-call expression (like argument of `new` or `::` operators).\n  // https://tc39.es/ecma262/#prod-MemberExpression\n  parseNoCallExpr(this: Parser): N.Expression {\n    const startLoc = this.state.startLoc;\n    return this.parseSubscripts(this.parseExprAtom(), startLoc, true);\n  }\n\n  // Parse an atomic expression — either a single token that is an\n  // expression, an expression started by a keyword like `function` or\n  // `new`, or an expression wrapped in punctuation like `()`, `[]`,\n  // or `{}`.\n\n  // https://tc39.es/ecma262/#prod-PrimaryExpression\n  // https://tc39.es/ecma262/#prod-AsyncArrowFunction\n  // PrimaryExpression\n  // Super\n  // Import\n  // AsyncArrowFunction\n\n  parseExprAtom(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.Expression {\n    let node;\n    let decorators: N.Decorator[] | null = null;\n\n    const { type } = this.state;\n    switch (type) {\n      case tt._super:\n        return this.parseSuper();\n\n      case tt._import:\n        node = this.startNode<N.MetaProperty | N.Import | N.ImportExpression>();\n        this.next();\n\n        if (this.match(tt.dot)) {\n          return this.parseImportMetaProperty(node as Undone<N.MetaProperty>);\n        }\n\n        if (this.match(tt.parenL)) {\n          if (this.optionFlags & OptionFlags.CreateImportExpressions) {\n            return this.parseImportCall(node as Undone<N.ImportExpression>);\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\n      case tt._this:\n        node = this.startNode<N.ThisExpression>();\n        this.next();\n        return this.finishNode(node, \"ThisExpression\");\n\n      case tt._do: {\n        return this.parseDo(this.startNode(), false);\n      }\n\n      case tt.slash:\n      case tt.slashAssign: {\n        this.readRegexp();\n        return this.parseRegExpLiteral(this.state.value);\n      }\n\n      case tt.num:\n        return this.parseNumericLiteral(this.state.value);\n\n      case tt.bigint:\n        return this.parseBigIntLiteral(this.state.value);\n\n      case tt.string:\n        return this.parseStringLiteral(this.state.value);\n\n      case tt._null:\n        return this.parseNullLiteral();\n\n      case tt._true:\n        return this.parseBooleanLiteral(true);\n      case tt._false:\n        return this.parseBooleanLiteral(false);\n\n      case tt.parenL: {\n        const canBeArrow = this.state.potentialArrowAt === this.state.start;\n        return this.parseParenAndDistinguishExpression(canBeArrow);\n      }\n\n      case tt.bracketBarL:\n      case tt.bracketHashL: {\n        return this.parseArrayLike(\n          this.state.type === tt.bracketBarL ? tt.bracketBarR : tt.bracketR,\n          /* canBePattern */ false,\n          /* isTuple */ true,\n        );\n      }\n      case tt.bracketL: {\n        return this.parseArrayLike(\n          tt.bracketR,\n          /* canBePattern */ true,\n          /* isTuple */ false,\n          refExpressionErrors,\n        );\n      }\n      case tt.braceBarL:\n      case tt.braceHashL: {\n        return this.parseObjectLike(\n          this.state.type === tt.braceBarL ? tt.braceBarR : tt.braceR,\n          /* isPattern */ false,\n          /* isRecord */ true,\n        );\n      }\n      case tt.braceL: {\n        return this.parseObjectLike(\n          tt.braceR,\n          /* isPattern */ false,\n          /* isRecord */ false,\n          refExpressionErrors,\n        );\n      }\n      case tt._function:\n        return this.parseFunctionOrFunctionSent();\n\n      case tt.at:\n        decorators = this.parseDecorators();\n      // fall through\n      case tt._class:\n        return this.parseClass(\n          this.maybeTakeDecorators(\n            decorators,\n            this.startNode<N.ClassExpression>(),\n          ),\n          false,\n        );\n\n      case tt._new:\n        return this.parseNewOrNewTarget();\n\n      case tt.templateNonTail:\n      case tt.templateTail:\n        return this.parseTemplate(false);\n\n      // BindExpression[Yield]\n      //   :: MemberExpression[?Yield]\n      case tt.doubleColon: {\n        node = this.startNode<N.BindExpression>();\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\n      case tt.privateName: {\n        // Standalone private names are only allowed in \"#x in obj\"\n        // expressions, and they are directly handled by callers of\n        // parseExprOp. If we reach this, the input is always invalid.\n        // We can throw a better error message and recover, rather than\n        // just throwing \"Unexpected token\" (which is the default\n        // behavior of this big switch statement).\n        this.raise(Errors.PrivateInExpectedIn, this.state.startLoc, {\n          identifierName: this.state.value,\n        });\n        return this.parsePrivateName() as unknown as N.Expression;\n      }\n\n      case tt.moduloAssign: {\n        return this.parseTopicReferenceThenEqualsSign(tt.modulo, \"%\");\n      }\n\n      case tt.xorAssign: {\n        return this.parseTopicReferenceThenEqualsSign(tt.bitwiseXOR, \"^\");\n      }\n\n      case tt.doubleCaret:\n      case tt.doubleAt: {\n        return this.parseTopicReference(\"hack\");\n      }\n\n      case tt.bitwiseXOR:\n      case tt.modulo:\n      case tt.hash: {\n        const pipeProposal = this.getPluginOption(\n          \"pipelineOperator\",\n          \"proposal\",\n        );\n\n        if (pipeProposal) {\n          return this.parseTopicReference(pipeProposal);\n        }\n        this.unexpected();\n        break;\n      }\n\n      case tt.lt: {\n        const lookaheadCh = this.input.codePointAt(this.nextTokenStart());\n        if (\n          isIdentifierStart(lookaheadCh) || // Element/Type Parameter <foo>\n          lookaheadCh === charCodes.greaterThan // Fragment <>\n        ) {\n          this.expectOnePlugin([\"jsx\", \"flow\", \"typescript\"]);\n        } else {\n          this.unexpected();\n        }\n        break;\n      }\n\n      default:\n        if (!process.env.BABEL_8_BREAKING && type === tt.decimal) {\n          return this.parseDecimalLiteral(this.state.value);\n        }\n\n        if (tokenIsIdentifier(type)) {\n          if (\n            this.isContextual(tt._module) &&\n            this.lookaheadInLineCharCode() === charCodes.leftCurlyBrace\n          ) {\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\n          if (\n            !containsEsc &&\n            id.name === \"async\" &&\n            !this.canInsertSemicolon()\n          ) {\n            const { type } = this.state;\n            if (type === tt._function) {\n              this.resetPreviousNodeTrailingComments(id);\n              this.next();\n              return this.parseAsyncFunctionExpression(\n                this.startNodeAtNode(id),\n              );\n            } else if (tokenIsIdentifier(type)) {\n              // If the next token begins with \"=\", commit to parsing an async\n              // arrow function. (Peeking ahead for \"=\" lets us avoid a more\n              // expensive full-token lookahead on this common path.)\n              if (this.lookaheadCharCode() === charCodes.equalsTo) {\n                // although `id` is not used in async arrow unary function,\n                // we don't need to reset `async`'s trailing comments because\n                // it will be attached to the upcoming async arrow binding identifier\n                return this.parseAsyncArrowUnaryFunction(\n                  this.startNodeAtNode(id),\n                );\n              } else {\n                // Otherwise, treat \"async\" as an identifier and let calling code\n                // deal with the current tt.name token.\n                return id;\n              }\n            } else if (type === tt._do) {\n              this.resetPreviousNodeTrailingComments(id);\n              return this.parseDo(this.startNodeAtNode(id), true);\n            }\n          }\n\n          if (\n            canBeArrow &&\n            this.match(tt.arrow) &&\n            !this.canInsertSemicolon()\n          ) {\n            this.next();\n            return this.parseArrowExpression(\n              this.startNodeAtNode(id),\n              [id],\n              false,\n            );\n          }\n\n          return id;\n        } else {\n          this.unexpected();\n        }\n    }\n  }\n\n  // This helper method should only be called\n  // when the parser has reached a potential Hack pipe topic token\n  // that is followed by an equals sign.\n  // See <https://github.com/js-choi/proposal-hack-pipes>.\n  // If we find ^= or %= in an expression position\n  // (i.e., the tt.moduloAssign or tt.xorAssign token types), and if the\n  // Hack-pipes proposal is active with ^ or % as its topicToken, then the ^ or\n  // % could be the topic token (e.g., in x |> ^==y or x |> ^===y), and so we\n  // reparse the current token as ^ or %.\n  // Otherwise, this throws an unexpected-token error.\n  parseTopicReferenceThenEqualsSign(\n    topicTokenType: TokenType,\n    topicTokenValue: string,\n  ): N.Expression {\n    const pipeProposal = this.getPluginOption(\"pipelineOperator\", \"proposal\");\n\n    if (pipeProposal) {\n      // Set the most-recent token to be a topic token\n      // given by the tokenType and tokenValue.\n      // Now the next readToken() call (in parseTopicReference)\n      // will consume that “topic token”.\n      this.state.type = topicTokenType;\n      this.state.value = topicTokenValue;\n      // Rewind the tokenizer to the end of the “topic token”, so that the\n      // following token starts at the equals sign after that topic token.\n      this.state.pos--;\n      this.state.end--;\n      // This is safe to do since the preceding character was either ^ or %, and\n      // thus not a newline.\n      this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);\n      // Now actually consume the topic token.\n      return this.parseTopicReference(pipeProposal);\n    } else {\n      this.unexpected();\n    }\n  }\n\n  // This helper method should only be called\n  // when the proposal-pipeline-operator plugin is active,\n  // and when the parser has reached a potential Hack pipe topic token.\n  // Although a pipe-operator proposal is assumed to be active,\n  // its configuration might not match the current token’s type.\n  // See <https://github.com/js-choi/proposal-hack-pipes>.\n  parseTopicReference(pipeProposal: string): N.Expression {\n    const node = this.startNode<N.TopicReference>();\n    const startLoc = this.state.startLoc;\n    const tokenType = this.state.type;\n\n    // Consume the current token.\n    this.next();\n\n    // If the pipe-operator plugin’s configuration matches the current token’s type,\n    // then this will return `node`, will have been finished as a topic reference.\n    // Otherwise, this will throw a `PipeTopicUnconfiguredToken` error.\n    return this.finishTopicReference(node, startLoc, pipeProposal, tokenType);\n  }\n\n  // This helper method attempts to finish the given `node`\n  // into a topic-reference node for the given `pipeProposal`.\n  // See <https://github.com/js-choi/proposal-hack-pipes>.\n  //\n  // The method assumes that any topic token was consumed before it was called.\n  //\n  // If the `pipelineOperator` plugin is active,\n  // and if the given `tokenType` matches the plugin’s configuration,\n  // then this method will return the finished `node`.\n  //\n  // If the `pipelineOperator` plugin is active,\n  // but if the given `tokenType` does not match the plugin’s configuration,\n  // then this method will throw a `PipeTopicUnconfiguredToken` error.\n  finishTopicReference<\n    T extends N.PipelinePrimaryTopicReference | N.TopicReference,\n  >(\n    node: Undone<T>,\n    startLoc: Position,\n    pipeProposal: string,\n    tokenType: TokenType,\n  ): T {\n    if (\n      this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)\n    ) {\n      // The token matches the plugin’s configuration.\n      // The token is therefore a topic reference.\n\n      if (process.env.BABEL_8_BREAKING || pipeProposal === \"hack\") {\n        if (!this.topicReferenceIsAllowedInCurrentContext()) {\n          this.raise(Errors.PipeTopicUnbound, startLoc);\n        }\n\n        // Register the topic reference so that its pipe body knows\n        // that its topic was used at least once.\n        this.registerTopicReference();\n\n        return this.finishNode(node, \"TopicReference\");\n      } else {\n        // pipeProposal is \"smart\"\n\n        if (!this.topicReferenceIsAllowedInCurrentContext()) {\n          this.raise(Errors.PrimaryTopicNotAllowed, startLoc);\n        }\n        this.registerTopicReference();\n        return this.finishNode(node, \"PipelinePrimaryTopicReference\");\n      }\n    } else {\n      // The token does not match the plugin’s configuration.\n      throw this.raise(Errors.PipeTopicUnconfiguredToken, startLoc, {\n        token: tokenLabelName(tokenType),\n      });\n    }\n  }\n\n  // This helper method tests whether the given token type\n  // matches the pipelineOperator parser plugin’s configuration.\n  // If the active pipe proposal is Hack style,\n  // and if the given token is the same as the plugin configuration’s `topicToken`,\n  // then this is a valid topic reference.\n  // If the active pipe proposal is smart mix,\n  // then the topic token must always be `#`.\n  // If the active pipe proposal is neither (e.g., \"minimal\"(Babel 7) or \"fsharp\"),\n  // then an error is thrown.\n  testTopicReferenceConfiguration(\n    pipeProposal: string,\n    startLoc: Position,\n    tokenType: TokenType,\n  ): boolean {\n    switch (pipeProposal) {\n      case \"hack\": {\n        return this.hasPlugin([\n          \"pipelineOperator\",\n          {\n            // @ts-expect-error token must have a label\n            topicToken: tokenLabelName(tokenType),\n          },\n        ]);\n      }\n      case \"smart\":\n        return tokenType === tt.hash;\n      default:\n        throw this.raise(Errors.PipeTopicRequiresHackPipes, startLoc);\n    }\n  }\n\n  // async [no LineTerminator here] AsyncArrowBindingIdentifier[?Yield] [no LineTerminator here] => AsyncConciseBody[?In]\n  parseAsyncArrowUnaryFunction(\n    this: Parser,\n    node: Undone<N.ArrowFunctionExpression>,\n  ): N.ArrowFunctionExpression {\n    // We don't need to push a new ParameterDeclarationScope here since we are sure\n    // 1) it is an async arrow, 2) no biding pattern is allowed in params\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(tt.arrow);\n    // let foo = async bar => {};\n    return this.parseArrowExpression(node, params, true);\n  }\n\n  // https://github.com/tc39/proposal-do-expressions\n  // https://github.com/tc39/proposal-async-do-expressions\n  parseDo(\n    this: Parser,\n    node: Undone<N.DoExpression>,\n    isAsync: boolean,\n  ): N.DoExpression {\n    this.expectPlugin(\"doExpressions\");\n    if (isAsync) {\n      this.expectPlugin(\"asyncDoExpressions\");\n    }\n    node.async = isAsync;\n    this.next(); // eat `do`\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n    if (isAsync) {\n      // AsyncDoExpression :\n      // async [no LineTerminator here] do Block[~Yield, +Await, ~Return]\n      this.prodParam.enter(ParamKind.PARAM_AWAIT);\n      node.body = this.parseBlock();\n      this.prodParam.exit();\n    } else {\n      node.body = this.parseBlock();\n    }\n\n    this.state.labels = oldLabels;\n    return this.finishNode(node, \"DoExpression\");\n  }\n\n  // Parse the `super` keyword\n  parseSuper(): N.Super {\n    const node = this.startNode<N.Super>();\n    this.next(); // eat `super`\n    if (\n      this.match(tt.parenL) &&\n      !this.scope.allowDirectSuper &&\n      !(this.optionFlags & OptionFlags.AllowSuperOutsideMethod)\n    ) {\n      this.raise(Errors.SuperNotAllowed, node);\n    } else if (\n      !this.scope.allowSuper &&\n      !(this.optionFlags & OptionFlags.AllowSuperOutsideMethod)\n    ) {\n      this.raise(Errors.UnexpectedSuper, node);\n    }\n\n    if (\n      !this.match(tt.parenL) &&\n      !this.match(tt.bracketL) &&\n      !this.match(tt.dot)\n    ) {\n      this.raise(Errors.UnsupportedSuper, node);\n    }\n\n    return this.finishNode(node, \"Super\");\n  }\n\n  parsePrivateName(): N.PrivateName {\n    const node = this.startNode<N.PrivateName>();\n    const id = this.startNodeAt<N.Identifier>(\n      // The position is hardcoded because we merge `#` and name into a single\n      // tt.privateName token\n      createPositionWithColumnOffset(this.state.startLoc, 1),\n    );\n    const name = this.state.value;\n    this.next(); // eat #name;\n    node.id = this.createIdentifier(id, name);\n    return this.finishNode(node, \"PrivateName\");\n  }\n\n  parseFunctionOrFunctionSent(\n    this: Parser,\n  ): N.FunctionExpression | N.MetaProperty {\n    const node = this.startNode<N.FunctionExpression | N.MetaProperty>();\n\n    // We do not do parseIdentifier here because when parseFunctionOrFunctionSent\n    // is called we already know that the current token is a \"name\" with the value \"function\"\n    // This will improve perf a tiny little bit as we do not do validation but more importantly\n    // here is that parseIdentifier will remove an item from the expression stack\n    // if \"function\" or \"class\" is parsed as identifier (in objects e.g.), which should not happen here.\n    this.next(); // eat `function`\n\n    if (this.prodParam.hasYield && this.match(tt.dot)) {\n      const meta = this.createIdentifier(\n        this.startNodeAtNode<N.Identifier>(node),\n        \"function\",\n      );\n      this.next(); // eat `.`\n      // https://github.com/tc39/proposal-function.sent#syntax-1\n      if (this.match(tt._sent)) {\n        this.expectPlugin(\"functionSent\");\n      } else if (!this.hasPlugin(\"functionSent\")) {\n        // The code wasn't `function.sent` but just `function.`, so a simple error is less confusing.\n        this.unexpected();\n      }\n      return this.parseMetaProperty(\n        node as Undone<N.MetaProperty>,\n        meta,\n        \"sent\",\n      );\n    }\n    return this.parseFunction(node as Undone<N.FunctionExpression>);\n  }\n\n  parseMetaProperty(\n    node: Undone<N.MetaProperty>,\n    meta: N.Identifier,\n    propertyName: string,\n  ): N.MetaProperty {\n    node.meta = meta;\n\n    const containsEsc = this.state.containsEsc;\n\n    node.property = this.parseIdentifier(true);\n\n    if (node.property.name !== propertyName || containsEsc) {\n      this.raise(Errors.UnsupportedMetaProperty, node.property, {\n        target: meta.name,\n        onlyValidPropertyName: propertyName,\n      });\n    }\n\n    return this.finishNode(node, \"MetaProperty\");\n  }\n\n  // https://tc39.es/ecma262/#prod-ImportMeta\n  parseImportMetaProperty(\n    this: Parser,\n    node: Undone<N.MetaProperty | N.ImportExpression>,\n  ): N.MetaProperty | N.ImportExpression {\n    const id = this.createIdentifier(\n      this.startNodeAtNode<N.Identifier>(node),\n      \"import\",\n    );\n    this.next(); // eat `.`\n\n    if (this.isContextual(tt._meta)) {\n      if (!this.inModule) {\n        this.raise(Errors.ImportMetaOutsideModule, id);\n      }\n      this.sawUnambiguousESM = true;\n    } else if (this.isContextual(tt._source) || this.isContextual(tt._defer)) {\n      const isSource = this.isContextual(tt._source);\n\n      this.expectPlugin(\n        isSource ? \"sourcePhaseImports\" : \"deferredImportEvaluation\",\n      );\n      if (!(this.optionFlags & OptionFlags.CreateImportExpressions)) {\n        throw this.raise(\n          Errors.DynamicImportPhaseRequiresImportExpressions,\n          this.state.startLoc,\n          {\n            phase: this.state.value,\n          },\n        );\n      }\n      this.next();\n      (node as Undone<N.ImportExpression>).phase = isSource\n        ? \"source\"\n        : \"defer\";\n      return this.parseImportCall(node as Undone<N.ImportExpression>);\n    }\n\n    return this.parseMetaProperty(node as Undone<N.MetaProperty>, id, \"meta\");\n  }\n\n  parseLiteralAtNode<T extends N.Node>(\n    value: any,\n    type: T[\"type\"],\n    node: any,\n  ): T {\n    this.addExtra(node, \"rawValue\", value);\n    this.addExtra(\n      node,\n      \"raw\",\n      this.input.slice(this.offsetToSourcePos(node.start), this.state.end),\n    );\n    node.value = value;\n    this.next();\n    return this.finishNode<T>(node, type);\n  }\n\n  parseLiteral<T extends N.Node>(value: any, type: T[\"type\"]): T {\n    const node = this.startNode();\n    return this.parseLiteralAtNode(value, type, node);\n  }\n\n  parseStringLiteral(value: any) {\n    return this.parseLiteral<N.StringLiteral>(value, \"StringLiteral\");\n  }\n\n  parseNumericLiteral(value: any) {\n    return this.parseLiteral<N.NumericLiteral>(value, \"NumericLiteral\");\n  }\n\n  parseBigIntLiteral(value: any) {\n    return this.parseLiteral<N.BigIntLiteral>(value, \"BigIntLiteral\");\n  }\n\n  // TODO: Remove this in Babel 8\n  parseDecimalLiteral(value: any) {\n    return this.parseLiteral<N.DecimalLiteral>(value, \"DecimalLiteral\");\n  }\n\n  parseRegExpLiteral(value: {\n    value: any;\n    pattern: string;\n    flags: N.RegExpLiteral[\"flags\"];\n  }) {\n    const node = this.startNode<N.RegExpLiteral>();\n    this.addExtra(\n      node,\n      \"raw\",\n      this.input.slice(this.offsetToSourcePos(node.start), this.state.end),\n    );\n    node.pattern = value.pattern;\n    node.flags = value.flags;\n    this.next();\n    return this.finishNode(node, \"RegExpLiteral\");\n  }\n\n  parseBooleanLiteral(value: boolean) {\n    const node = this.startNode<N.BooleanLiteral>();\n    node.value = value;\n    this.next();\n    return this.finishNode(node, \"BooleanLiteral\");\n  }\n\n  parseNullLiteral() {\n    const node = this.startNode<N.NullLiteral>();\n    this.next();\n    return this.finishNode(node, \"NullLiteral\");\n  }\n\n  // https://tc39.es/ecma262/#prod-CoverParenthesizedExpressionAndArrowParameterList\n  parseParenAndDistinguishExpression(\n    this: Parser,\n    canBeArrow: boolean,\n  ): N.Expression {\n    const startLoc = this.state.startLoc;\n\n    let val;\n    this.next(); // eat `(`\n    this.expressionScope.enter(newArrowHeadScope());\n\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.maybeInArrowParameters = true;\n    this.state.inFSharpPipelineDirectBody = false;\n\n    const innerStartLoc = this.state.startLoc;\n    const exprList: (N.Expression | N.RestElement)[] = [];\n    const refExpressionErrors = new ExpressionErrors();\n    let first = true;\n    let spreadStartLoc;\n    let optionalCommaStartLoc;\n\n    while (!this.match(tt.parenR)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(\n          tt.comma,\n          refExpressionErrors.optionalParametersLoc === null\n            ? null\n            : refExpressionErrors.optionalParametersLoc,\n        );\n        if (this.match(tt.parenR)) {\n          optionalCommaStartLoc = this.state.startLoc;\n          break;\n        }\n      }\n\n      if (this.match(tt.ellipsis)) {\n        const spreadNodeStartLoc = this.state.startLoc;\n        spreadStartLoc = this.state.startLoc;\n        exprList.push(\n          this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc),\n        );\n\n        if (!this.checkCommaAfterRest(charCodes.rightParenthesis)) {\n          break;\n        }\n      } else {\n        exprList.push(\n          this.parseMaybeAssignAllowIn(\n            refExpressionErrors,\n            this.parseParenItem,\n          ),\n        );\n      }\n    }\n\n    const innerEndLoc = this.state.lastTokEndLoc;\n    this.expect(tt.parenR);\n\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n\n    let arrowNode = this.startNodeAt<N.ArrowFunctionExpression>(startLoc);\n    if (\n      canBeArrow &&\n      this.shouldParseArrow(exprList) &&\n      (arrowNode = this.parseArrow(arrowNode))\n    ) {\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.expressionScope.validateAsPattern();\n      this.expressionScope.exit();\n      this.parseArrowExpression(arrowNode, exprList, false);\n      // @ts-expect-error todo(flow->ts) improve node types\n      return arrowNode;\n    }\n    this.expressionScope.exit();\n\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\n    this.toReferencedListDeep(exprList, /* isParenthesizedExpr */ true);\n    if (exprList.length > 1) {\n      val = this.startNodeAt<N.SequenceExpression>(innerStartLoc);\n      val.expressions = exprList as N.Expression[];\n      // finish node at current location so it can pick up comments after `)`\n      this.finishNode(val, \"SequenceExpression\");\n      this.resetEndLocation(val, innerEndLoc);\n    } else {\n      val = exprList[0];\n    }\n\n    return this.wrapParenthesis(\n      startLoc,\n      // @ts-expect-error todo(flow->ts)\n      val,\n    );\n  }\n\n  wrapParenthesis(startLoc: Position, expression: N.Expression): N.Expression {\n    if (!(this.optionFlags & OptionFlags.CreateParenthesizedExpressions)) {\n      this.addExtra(expression, \"parenthesized\", true);\n      this.addExtra(expression, \"parenStart\", startLoc.index);\n\n      this.takeSurroundingComments(\n        expression,\n        startLoc.index,\n        this.state.lastTokEndLoc.index,\n      );\n\n      return expression;\n    }\n\n    const parenExpression =\n      this.startNodeAt<N.ParenthesizedExpression>(startLoc);\n    parenExpression.expression = expression;\n    return this.finishNode(parenExpression, \"ParenthesizedExpression\");\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- `params` is used in typescript plugin\n  shouldParseArrow(params: Array<N.Node>): boolean {\n    return !this.canInsertSemicolon();\n  }\n\n  parseArrow(\n    node: Undone<N.ArrowFunctionExpression>,\n  ): Undone<N.ArrowFunctionExpression> | undefined {\n    if (this.eat(tt.arrow)) {\n      return node;\n    }\n  }\n\n  parseParenItem<T extends N.Expression | N.RestElement | N.SpreadElement>(\n    node: T,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    startLoc: Position,\n  ): T | N.TypeCastExpression | N.TsTypeCastExpression {\n    return node;\n  }\n\n  parseNewOrNewTarget(this: Parser): N.NewExpression | N.MetaProperty {\n    const node = this.startNode<N.NewExpression | N.MetaProperty>();\n    this.next();\n    if (this.match(tt.dot)) {\n      // https://tc39.es/ecma262/#prod-NewTarget\n      const meta = this.createIdentifier(\n        this.startNodeAtNode<N.Identifier>(node),\n        \"new\",\n      );\n      this.next();\n      const metaProp = this.parseMetaProperty(\n        node as Undone<N.MetaProperty>,\n        meta,\n        \"target\",\n      );\n\n      if (\n        !this.scope.inNonArrowFunction &&\n        !this.scope.inClass &&\n        !(this.optionFlags & OptionFlags.AllowNewTargetOutsideFunction)\n      ) {\n        this.raise(Errors.UnexpectedNewTarget, metaProp);\n      }\n\n      return metaProp;\n    }\n\n    return this.parseNew(node as Undone<N.NewExpression>);\n  }\n\n  // New's precedence is slightly tricky. It must allow its argument to\n  // be a `[]` or dot subscript expression, but not a call — at least,\n  // not without wrapping it in parentheses. Thus, it uses the noCalls\n  // argument to parseSubscripts to prevent it from consuming the\n  // argument list.\n  // https://tc39.es/ecma262/#prod-NewExpression\n  parseNew(this: Parser, node: Undone<N.NewExpression>): N.NewExpression {\n    this.parseNewCallee(node);\n\n    if (this.eat(tt.parenL)) {\n      const args = this.parseExprList(tt.parenR);\n      this.toReferencedList(args);\n      // (parseExprList should be all non-null in this case)\n      node.arguments = args;\n    } else {\n      node.arguments = [];\n    }\n\n    return this.finishNode(node, \"NewExpression\");\n  }\n\n  parseNewCallee(this: Parser, node: Undone<N.NewExpression>): void {\n    const isImport = this.match(tt._import);\n    const callee = this.parseNoCallExpr();\n    node.callee = callee;\n    if (\n      isImport &&\n      (callee.type === \"Import\" || callee.type === \"ImportExpression\")\n    ) {\n      this.raise(Errors.ImportCallNotNewExpression, callee);\n    }\n  }\n\n  // Parse template expression.\n\n  parseTemplateElement(isTagged: boolean): N.TemplateElement {\n    const { start, startLoc, end, value } = this.state;\n    const elemStart = start + 1;\n    const elem = this.startNodeAt<N.TemplateElement>(\n      createPositionWithColumnOffset(startLoc, 1),\n    );\n    if (value === null) {\n      if (!isTagged) {\n        this.raise(\n          Errors.InvalidEscapeSequenceTemplate,\n          // FIXME: Adding 1 is probably wrong.\n          createPositionWithColumnOffset(\n            this.state.firstInvalidTemplateEscapePos,\n            1,\n          ),\n        );\n      }\n    }\n\n    const isTail = this.match(tt.templateTail);\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(\n      finishedNode,\n      createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset),\n    );\n    return finishedNode;\n  }\n\n  // https://tc39.es/ecma262/#prod-TemplateLiteral\n  parseTemplate(this: Parser, isTagged: boolean): N.TemplateLiteral {\n    const node = this.startNode<N.TemplateLiteral>();\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    // Type cast from (N.Expression[] | N.TsType[]). parseTemplateSubstitution\n    // returns consistent results.\n    node.expressions = substitutions as N.Expression[] | N.TsType[];\n    node.quasis = quasis;\n    return this.finishNode(node, \"TemplateLiteral\");\n  }\n\n  // This is overwritten by the TypeScript plugin to parse template types\n  parseTemplateSubstitution(this: Parser): N.Expression | N.TsType {\n    return this.parseExpression();\n  }\n\n  // Parse an object literal, binding pattern, or record.\n\n  parseObjectLike(\n    close: TokenType,\n    isPattern: true,\n    isRecord?: boolean | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectPattern;\n  parseObjectLike(\n    close: TokenType,\n    isPattern: false,\n    isRecord?: false | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectExpression;\n  parseObjectLike(\n    close: TokenType,\n    isPattern: false,\n    isRecord?: true,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.RecordExpression;\n  parseObjectLike<T extends N.ObjectPattern | N.ObjectExpression>(\n    this: Parser,\n    close: TokenType,\n    isPattern: boolean,\n    isRecord?: boolean | null,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): T {\n    if (isRecord) {\n      this.expectPlugin(\"recordAndTuple\");\n    }\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = false;\n    const propHash: any = Object.create(null);\n    let first = true;\n    const node = this.startNode<\n      N.ObjectExpression | N.ObjectPattern | N.RecordExpression\n    >();\n\n    node.properties = [];\n    this.next();\n\n    while (!this.match(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.match(close)) {\n          this.addTrailingCommaExtraToNode(node);\n          break;\n        }\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\n      if (\n        isRecord &&\n        !this.isObjectProperty(prop) &&\n        prop.type !== \"SpreadElement\"\n      ) {\n        this.raise(Errors.InvalidRecordProperty, prop);\n      }\n\n      if (!process.env.BABEL_8_BREAKING) {\n        // @ts-expect-error shorthand may not index prop\n        if (prop.shorthand) {\n          this.addExtra(prop, \"shorthand\", true);\n        }\n      }\n\n      // @ts-expect-error Fixme: refine typings\n      node.properties.push(prop);\n    }\n\n    this.next();\n\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    let type = \"ObjectExpression\";\n    if (isPattern) {\n      type = \"ObjectPattern\";\n    } else if (isRecord) {\n      type = \"RecordExpression\";\n    }\n    // @ts-expect-error type is well defined\n    return this.finishNode(node, type);\n  }\n\n  addTrailingCommaExtraToNode(node: Undone<N.Node>): void {\n    this.addExtra(node, \"trailingComma\", this.state.lastTokStartLoc.index);\n    this.addExtra(node, \"trailingCommaLoc\", this.state.lastTokStartLoc, false);\n  }\n\n  // Check grammar production:\n  //   IdentifierName *_opt PropertyName\n  // It is used in `parsePropertyDefinition` to detect AsyncMethod and Accessors\n  maybeAsyncOrAccessorProp(\n    prop: Undone<N.ObjectProperty>,\n  ): prop is typeof prop & { key: N.Identifier } {\n    return (\n      !prop.computed &&\n      prop.key.type === \"Identifier\" &&\n      (this.isLiteralPropertyName() ||\n        this.match(tt.bracketL) ||\n        this.match(tt.star))\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-PropertyDefinition\n  parsePropertyDefinition(\n    this: Parser,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectMember | N.SpreadElement {\n    let decorators = [];\n    if (this.match(tt.at)) {\n      if (this.hasPlugin(\"decorators\")) {\n        this.raise(Errors.UnsupportedPropertyDecorator, this.state.startLoc);\n      }\n\n      // we needn't check if decorators (stage 0) plugin is enabled since it's checked by\n      // the call to this.parseDecorator\n      while (this.match(tt.at)) {\n        decorators.push(this.parseDecorator());\n      }\n    }\n\n    const prop = this.startNode<N.ObjectProperty>();\n    let isAsync = false;\n    let isAccessor = false;\n    let startLoc;\n\n    if (this.match(tt.ellipsis)) {\n      if (decorators.length) this.unexpected();\n      return this.parseSpread();\n    }\n\n    if (decorators.length) {\n      prop.decorators = decorators;\n      decorators = [];\n    }\n\n    prop.method = false;\n\n    if (refExpressionErrors) {\n      startLoc = this.state.startLoc;\n    }\n\n    let isGenerator = this.eat(tt.star);\n    this.parsePropertyNamePrefixOperator(prop);\n    const containsEsc = this.state.containsEsc;\n    this.parsePropertyName(prop, refExpressionErrors);\n\n    if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {\n      const { key } = prop;\n      const keyName = key.name;\n      // https://tc39.es/ecma262/#prod-AsyncMethod\n      // https://tc39.es/ecma262/#prod-AsyncGeneratorMethod\n      if (keyName === \"async\" && !this.hasPrecedingLineBreak()) {\n        isAsync = true;\n        this.resetPreviousNodeTrailingComments(key);\n        isGenerator = this.eat(tt.star);\n        this.parsePropertyName(prop);\n      }\n      // get PropertyName[?Yield, ?Await] () { FunctionBody[~Yield, ~Await] }\n      // set PropertyName[?Yield, ?Await] ( PropertySetParameterList ) { FunctionBody[~Yield, ~Await] }\n      if (keyName === \"get\" || keyName === \"set\") {\n        isAccessor = true;\n        this.resetPreviousNodeTrailingComments(key);\n        prop.kind = keyName;\n        if (this.match(tt.star)) {\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\n    return this.parseObjPropValue(\n      prop,\n      startLoc,\n      isGenerator,\n      isAsync,\n      false /* isPattern */,\n      isAccessor,\n      refExpressionErrors,\n    );\n  }\n\n  getGetterSetterExpectedParamCount(\n    method: N.ObjectMethod | N.ClassMethod,\n  ): number {\n    return method.kind === \"get\" ? 0 : 1;\n  }\n\n  // This exists so we can override within the ESTree plugin\n  getObjectOrClassMethodParams(method: N.ObjectMethod | N.ClassMethod) {\n    return method.params;\n  }\n\n  // get methods aren't allowed to have any parameters\n  // set methods must have exactly 1 parameter which is not a rest parameter\n  checkGetterSetterParams(method: N.ObjectMethod | N.ClassMethod): void {\n    const paramCount = this.getGetterSetterExpectedParamCount(method);\n    const params = this.getObjectOrClassMethodParams(method);\n\n    if (params.length !== paramCount) {\n      this.raise(\n        method.kind === \"get\" ? Errors.BadGetterArity : Errors.BadSetterArity,\n        method,\n      );\n    }\n\n    if (\n      method.kind === \"set\" &&\n      params[params.length - 1]?.type === \"RestElement\"\n    ) {\n      this.raise(Errors.BadSetterRestParameter, method);\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-MethodDefinition\n  parseObjectMethod(\n    this: Parser,\n    prop: Undone<N.ObjectMethod>,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isPattern: boolean,\n    isAccessor: boolean,\n  ): N.ObjectMethod | undefined | null {\n    if (isAccessor) {\n      // isAccessor implies isAsync: false, isPattern: false, isGenerator: false\n      const finishedProp = this.parseMethod(\n        prop,\n        // This _should_ be false, but with error recovery, we allow it to be\n        // set for informational purposes\n        isGenerator,\n        /* isAsync */ false,\n        /* isConstructor */ false,\n        false,\n        \"ObjectMethod\",\n      );\n      this.checkGetterSetterParams(finishedProp);\n      return finishedProp;\n    }\n\n    if (isAsync || isGenerator || this.match(tt.parenL)) {\n      if (isPattern) this.unexpected();\n      prop.kind = \"method\";\n      prop.method = true;\n      return this.parseMethod(\n        prop,\n        isGenerator,\n        isAsync,\n        /* isConstructor */ false,\n        false,\n        \"ObjectMethod\",\n      );\n    }\n  }\n\n  // if `isPattern` is true, parse https://tc39.es/ecma262/#prod-BindingProperty\n  // else https://tc39.es/ecma262/#prod-PropertyDefinition\n  parseObjectProperty(\n    this: Parser,\n    prop: Undone<N.ObjectProperty>,\n    startLoc: Position | undefined | null,\n    isPattern: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ObjectProperty | undefined | null {\n    prop.shorthand = false;\n\n    if (this.eat(tt.colon)) {\n      prop.value = isPattern\n        ? this.parseMaybeDefault(this.state.startLoc)\n        : this.parseMaybeAssignAllowIn(refExpressionErrors);\n\n      return this.finishNode(prop, \"ObjectProperty\");\n    }\n\n    if (!prop.computed && prop.key.type === \"Identifier\") {\n      // PropertyDefinition:\n      //   IdentifierReference\n      //   CoverInitializedName\n      // Note: `{ eval } = {}` will be checked in `checkLVal` later.\n      this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);\n\n      if (isPattern) {\n        prop.value = this.parseMaybeDefault(\n          startLoc,\n          cloneIdentifier(prop.key),\n        );\n      } else if (this.match(tt.eq)) {\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(\n          startLoc,\n          cloneIdentifier(prop.key),\n        );\n      } else {\n        prop.value = cloneIdentifier(prop.key);\n      }\n      prop.shorthand = true;\n\n      return this.finishNode(prop, \"ObjectProperty\");\n    }\n  }\n\n  parseObjPropValue<T extends N.ObjectMember>(\n    this: Parser,\n    prop: Undone<T>,\n    startLoc: Position | undefined | null,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isPattern: boolean,\n    isAccessor: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): T {\n    const node = (this.parseObjectMethod(\n      prop as Undone<N.ObjectMethod>,\n      isGenerator,\n      isAsync,\n      isPattern,\n      isAccessor,\n    ) ||\n      this.parseObjectProperty(\n        prop as Undone<N.ObjectProperty>,\n        startLoc,\n        isPattern,\n        refExpressionErrors,\n      )) as T;\n\n    if (!node) this.unexpected();\n\n    return node;\n  }\n\n  // https://tc39.es/ecma262/#prod-PropertyName\n  // when refExpressionErrors presents, it will parse private name\n  // and record the position of the first private name\n  parsePropertyName(\n    this: Parser,\n    prop:\n      | Undone<N.ObjectOrClassMember | N.ClassMember>\n      | N.TsNamedTypeElementBase,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): void {\n    if (this.eat(tt.bracketL)) {\n      (prop as Undone<N.ObjectOrClassMember>).computed = true;\n      prop.key = this.parseMaybeAssignAllowIn();\n      this.expect(tt.bracketR);\n    } else {\n      // We check if it's valid for it to be a private name when we push it.\n      const { type, value } = this.state;\n      let key;\n      // most un-computed property names are identifiers\n      if (tokenIsKeywordOrIdentifier(type)) {\n        key = this.parseIdentifier(true);\n      } else {\n        switch (type) {\n          case tt.num:\n            key = this.parseNumericLiteral(value);\n            break;\n          case tt.string:\n            key = this.parseStringLiteral(value);\n            break;\n          case tt.bigint:\n            key = this.parseBigIntLiteral(value);\n            break;\n          case tt.privateName: {\n            // the class private key has been handled in parseClassElementName\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            if (!process.env.BABEL_8_BREAKING && type === tt.decimal) {\n              key = this.parseDecimalLiteral(value);\n              break;\n            }\n\n            this.unexpected();\n        }\n      }\n      (prop as any).key = key;\n      if (type !== tt.privateName) {\n        // ClassPrivateProperty is never computed, so we don't assign in that case.\n        prop.computed = false;\n      }\n    }\n  }\n\n  // Initialize empty function node.\n\n  initFunction(node: N.BodilessFunctionOrMethodBase, isAsync: boolean): void {\n    node.id = null;\n    node.generator = false;\n    node.async = isAsync;\n  }\n\n  // Parse object or class method.\n\n  parseMethod<T extends N.ObjectMethod | N.ClassMethod | N.ClassPrivateMethod>(\n    this: Parser,\n    node: Undone<T>,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isConstructor: boolean,\n    allowDirectSuper: boolean,\n    type: T[\"type\"],\n    inClassScope: boolean = false,\n  ): T {\n    this.initFunction(node, isAsync);\n    node.generator = isGenerator;\n    this.scope.enter(\n      ScopeFlag.FUNCTION |\n        ScopeFlag.SUPER |\n        (inClassScope ? ScopeFlag.CLASS : 0) |\n        (allowDirectSuper ? ScopeFlag.DIRECT_SUPER : 0),\n    );\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\n    return finishedNode;\n  }\n\n  // parse an array literal or tuple literal\n  // https://tc39.es/ecma262/#prod-ArrayLiteral\n  // https://tc39.es/proposal-record-tuple/#prod-TupleLiteral\n  parseArrayLike(\n    this: Parser,\n    close: TokenType,\n    canBePattern: boolean,\n    isTuple: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n  ): N.ArrayExpression | N.TupleExpression {\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.ArrayExpression | N.TupleExpression>();\n    this.next();\n    node.elements = this.parseExprList(\n      close,\n      /* allowEmpty */ !isTuple,\n      refExpressionErrors,\n      // @ts-expect-error todo(flow->ts)\n      node,\n    );\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n    return this.finishNode(\n      node,\n      isTuple ? \"TupleExpression\" : \"ArrayExpression\",\n    );\n  }\n\n  // Parse arrow function expression.\n  // If the parameters are provided, they will be converted to an\n  // assignable list.\n  parseArrowExpression(\n    this: Parser,\n    node: Undone<N.ArrowFunctionExpression>,\n    params:\n      | Array<N.Expression | N.SpreadElement>\n      | Array<N.Expression | N.RestElement>,\n    isAsync: boolean,\n    trailingCommaLoc?: Position | null,\n  ): N.ArrowFunctionExpression {\n    this.scope.enter(ScopeFlag.FUNCTION | ScopeFlag.ARROW);\n    let flags = functionFlags(isAsync, false);\n    // ConciseBody[In] :\n    //   [lookahead ≠ {] ExpressionBody[?In, ~Await]\n    //   { FunctionBody[~Yield, ~Await] }\n    if (!this.match(tt.braceL) && this.prodParam.hasIn) {\n      flags |= ParamKind.PARAM_IN;\n    }\n    this.prodParam.enter(flags);\n    this.initFunction(node, isAsync);\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n\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\n    this.prodParam.exit();\n    this.scope.exit();\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n\n    return this.finishNode(node, \"ArrowFunctionExpression\");\n  }\n\n  setArrowFunctionParameters(\n    node: Undone<N.ArrowFunctionExpression>,\n    params:\n      | Array<N.Expression | N.SpreadElement>\n      | Array<N.Expression | N.RestElement>,\n    trailingCommaLoc?: Position | null,\n  ): void {\n    this.toAssignableList(params, trailingCommaLoc, false);\n    node.params = params as (N.Pattern | N.TSParameterProperty)[];\n  }\n\n  parseFunctionBodyAndFinish<\n    T extends\n      | N.Function\n      | N.TSDeclareMethod\n      | N.TSDeclareFunction\n      | N.ClassPrivateMethod,\n  >(node: Undone<T>, type: T[\"type\"], isMethod: boolean = false): T {\n    // @ts-expect-error (node is not bodiless if we get here)\n    this.parseFunctionBody(node, false, isMethod);\n    return this.finishNode(node, type);\n  }\n\n  // Parse function body and check parameters.\n  parseFunctionBody(\n    this: Parser,\n    node: Undone<N.Function>,\n    allowExpression?: boolean | null,\n    isMethod: boolean = false,\n  ): void {\n    const isExpression = allowExpression && !this.match(tt.braceL);\n    this.expressionScope.enter(newExpressionScope());\n\n    if (isExpression) {\n      // https://tc39.es/ecma262/#prod-ExpressionBody\n      (node as Undone<N.ArrowFunctionExpression>).body =\n        this.parseMaybeAssign();\n      this.checkParams(node, false, allowExpression, false);\n    } else {\n      const oldStrict = this.state.strict;\n      // Start a new scope with regard to labels\n      // flag (restore them to their old value afterwards).\n      const oldLabels = this.state.labels;\n      this.state.labels = [];\n\n      // FunctionBody[Yield, Await]:\n      //   StatementList[?Yield, ?Await, +Return] opt\n      this.prodParam.enter(\n        this.prodParam.currentFlags() | ParamKind.PARAM_RETURN,\n      );\n      node.body = this.parseBlock(\n        true,\n        false,\n        // Strict mode function checks after we parse the statements in the function body.\n        (hasStrictModeDirective: boolean) => {\n          const nonSimple = !this.isSimpleParamList(node.params);\n\n          if (hasStrictModeDirective && nonSimple) {\n            // This logic is here to align the error location with the ESTree plugin.\n            this.raise(\n              Errors.IllegalLanguageModeDirective,\n              // @ts-expect-error kind may not index node\n              (node.kind === \"method\" || node.kind === \"constructor\") &&\n                // @ts-expect-error key may not index node\n                !!node.key\n                ? // @ts-expect-error node.key has been guarded\n                  node.key.loc.end\n                : node,\n            );\n          }\n\n          const strictModeChanged = !oldStrict && this.state.strict;\n\n          // Add the params to varDeclaredNames to ensure that an error is thrown\n          // if a let/const declaration in the function clashes with one of the params.\n          this.checkParams(\n            node,\n            !this.state.strict && !allowExpression && !isMethod && !nonSimple,\n            allowExpression,\n            strictModeChanged,\n          );\n\n          // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'\n          if (this.state.strict && node.id) {\n            this.checkIdentifier(\n              node.id,\n              BindingFlag.TYPE_OUTSIDE,\n              strictModeChanged,\n            );\n          }\n        },\n      );\n      this.prodParam.exit();\n      this.state.labels = oldLabels;\n    }\n    this.expressionScope.exit();\n  }\n\n  isSimpleParameter(node: N.Pattern | N.TSParameterProperty): boolean {\n    return node.type === \"Identifier\";\n  }\n\n  isSimpleParamList(\n    params: ReadonlyArray<N.Pattern | N.TSParameterProperty>,\n  ): boolean {\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\n  checkParams(\n    node: Undone<N.Function>,\n    allowDuplicates: boolean,\n    isArrowFunction?: boolean | null,\n    strictModeChanged: boolean = true,\n  ): void {\n    const checkClashes = !allowDuplicates && new Set<string>();\n    // We create a fake node with the \"ephemeral\" type `FormalParameters`[1]\n    // since we just store an array of parameters. Perhaps someday we can have\n    // something like class FormalParameters extends Array { ... }, which would\n    // also be helpful when traversing this node.\n    //\n    // 1. https://tc39.es/ecma262/#prod-FormalParameters\n    const formalParameters = { type: \"FormalParameters\" } as const;\n    for (const param of node.params) {\n      this.checkLVal(\n        param,\n        formalParameters,\n        BindingFlag.TYPE_VAR,\n        checkClashes,\n        strictModeChanged,\n      );\n    }\n  }\n\n  // Parses a comma-separated list of expressions, and returns them as\n  // an array. `close` is the token type that ends the list, and\n  // `allowEmpty` can be turned on to allow subsequent commas with\n  // nothing in between them to be parsed as `null` (which is needed\n  // for array literals).\n\n  parseExprList(\n    this: Parser,\n    close: TokenType,\n    allowEmpty?: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n    nodeForExtra?: N.Node | null,\n  ): (N.Expression | null)[] {\n    const elts: (N.Expression | null)[] = [];\n    let first = true;\n\n    while (!this.eat(close)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.match(close)) {\n          if (nodeForExtra) {\n            this.addTrailingCommaExtraToNode(nodeForExtra);\n          }\n          this.next();\n          break;\n        }\n      }\n\n      elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));\n    }\n    return elts;\n  }\n\n  parseExprListItem(\n    this: Parser,\n    allowEmpty?: boolean,\n    refExpressionErrors?: ExpressionErrors | null,\n    allowPlaceholder?: boolean | null,\n  ): N.Expression | null;\n  parseExprListItem(\n    this: Parser,\n    allowEmpty?: false,\n    refExpressionErrors?: ExpressionErrors | null,\n    allowPlaceholder?: boolean | null,\n  ): N.Expression;\n  parseExprListItem(\n    this: Parser,\n    allowEmpty?: boolean | null,\n    refExpressionErrors?: ExpressionErrors | null,\n    allowPlaceholder?: boolean | null,\n  ): N.Expression | N.SpreadElement | N.ArgumentPlaceholder | null {\n    let elt;\n    if (this.match(tt.comma)) {\n      if (!allowEmpty) {\n        this.raise(Errors.UnexpectedToken, this.state.curPosition(), {\n          unexpected: \",\",\n        });\n      }\n      elt = null;\n    } else if (this.match(tt.ellipsis)) {\n      const spreadNodeStartLoc = this.state.startLoc;\n\n      elt = this.parseParenItem(\n        this.parseSpread(refExpressionErrors),\n        spreadNodeStartLoc,\n      );\n    } else if (this.match(tt.question)) {\n      this.expectPlugin(\"partialApplication\");\n      if (!allowPlaceholder) {\n        this.raise(Errors.UnexpectedArgumentPlaceholder, this.state.startLoc);\n      }\n      const node = this.startNode<N.ArgumentPlaceholder>();\n      this.next();\n      elt = this.finishNode(node, \"ArgumentPlaceholder\");\n    } else {\n      elt = this.parseMaybeAssignAllowIn(\n        refExpressionErrors,\n        this.parseParenItem,\n      );\n    }\n    return elt;\n  }\n\n  // Parse the next token as an identifier. If `liberal` is true (used\n  // when parsing properties), it will also convert keywords into\n  // identifiers.\n  // This shouldn't be used to parse the keywords of meta properties, since they\n  // are not identifiers and cannot contain escape sequences.\n\n  parseIdentifier(liberal?: boolean): N.Identifier {\n    const node = this.startNode<N.Identifier>();\n    const name = this.parseIdentifierName(liberal);\n\n    return this.createIdentifier(node, name);\n  }\n\n  createIdentifier(\n    node: Omit<N.Identifier, \"type\">,\n    name: string,\n  ): N.Identifier {\n    node.name = name;\n    node.loc.identifierName = name;\n\n    return this.finishNode(node, \"Identifier\");\n  }\n\n  parseIdentifierName(liberal?: boolean): string {\n    let name: string;\n\n    const { startLoc, type } = this.state;\n\n    if (tokenIsKeywordOrIdentifier(type)) {\n      name = this.state.value;\n    } else {\n      this.unexpected();\n    }\n\n    const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);\n\n    if (liberal) {\n      // If the current token is not used as a keyword, set its type to \"tt.name\".\n      // This will prevent this.next() from throwing about unexpected escapes.\n      if (tokenIsKeyword) {\n        this.replaceToken(tt.name);\n      }\n    } else {\n      this.checkReservedWord(name, startLoc, tokenIsKeyword, false);\n    }\n\n    this.next();\n\n    return name;\n  }\n\n  checkReservedWord(\n    word: string,\n    startLoc: Position,\n    checkKeywords: boolean,\n    isBinding: boolean,\n  ): void {\n    // Every JavaScript reserved word is 10 characters or less.\n    if (word.length > 10) {\n      return;\n    }\n    // Most identifiers are not reservedWord-like, they don't need special\n    // treatments afterward, which very likely ends up throwing errors\n    if (!canBeReservedWord(word)) {\n      return;\n    }\n\n    if (checkKeywords && isKeyword(word)) {\n      this.raise(Errors.UnexpectedKeyword, startLoc, {\n        keyword: word,\n      });\n      return;\n    }\n\n    const reservedTest = !this.state.strict\n      ? isReservedWord\n      : isBinding\n        ? isStrictBindReservedWord\n        : isStrictReservedWord;\n\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\n      if (this.scope.inStaticBlock) {\n        this.raise(Errors.AwaitBindingIdentifierInStaticBlock, startLoc);\n        return;\n      }\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\n  // Returns wether `await` is allowed or not in this context, and if it is\n  // keeps track of it to determine whether a module uses top-level await.\n  recordAwaitIfAllowed(): boolean {\n    const isAwaitAllowed =\n      this.prodParam.hasAwait ||\n      (this.optionFlags & OptionFlags.AllowAwaitOutsideFunction &&\n        !this.scope.inFunction);\n\n    if (isAwaitAllowed && !this.scope.inFunction) {\n      this.state.hasTopLevelAwait = true;\n    }\n\n    return isAwaitAllowed;\n  }\n\n  // Parses await expression inside async function.\n\n  parseAwait(this: Parser, startLoc: Position): N.AwaitExpression {\n    const node = this.startNodeAt<N.AwaitExpression>(startLoc);\n\n    this.expressionScope.recordParameterInitializerError(\n      Errors.AwaitExpressionFormalParameter,\n      // @ts-expect-error todo(flow->ts)\n      node,\n    );\n\n    if (this.eat(tt.star)) {\n      this.raise(Errors.ObsoleteAwaitStar, node);\n    }\n\n    if (\n      !this.scope.inFunction &&\n      !(this.optionFlags & OptionFlags.AllowAwaitOutsideFunction)\n    ) {\n      if (this.isAmbiguousAwait()) {\n        this.ambiguousScriptDifferentAst = true;\n      } else {\n        this.sawUnambiguousESM = true;\n      }\n    }\n\n    if (!this.state.soloAwait) {\n      node.argument = this.parseMaybeUnary(null, true);\n    }\n\n    return this.finishNode(node, \"AwaitExpression\");\n  }\n\n  isAmbiguousAwait(): boolean {\n    if (this.hasPrecedingLineBreak()) return true;\n    const { type } = this.state;\n    return (\n      // All the following expressions are ambiguous:\n      //   await + 0, await - 0, await ( 0 ), await [ 0 ], await / 0 /u, await ``, await of []\n      type === tt.plusMin ||\n      type === tt.parenL ||\n      type === tt.bracketL ||\n      tokenIsTemplate(type) ||\n      (type === tt._of && !this.state.containsEsc) ||\n      // Sometimes the tokenizer generates tt.slash for regexps, and this is\n      // handler by parseExprAtom\n      type === tt.regexp ||\n      type === tt.slash ||\n      // This code could be parsed both as a modulo operator or as an intrinsic:\n      //   await %x(0)\n      (this.hasPlugin(\"v8intrinsic\") && type === tt.modulo)\n    );\n  }\n\n  // Parses yield expression inside generator.\n\n  parseYield(this: Parser): N.YieldExpression {\n    const node = this.startNode<N.YieldExpression>();\n\n    this.expressionScope.recordParameterInitializerError(\n      Errors.YieldInParameter,\n      // @ts-expect-error todo(flow->ts)\n      node,\n    );\n\n    this.next();\n    let delegating = false;\n    let argument: N.Expression | null = null;\n    if (!this.hasPrecedingLineBreak()) {\n      delegating = this.eat(tt.star);\n      switch (this.state.type) {\n        case tt.semi:\n        case tt.eof:\n        case tt.braceR:\n        case tt.parenR:\n        case tt.bracketR:\n        case tt.braceBarR:\n        case tt.colon:\n        case tt.comma:\n          // The above is the complete set of tokens that can\n          // follow an AssignmentExpression, and none of them\n          // can start an AssignmentExpression\n          if (!delegating) break;\n        /* fallthrough */\n        default:\n          argument = this.parseMaybeAssign();\n      }\n    }\n    node.delegate = delegating;\n    node.argument = argument;\n    return this.finishNode(node, \"YieldExpression\");\n  }\n\n  // https://tc39.es/ecma262/#prod-ImportCall\n  parseImportCall(\n    this: Parser,\n    node: Undone<N.ImportExpression>,\n  ): N.ImportExpression {\n    this.next(); // eat tt.parenL\n    node.source = this.parseMaybeAssignAllowIn();\n    node.options = null;\n    if (this.eat(tt.comma)) {\n      if (!this.match(tt.parenR)) {\n        node.options = this.parseMaybeAssignAllowIn();\n\n        if (this.eat(tt.comma) && !this.match(tt.parenR)) {\n          // keep consuming arguments, to then throw ImportCallArity\n          // instead of \"expected )\"\n          do {\n            this.parseMaybeAssignAllowIn();\n          } while (this.eat(tt.comma) && !this.match(tt.parenR));\n\n          this.raise(Errors.ImportCallArity, node);\n        }\n      }\n    }\n    this.expect(tt.parenR);\n    return this.finishNode(node, \"ImportExpression\");\n  }\n\n  // Validates a pipeline (for any of the pipeline Babylon plugins) at the point\n  // of the infix operator `|>`.\n\n  checkPipelineAtInfixOperator(left: N.Expression, leftStartLoc: Position) {\n    // @ts-expect-error Remove this in Babel 8\n    if (this.hasPlugin([\"pipelineOperator\", { proposal: \"smart\" }])) {\n      if (left.type === \"SequenceExpression\") {\n        // Ensure that the pipeline head is not a comma-delimited\n        // sequence expression.\n        this.raise(Errors.PipelineHeadSequenceExpression, leftStartLoc);\n      }\n    }\n  }\n\n  parseSmartPipelineBodyInStyle(childExpr: N.Expression, startLoc: Position) {\n    if (this.isSimpleReference(childExpr)) {\n      const bodyNode = this.startNodeAt<N.PipelineBareFunction>(startLoc);\n      bodyNode.callee = childExpr;\n      return this.finishNode(bodyNode, \"PipelineBareFunction\");\n    } else {\n      const bodyNode = this.startNodeAt<N.PipelineTopicExpression>(startLoc);\n      this.checkSmartPipeTopicBodyEarlyErrors(startLoc);\n      bodyNode.expression = childExpr;\n      return this.finishNode(bodyNode, \"PipelineTopicExpression\");\n    }\n  }\n\n  isSimpleReference(expression: N.Expression): boolean {\n    switch (expression.type) {\n      case \"MemberExpression\":\n        return (\n          !expression.computed && this.isSimpleReference(expression.object)\n        );\n      case \"Identifier\":\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  // This helper method is to be called immediately\n  // after a topic-style smart-mix pipe body is parsed.\n  // The `startLoc` is the starting position of the pipe body.\n\n  checkSmartPipeTopicBodyEarlyErrors(startLoc: Position): void {\n    // If the following token is invalidly `=>`, then throw a human-friendly error\n    // instead of something like 'Unexpected token, expected \";\"'.\n    // For example, `x => x |> y => #` (assuming `#` is the topic reference)\n    // groups into `x => (x |> y) => #`,\n    // and `(x |> y) => #` is an invalid arrow function.\n    // This is because smart-mix `|>` has tighter precedence than `=>`.\n    if (this.match(tt.arrow)) {\n      throw this.raise(Errors.PipelineBodyNoArrow, this.state.startLoc);\n    }\n\n    // A topic-style smart-mix pipe body must use the topic reference at least once.\n    if (!this.topicReferenceWasUsedInCurrentContext()) {\n      this.raise(Errors.PipelineTopicUnused, startLoc);\n    }\n  }\n\n  // Enable topic references from outer contexts within Hack-style pipe bodies.\n  // The function modifies the parser's topic-context state to enable or disable\n  // the use of topic references.\n  // The function then calls a callback, then resets the parser\n  // to the old topic-context state that it had before the function was called.\n\n  withTopicBindingContext<T>(callback: () => T): T {\n    const outerContextTopicState = this.state.topicContext;\n    this.state.topicContext = {\n      // Enable the use of the primary topic reference.\n      maxNumOfResolvableTopics: 1,\n      // Hide the use of any topic references from outer contexts.\n      maxTopicIndex: null,\n    };\n\n    try {\n      return callback();\n    } finally {\n      this.state.topicContext = outerContextTopicState;\n    }\n  }\n\n  // This helper method is used only with the deprecated smart-mix pipe proposal.\n  // Disables topic references from outer contexts within syntax constructs\n  // such as the bodies of iteration statements.\n  // The function modifies the parser's topic-context state to enable or disable\n  // the use of topic references with the smartPipelines plugin. They then run a\n  // callback, then they reset the parser to the old topic-context state that it\n  // had before the function was called.\n\n  withSmartMixTopicForbiddingContext<T>(callback: () => T): T {\n    // TODO(Babel 8): Remove this method\n\n    if (\n      !process.env.BABEL_8_BREAKING &&\n      // @ts-expect-error Babel 7 only\n      this.hasPlugin([\"pipelineOperator\", { proposal: \"smart\" }])\n    ) {\n      // Reset the parser’s topic context only if the smart-mix pipe proposal is active.\n      const outerContextTopicState = this.state.topicContext;\n      this.state.topicContext = {\n        // Disable the use of the primary topic reference.\n        maxNumOfResolvableTopics: 0,\n        // Hide the use of any topic references from outer contexts.\n        maxTopicIndex: null,\n      };\n\n      try {\n        return callback();\n      } finally {\n        this.state.topicContext = outerContextTopicState;\n      }\n    } else {\n      // If the pipe proposal is \"minimal\"(Babel 7), \"fsharp\", or \"hack\",\n      // or if no pipe proposal is active,\n      // then the callback result is returned\n      // without touching any extra parser state.\n      return callback();\n    }\n  }\n\n  withSoloAwaitPermittingContext<T>(callback: () => T): T {\n    const outerContextSoloAwaitState = this.state.soloAwait;\n    this.state.soloAwait = true;\n\n    try {\n      return callback();\n    } finally {\n      this.state.soloAwait = outerContextSoloAwaitState;\n    }\n  }\n\n  allowInAnd<T>(callback: () => T): T {\n    const flags = this.prodParam.currentFlags();\n    const prodParamToSet = ParamKind.PARAM_IN & ~flags;\n    if (prodParamToSet) {\n      this.prodParam.enter(flags | ParamKind.PARAM_IN);\n      try {\n        return callback();\n      } finally {\n        this.prodParam.exit();\n      }\n    }\n    return callback();\n  }\n\n  disallowInAnd<T>(callback: () => T): T {\n    const flags = this.prodParam.currentFlags();\n    const prodParamToClear = ParamKind.PARAM_IN & flags;\n    if (prodParamToClear) {\n      this.prodParam.enter(flags & ~ParamKind.PARAM_IN);\n      try {\n        return callback();\n      } finally {\n        this.prodParam.exit();\n      }\n    }\n    return callback();\n  }\n\n  // Register the use of a topic reference within the current\n  // topic-binding context.\n  registerTopicReference(): void {\n    this.state.topicContext.maxTopicIndex = 0;\n  }\n\n  topicReferenceIsAllowedInCurrentContext(): boolean {\n    return this.state.topicContext.maxNumOfResolvableTopics >= 1;\n  }\n\n  topicReferenceWasUsedInCurrentContext(): boolean {\n    return (\n      this.state.topicContext.maxTopicIndex != null &&\n      this.state.topicContext.maxTopicIndex >= 0\n    );\n  }\n\n  parseFSharpPipelineBody(this: Parser, prec: number): N.Expression {\n    const startLoc = this.state.startLoc;\n\n    this.state.potentialArrowAt = this.state.start;\n    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n    this.state.inFSharpPipelineDirectBody = true;\n\n    const ret = this.parseExprOp(\n      this.parseMaybeUnaryOrPrivate(),\n      startLoc,\n      prec,\n    );\n\n    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n\n    return ret;\n  }\n\n  // https://github.com/tc39/proposal-js-module-blocks\n  parseModuleExpression(this: Parser): N.ModuleExpression {\n    this.expectPlugin(\"moduleBlocks\");\n    const node = this.startNode<N.ModuleExpression>();\n    this.next(); // eat \"module\"\n    if (!this.match(tt.braceL)) {\n      this.unexpected(null, tt.braceL);\n    }\n    // start program node immediately after `{`\n    const program = this.startNodeAt<N.Program>(this.state.endLoc);\n    this.next(); // eat `{`\n\n    const revertScopes = this.initializeScopes(/** inModule */ true);\n    this.enterInitialScopes();\n\n    try {\n      node.body = this.parseProgram(program, tt.braceR, \"module\");\n    } finally {\n      revertScopes();\n    }\n    return this.finishNode<N.ModuleExpression>(node, \"ModuleExpression\");\n  }\n\n  // Used in Flow plugin\n  parsePropertyNamePrefixOperator(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    prop: Undone<N.ObjectOrClassMember | N.ClassMember>,\n  ): void {}\n}\n","import type * as N from \"../types.ts\";\nimport {\n  tokenIsIdentifier,\n  tokenIsKeywordOrIdentifier,\n  tokenIsLoop,\n  tokenIsTemplate,\n  tt,\n  type TokenType,\n  getExportedToken,\n} from \"../tokenizer/types.ts\";\nimport ExpressionParser from \"./expression.ts\";\nimport { Errors } from \"../parse-error.ts\";\nimport { isIdentifierChar, isIdentifierStart } from \"../util/identifier.ts\";\nimport * as charCodes from \"charcodes\";\nimport {\n  ScopeFlag,\n  ClassElementType,\n  BindingFlag,\n} from \"../util/scopeflags.ts\";\nimport { ExpressionErrors } from \"./util.ts\";\nimport { ParamKind, functionFlags } from \"../util/production-parameter.ts\";\nimport {\n  newExpressionScope,\n  newParameterDeclarationScope,\n} from \"../util/expression-scope.ts\";\nimport { OptionFlags, type SourceType } from \"../options.ts\";\nimport { Token } from \"../tokenizer/index.ts\";\nimport type { Position } from \"../util/location.ts\";\nimport { createPositionWithColumnOffset } from \"../util/location.ts\";\nimport { cloneStringLiteral, cloneIdentifier, type Undone } from \"./node.ts\";\nimport type Parser from \"./index.ts\";\nimport { ParseBindingListFlags } from \"./lval.ts\";\nimport { LoopLabelKind } from \"../tokenizer/state.ts\";\n\nconst loopLabel = { kind: LoopLabelKind.Loop } as const,\n  switchLabel = { kind: LoopLabelKind.Switch } as const;\n\nexport const enum ParseFunctionFlag {\n  Expression = 0b0000,\n  Declaration = 0b0001,\n  HangingDeclaration = 0b0010,\n  NullableId = 0b0100,\n  Async = 0b1000,\n}\n\nexport const enum ParseStatementFlag {\n  StatementOnly = 0b0000,\n  AllowImportExport = 0b0001,\n  AllowDeclaration = 0b0010,\n  AllowFunctionDeclaration = 0b0100,\n  AllowLabeledFunction = 0b1000,\n}\n\nconst loneSurrogate = /[\\uD800-\\uDFFF]/u;\n\nconst keywordRelationalOperator = /in(?:stanceof)?/y;\n\n/**\n * Convert tokens for backward Babel 7 compat.\n * tt.privateName => tt.hash + tt.name\n * tt.templateTail => tt.backquote/tt.braceR + tt.template + tt.backquote\n * tt.templateNonTail => tt.backquote/tt.braceR + tt.template + tt.dollarBraceL\n * For performance reasons this routine mutates `tokens`, it is okay\n * here since we execute `parseTopLevel` once for every file.\n */\nfunction babel7CompatTokens(\n  tokens: (Token | N.Comment)[],\n  input: string,\n  startIndex: number,\n) {\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    const { type } = token;\n    if (typeof type === \"number\") {\n      if (!process.env.BABEL_8_BREAKING) {\n        if (type === tt.privateName) {\n          const { loc, start, value, end } = token;\n          const hashEndPos = start + 1;\n          const hashEndLoc = createPositionWithColumnOffset(loc.start, 1);\n          tokens.splice(\n            i,\n            1,\n            new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.hash),\n              value: \"#\",\n              start: start,\n              end: hashEndPos,\n              startLoc: loc.start,\n              endLoc: hashEndLoc,\n            }),\n            new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.name),\n              value: value,\n              start: hashEndPos,\n              end: end,\n              startLoc: hashEndLoc,\n              endLoc: loc.end,\n            }),\n          );\n          i++;\n          continue;\n        }\n\n        if (tokenIsTemplate(type)) {\n          const { loc, start, value, end } = token;\n          const backquoteEnd = start + 1;\n          const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);\n          let startToken;\n          if (input.charCodeAt(start - startIndex) === charCodes.graveAccent) {\n            startToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.backQuote),\n              value: \"`\",\n              start: start,\n              end: backquoteEnd,\n              startLoc: loc.start,\n              endLoc: backquoteEndLoc,\n            });\n          } else {\n            startToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.braceR),\n              value: \"}\",\n              start: start,\n              end: backquoteEnd,\n              startLoc: loc.start,\n              endLoc: backquoteEndLoc,\n            });\n          }\n          let templateValue,\n            templateElementEnd,\n            templateElementEndLoc,\n            endToken;\n          if (type === tt.templateTail) {\n            // ends with '`'\n            templateElementEnd = end - 1;\n            templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1);\n            templateValue = value === null ? null : value.slice(1, -1);\n            endToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.backQuote),\n              value: \"`\",\n              start: templateElementEnd,\n              end: end,\n              startLoc: templateElementEndLoc,\n              endLoc: loc.end,\n            });\n          } else {\n            // ends with `${`\n            templateElementEnd = end - 2;\n            templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2);\n            templateValue = value === null ? null : value.slice(1, -2);\n            endToken = new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.dollarBraceL),\n              value: \"${\",\n              start: templateElementEnd,\n              end: end,\n              startLoc: templateElementEndLoc,\n              endLoc: loc.end,\n            });\n          }\n          tokens.splice(\n            i,\n            1,\n            startToken,\n            new Token({\n              // @ts-expect-error: hacky way to create token\n              type: getExportedToken(tt.template),\n              value: templateValue,\n              start: backquoteEnd,\n              end: templateElementEnd,\n              startLoc: backquoteEndLoc,\n              endLoc: templateElementEndLoc,\n            }),\n            endToken,\n          );\n          i += 2;\n          continue;\n        }\n      }\n      // @ts-expect-error: we manipulate `token` for performance reasons\n      token.type = getExportedToken(type);\n    }\n  }\n  return tokens;\n}\nexport default abstract class StatementParser extends ExpressionParser {\n  // ### Statement parsing\n\n  // Parse a program. Initializes the parser, reads any number of\n  // statements, and wraps them in a Program node.  Optionally takes a\n  // `program` argument.  If present, the statements will be appended\n  // to its body instead of creating a new node.\n\n  parseTopLevel(\n    this: Parser,\n    file: Undone<N.File>,\n    program: Undone<N.Program>,\n  ): N.File {\n    file.program = this.parseProgram(program);\n    file.comments = this.comments;\n\n    if (this.optionFlags & OptionFlags.Tokens) {\n      file.tokens = babel7CompatTokens(\n        this.tokens,\n        this.input,\n        this.startIndex,\n      );\n    }\n\n    return this.finishNode(file, \"File\");\n  }\n\n  parseProgram(\n    this: Parser,\n    program: Undone<N.Program>,\n    end: TokenType = tt.eof,\n    sourceType: SourceType = this.options.sourceType,\n  ): N.Program {\n    program.sourceType = sourceType;\n    program.interpreter = this.parseInterpreterDirective();\n    this.parseBlockBody(program, true, true, end);\n    if (this.inModule) {\n      if (\n        !(this.optionFlags & OptionFlags.AllowUndeclaredExports) &&\n        this.scope.undefinedExports.size > 0\n      ) {\n        for (const [localName, at] of Array.from(this.scope.undefinedExports)) {\n          this.raise(Errors.ModuleExportUndefined, at, { localName });\n        }\n      }\n      this.addExtra(program, \"topLevelAwait\", this.state.hasTopLevelAwait);\n    }\n    let finishedProgram: N.Program;\n    if (end === tt.eof) {\n      // finish at eof for top level program\n      finishedProgram = this.finishNode(program, \"Program\");\n    } else {\n      // finish immediately before the end token\n      finishedProgram = this.finishNodeAt(\n        program,\n        \"Program\",\n        createPositionWithColumnOffset(this.state.startLoc, -1),\n      );\n    }\n    return finishedProgram;\n  }\n\n  /**\n   * cast a Statement to a Directive. This method mutates input statement.\n   */\n  stmtToDirective(stmt: N.Statement): N.Directive {\n    const directive = stmt as any;\n    directive.type = \"Directive\";\n    directive.value = directive.expression;\n    delete directive.expression;\n\n    const directiveLiteral = directive.value;\n    const expressionValue = directiveLiteral.value;\n    const raw = this.input.slice(\n      this.offsetToSourcePos(directiveLiteral.start),\n      this.offsetToSourcePos(directiveLiteral.end),\n    );\n    const val = (directiveLiteral.value = raw.slice(1, -1)); // remove quotes\n\n    this.addExtra(directiveLiteral, \"raw\", raw);\n    this.addExtra(directiveLiteral, \"rawValue\", val);\n    this.addExtra(directiveLiteral, \"expressionValue\", expressionValue);\n\n    directiveLiteral.type = \"DirectiveLiteral\";\n\n    return directive;\n  }\n\n  parseInterpreterDirective(): N.InterpreterDirective | null {\n    if (!this.match(tt.interpreterDirective)) {\n      return null;\n    }\n\n    const node = this.startNode<N.InterpreterDirective>();\n    node.value = this.state.value;\n    this.next();\n    return this.finishNode(node, \"InterpreterDirective\");\n  }\n\n  isLet(): boolean {\n    if (!this.isContextual(tt._let)) {\n      return false;\n    }\n    return this.hasFollowingBindingAtom();\n  }\n\n  chStartsBindingIdentifier(ch: number, pos: number) {\n    if (isIdentifierStart(ch)) {\n      keywordRelationalOperator.lastIndex = pos;\n      if (keywordRelationalOperator.test(this.input)) {\n        // We have seen `in` or `instanceof` so far, now check if the identifier\n        // ends here\n        const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);\n        if (!isIdentifierChar(endCh) && endCh !== charCodes.backslash) {\n          return false;\n        }\n      }\n      return true;\n    } else if (ch === charCodes.backslash) {\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  chStartsBindingPattern(ch: number) {\n    return (\n      ch === charCodes.leftSquareBracket || ch === charCodes.leftCurlyBrace\n    );\n  }\n\n  /**\n   * Assuming we have seen a contextual `let` and declaration is allowed, check if it\n   * starts a variable declaration so that it should be interpreted as a keyword.\n   */\n  hasFollowingBindingAtom(): boolean {\n    const next = this.nextTokenStart();\n    const nextCh = this.codePointAtPos(next);\n    return (\n      this.chStartsBindingPattern(nextCh) ||\n      this.chStartsBindingIdentifier(nextCh, next)\n    );\n  }\n\n  /**\n   * Assuming we have seen a contextual `using` and declaration is allowed, check if it\n   * starts a variable declaration in the same line so that it should be interpreted as\n   * a keyword.\n   */\n  hasInLineFollowingBindingIdentifierOrBrace(): boolean {\n    const next = this.nextTokenInLineStart();\n    const nextCh = this.codePointAtPos(next);\n    return (\n      nextCh === charCodes.leftCurlyBrace ||\n      this.chStartsBindingIdentifier(nextCh, next)\n    );\n  }\n\n  startsUsingForOf(): boolean {\n    const { type, containsEsc } = this.lookahead();\n    if (type === tt._of && !containsEsc) {\n      // `using of` must start a for-lhs-of statement\n      return false;\n    } else if (tokenIsIdentifier(type) && !this.hasFollowingLineBreak()) {\n      this.expectPlugin(\"explicitResourceManagement\");\n      return true;\n    }\n  }\n\n  startsAwaitUsing(): boolean {\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\n  // https://tc39.es/ecma262/#prod-ModuleItem\n  parseModuleItem(this: Parser) {\n    return this.parseStatementLike(\n      ParseStatementFlag.AllowImportExport |\n        ParseStatementFlag.AllowDeclaration |\n        ParseStatementFlag.AllowFunctionDeclaration |\n        // This function is actually also used to parse StatementItems,\n        // which with Annex B enabled allows labeled functions.\n        ParseStatementFlag.AllowLabeledFunction,\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-StatementListItem\n  parseStatementListItem(this: Parser) {\n    return this.parseStatementLike(\n      ParseStatementFlag.AllowDeclaration |\n        ParseStatementFlag.AllowFunctionDeclaration |\n        (!this.options.annexB || this.state.strict\n          ? 0\n          : ParseStatementFlag.AllowLabeledFunction),\n    );\n  }\n\n  parseStatementOrSloppyAnnexBFunctionDeclaration(\n    this: Parser,\n    allowLabeledFunction: boolean = false,\n  ) {\n    let flags: ParseStatementFlag = ParseStatementFlag.StatementOnly;\n    if (this.options.annexB && !this.state.strict) {\n      flags |= ParseStatementFlag.AllowFunctionDeclaration;\n      if (allowLabeledFunction) {\n        flags |= ParseStatementFlag.AllowLabeledFunction;\n      }\n    }\n    return this.parseStatementLike(flags);\n  }\n\n  // Parse a single statement.\n  //\n  // If expecting a statement and finding a slash operator, parse a\n  // regular expression literal. This is to handle cases like\n  // `if (foo) /blah/.exec(foo)`, where looking at the previous token\n  // does not help.\n  // https://tc39.es/ecma262/#prod-Statement\n  parseStatement(this: Parser) {\n    return this.parseStatementLike(ParseStatementFlag.StatementOnly);\n  }\n\n  // ImportDeclaration and ExportDeclaration are also handled here so we can throw recoverable errors\n  // when they are not at the top level\n  parseStatementLike(\n    this: Parser,\n    flags: ParseStatementFlag,\n  ):\n    | N.Statement\n    | N.Declaration\n    | N.ImportDeclaration\n    | N.ExportDefaultDeclaration\n    | N.ExportNamedDeclaration\n    | N.ExportAllDeclaration {\n    let decorators: N.Decorator[] | null = null;\n\n    if (this.match(tt.at)) {\n      decorators = this.parseDecorators(true);\n    }\n    return this.parseStatementContent(flags, decorators);\n  }\n\n  parseStatementContent(\n    this: Parser,\n    flags: ParseStatementFlag,\n    decorators?: N.Decorator[] | null,\n  ): N.Statement {\n    const startType = this.state.type;\n    const node = this.startNode();\n    const allowDeclaration = !!(flags & ParseStatementFlag.AllowDeclaration);\n    const allowFunctionDeclaration = !!(\n      flags & ParseStatementFlag.AllowFunctionDeclaration\n    );\n    const topLevel = flags & ParseStatementFlag.AllowImportExport;\n\n    // Most types of statements are recognized by the keyword they\n    // start with. Many are trivial to parse, some require a bit of\n    // complexity.\n\n    switch (startType) {\n      case tt._break:\n        return this.parseBreakContinueStatement(node, /* isBreak */ true);\n      case tt._continue:\n        return this.parseBreakContinueStatement(node, /* isBreak */ false);\n      case tt._debugger:\n        return this.parseDebuggerStatement(node as Undone<N.DebuggerStatement>);\n      case tt._do:\n        return this.parseDoWhileStatement(node as Undone<N.DoWhileStatement>);\n      case tt._for:\n        return this.parseForStatement(node as Undone<N.ForStatement>);\n      case tt._function:\n        if (this.lookaheadCharCode() === charCodes.dot) break;\n        if (!allowFunctionDeclaration) {\n          this.raise(\n            this.state.strict\n              ? Errors.StrictFunction\n              : this.options.annexB\n                ? Errors.SloppyFunctionAnnexB\n                : Errors.SloppyFunction,\n            this.state.startLoc,\n          );\n        }\n        return this.parseFunctionStatement(\n          node as Undone<N.FunctionDeclaration>,\n          false,\n          !allowDeclaration && allowFunctionDeclaration,\n        );\n      case tt._class:\n        if (!allowDeclaration) this.unexpected();\n        return this.parseClass(\n          this.maybeTakeDecorators(\n            decorators,\n            node as Undone<N.ClassDeclaration>,\n          ),\n          true,\n        );\n\n      case tt._if:\n        return this.parseIfStatement(node as Undone<N.IfStatement>);\n      case tt._return:\n        return this.parseReturnStatement(node as Undone<N.ReturnStatement>);\n      case tt._switch:\n        return this.parseSwitchStatement(node as Undone<N.SwitchStatement>);\n      case tt._throw:\n        return this.parseThrowStatement(node as Undone<N.ThrowStatement>);\n      case tt._try:\n        return this.parseTryStatement(node as Undone<N.TryStatement>);\n\n      case tt._await:\n        // [+Await] await [no LineTerminator here] using [no LineTerminator here] BindingList[+Using]\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(); // eat 'await'\n          return this.parseVarStatement(\n            node as Undone<N.VariableDeclaration>,\n            \"await using\",\n          );\n        }\n        break;\n      case tt._using:\n        // using [no LineTerminator here] BindingList[+Using]\n        if (\n          this.state.containsEsc ||\n          !this.hasInLineFollowingBindingIdentifierOrBrace()\n        ) {\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(\n          node as Undone<N.VariableDeclaration>,\n          \"using\",\n        );\n      case tt._let: {\n        if (this.state.containsEsc) {\n          break;\n        }\n        // `let [` is an explicit negative lookahead for\n        // ExpressionStatement, so special-case it first.\n        const next = this.nextTokenStart();\n        const nextCh = this.codePointAtPos(next);\n        if (nextCh !== charCodes.leftSquareBracket) {\n          if (!allowDeclaration && this.hasFollowingLineBreak()) break;\n          if (\n            !this.chStartsBindingIdentifier(nextCh, next) &&\n            nextCh !== charCodes.leftCurlyBrace\n          ) {\n            break;\n          }\n        }\n      }\n      // fall through\n      case tt._const: {\n        if (!allowDeclaration) {\n          this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);\n        }\n      }\n      // fall through\n      case tt._var: {\n        const kind = this.state.value;\n        return this.parseVarStatement(\n          node as Undone<N.VariableDeclaration>,\n          kind,\n        );\n      }\n      case tt._while:\n        return this.parseWhileStatement(node as Undone<N.WhileStatement>);\n      case tt._with:\n        return this.parseWithStatement(node as Undone<N.WithStatement>);\n      case tt.braceL:\n        return this.parseBlock();\n      case tt.semi:\n        return this.parseEmptyStatement(node as Undone<N.EmptyStatement>);\n      case tt._import: {\n        const nextTokenCharCode = this.lookaheadCharCode();\n        if (\n          nextTokenCharCode === charCodes.leftParenthesis || // import()\n          nextTokenCharCode === charCodes.dot // import.meta\n        ) {\n          break;\n        }\n      }\n      // fall through\n      case tt._export: {\n        if (\n          !(this.optionFlags & OptionFlags.AllowImportExportEverywhere) &&\n          !topLevel\n        ) {\n          this.raise(Errors.UnexpectedImportExport, this.state.startLoc);\n        }\n\n        this.next(); // eat `import`/`export`\n\n        let result;\n        if (startType === tt._import) {\n          result = this.parseImport(node as Undone<N.ImportDeclaration>);\n\n          if (\n            result.type === \"ImportDeclaration\" &&\n            (!result.importKind || result.importKind === \"value\")\n          ) {\n            this.sawUnambiguousESM = true;\n          }\n        } else {\n          result = this.parseExport(\n            node as Undone<\n              | N.ExportAllDeclaration\n              | N.ExportDefaultDeclaration\n              | N.ExportDefaultDeclaration\n            >,\n            decorators,\n          );\n\n          if (\n            (result.type === \"ExportNamedDeclaration\" &&\n              (!result.exportKind || result.exportKind === \"value\")) ||\n            (result.type === \"ExportAllDeclaration\" &&\n              (!result.exportKind || result.exportKind === \"value\")) ||\n            result.type === \"ExportDefaultDeclaration\"\n          ) {\n            this.sawUnambiguousESM = true;\n          }\n        }\n\n        this.assertModuleNodeAllowed(result);\n\n        return result;\n      }\n\n      default: {\n        if (this.isAsyncFunction()) {\n          if (!allowDeclaration) {\n            this.raise(\n              Errors.AsyncFunctionInSingleStatementContext,\n              this.state.startLoc,\n            );\n          }\n          this.next(); // eat 'async'\n          return this.parseFunctionStatement(\n            node as Undone<N.FunctionDeclaration>,\n            true,\n            !allowDeclaration && allowFunctionDeclaration,\n          );\n        }\n      }\n    }\n\n    // If the statement does not start with a statement keyword or a\n    // brace, it's an ExpressionStatement or LabeledStatement. We\n    // simply start parsing an expression, and afterwards, if the\n    // next token is a colon and the expression was a simple\n    // Identifier node, we switch to interpreting it as a label.\n    const maybeName = this.state.value;\n    const expr = this.parseExpression();\n\n    if (\n      tokenIsIdentifier(startType) &&\n      expr.type === \"Identifier\" &&\n      this.eat(tt.colon)\n    ) {\n      return this.parseLabeledStatement(\n        node as Undone<N.LabeledStatement>,\n        maybeName,\n        expr,\n        flags,\n      );\n    } else {\n      return this.parseExpressionStatement(\n        node as Undone<N.ExpressionStatement>,\n        expr,\n        decorators,\n      );\n    }\n  }\n\n  assertModuleNodeAllowed(node: N.Node): void {\n    if (\n      !(this.optionFlags & OptionFlags.AllowImportExportEverywhere) &&\n      !this.inModule\n    ) {\n      this.raise(Errors.ImportOutsideModule, node);\n    }\n  }\n\n  decoratorsEnabledBeforeExport(): boolean {\n    if (this.hasPlugin(\"decorators-legacy\")) return true;\n    return (\n      this.hasPlugin(\"decorators\") &&\n      this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") !== false\n    );\n  }\n\n  // Attach the decorators to the given class.\n  // NOTE: This method changes the .start location of the class, and thus\n  // can affect comment attachment. Calling it before or after finalizing\n  // the class node (and thus finalizing its comments) changes how comments\n  // before the `class` keyword or before the final .start location of the\n  // class are attached.\n  maybeTakeDecorators<T extends Undone<N.Class>>(\n    maybeDecorators: N.Decorator[] | null,\n    classNode: T,\n    exportNode?: Undone<N.ExportDefaultDeclaration | N.ExportNamedDeclaration>,\n  ): T {\n    if (maybeDecorators) {\n      if (classNode.decorators?.length) {\n        // Note: decorators attachment is only attempred multiple times\n        // when the class is part of an export declaration.\n        if (\n          typeof this.getPluginOption(\n            \"decorators\",\n            \"decoratorsBeforeExport\",\n          ) !== \"boolean\"\n        ) {\n          // If `decoratorsBeforeExport` was set to `true` or `false`, we\n          // already threw an error about decorators not being in a valid\n          // position.\n          this.raise(\n            Errors.DecoratorsBeforeAfterExport,\n            classNode.decorators[0],\n          );\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\n  canHaveLeadingDecorator(): boolean {\n    return this.match(tt._class);\n  }\n\n  parseDecorators(this: Parser, allowExport?: boolean): N.Decorator[] {\n    const decorators = [];\n    do {\n      decorators.push(this.parseDecorator());\n    } while (this.match(tt.at));\n\n    if (this.match(tt._export)) {\n      if (!allowExport) {\n        this.unexpected();\n      }\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\n    return decorators;\n  }\n\n  parseDecorator(this: Parser): N.Decorator {\n    this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n\n    const node = this.startNode<N.Decorator>();\n    this.next();\n\n    if (this.hasPlugin(\"decorators\")) {\n      const startLoc = this.state.startLoc;\n      let expr: N.Expression;\n\n      if (this.match(tt.parenL)) {\n        const startLoc = this.state.startLoc;\n        this.next(); // eat '('\n        expr = this.parseExpression();\n        this.expect(tt.parenR);\n        expr = this.wrapParenthesis(startLoc, expr);\n\n        const paramsStartLoc = this.state.startLoc;\n        node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);\n        if (\n          this.getPluginOption(\"decorators\", \"allowCallParenthesized\") ===\n            false &&\n          node.expression !== expr\n        ) {\n          this.raise(\n            Errors.DecoratorArgumentsOutsideParentheses,\n            paramsStartLoc,\n          );\n        }\n      } else {\n        expr = this.parseIdentifier(false);\n\n        while (this.eat(tt.dot)) {\n          const node = this.startNodeAt<N.MemberExpression>(startLoc);\n          node.object = expr;\n          if (this.match(tt.privateName)) {\n            this.classScope.usePrivateName(\n              this.state.value,\n              this.state.startLoc,\n            );\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\n        node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);\n      }\n    } else {\n      node.expression = this.parseExprSubscripts();\n    }\n    return this.finishNode(node, \"Decorator\");\n  }\n\n  parseMaybeDecoratorArguments(\n    this: Parser,\n    expr: N.Expression,\n    startLoc: Position,\n  ): N.Expression {\n    if (this.eat(tt.parenL)) {\n      const node = this.startNodeAt<N.CallExpression>(startLoc);\n      node.callee = expr;\n      node.arguments = this.parseCallExpressionArguments(tt.parenR);\n      this.toReferencedList(node.arguments);\n      return this.finishNode(node, \"CallExpression\");\n    }\n\n    return expr;\n  }\n\n  parseBreakContinueStatement(\n    node: Undone<N.Node>,\n    isBreak: true,\n  ): N.BreakStatement;\n  parseBreakContinueStatement(\n    node: Undone<N.Node>,\n    isBreak: false,\n  ): N.ContinueStatement;\n  parseBreakContinueStatement(\n    node: Undone<N.BreakStatement | N.ContinueStatement>,\n    isBreak: boolean,\n  ): N.BreakStatement | N.ContinueStatement {\n    this.next();\n\n    if (this.isLineTerminator()) {\n      node.label = null;\n    } else {\n      node.label = this.parseIdentifier();\n      this.semicolon();\n    }\n\n    this.verifyBreakContinue(node, isBreak);\n\n    return this.finishNode(\n      node,\n      isBreak ? \"BreakStatement\" : \"ContinueStatement\",\n    );\n  }\n\n  verifyBreakContinue(\n    node: Undone<N.BreakStatement | N.ContinueStatement>,\n    isBreak: boolean,\n  ) {\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 === LoopLabelKind.Loop)) {\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, { type });\n    }\n  }\n\n  parseDebuggerStatement(\n    node: Undone<N.DebuggerStatement>,\n  ): N.DebuggerStatement {\n    this.next();\n    this.semicolon();\n    return this.finishNode(node, \"DebuggerStatement\");\n  }\n\n  parseHeaderExpression(this: Parser): N.Expression {\n    this.expect(tt.parenL);\n    const val = this.parseExpression();\n    this.expect(tt.parenR);\n    return val;\n  }\n\n  // https://tc39.es/ecma262/#prod-DoWhileStatement\n  parseDoWhileStatement(\n    this: Parser,\n    node: Undone<N.DoWhileStatement>,\n  ): N.DoWhileStatement {\n    this.next();\n    this.state.labels.push(loopLabel);\n\n    // Parse the loop body's body.\n    node.body =\n      // For the smartPipelines plugin: Disable topic references from outer\n      // contexts within the loop body. They are permitted in test expressions,\n      // outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse the loop body's body.\n        this.parseStatement(),\n      );\n\n    this.state.labels.pop();\n\n    this.expect(tt._while);\n    node.test = this.parseHeaderExpression();\n    this.eat(tt.semi);\n    return this.finishNode(node, \"DoWhileStatement\");\n  }\n\n  // Disambiguating between a `for` and a `for`/`in` or `for`/`of`\n  // loop is non-trivial. Basically, we have to parse the init `var`\n  // statement or expression, disallowing the `in` operator (see\n  // the second parameter to `parseExpression`), and then check\n  // whether the next token is `in` or `of`. When there is no init\n  // part (semicolon immediately after the opening parenthesis), it\n  // is a regular `for` loop.\n\n  parseForStatement(\n    this: Parser,\n    node: Undone<N.ForStatement | N.ForInOf>,\n  ): N.ForLike {\n    this.next();\n    this.state.labels.push(loopLabel);\n\n    let awaitAt = null;\n\n    if (this.isContextual(tt._await) && this.recordAwaitIfAllowed()) {\n      awaitAt = this.state.startLoc;\n      this.next();\n    }\n    this.scope.enter(ScopeFlag.OTHER);\n    this.expect(tt.parenL);\n\n    if (this.match(tt.semi)) {\n      if (awaitAt !== null) {\n        this.unexpected(awaitAt);\n      }\n      return this.parseFor(node as Undone<N.ForStatement>, null);\n    }\n\n    const startsWithLet = this.isContextual(tt._let);\n    {\n      const startsWithAwaitUsing =\n        this.isContextual(tt._await) && this.startsAwaitUsing();\n      const starsWithUsingDeclaration =\n        startsWithAwaitUsing ||\n        (this.isContextual(tt._using) && this.startsUsingForOf());\n      const isLetOrUsing =\n        (startsWithLet && this.hasFollowingBindingAtom()) ||\n        starsWithUsingDeclaration;\n\n      if (this.match(tt._var) || this.match(tt._const) || isLetOrUsing) {\n        const initNode = this.startNode<N.VariableDeclaration>();\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(); // eat 'await'\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\n        const isForIn = this.match(tt._in);\n        if (isForIn && starsWithUsingDeclaration) {\n          this.raise(Errors.ForInUsing, init);\n        }\n        if (\n          (isForIn || this.isContextual(tt._of)) &&\n          init.declarations.length === 1\n        ) {\n          return this.parseForIn(node as Undone<N.ForInOf>, init, awaitAt);\n        }\n        if (awaitAt !== null) {\n          this.unexpected(awaitAt);\n        }\n        return this.parseFor(node as Undone<N.ForStatement>, init);\n      }\n    }\n\n    // Check whether the first token is possibly a contextual keyword, so that\n    // we can forbid `for (async of` if this turns out to be a for-of loop.\n    const startsWithAsync = this.isContextual(tt._async);\n\n    const refExpressionErrors = new ExpressionErrors();\n    const init = this.parseExpression(true, refExpressionErrors);\n    const isForOf = this.isContextual(tt._of);\n    if (isForOf) {\n      // Check for leading tokens that are forbidden in for-of loops:\n      if (startsWithLet) {\n        this.raise(Errors.ForOfLet, init);\n      }\n\n      if (\n        // `for await (async of []);` is allowed.\n        awaitAt === null &&\n        startsWithAsync &&\n        init.type === \"Identifier\"\n      ) {\n        // This catches the case where the `async` in `for (async of` was\n        // parsed as an identifier. If it was parsed as the start of an async\n        // arrow function (e.g. `for (async of => {} of []);`), the LVal check\n        // further down will raise a more appropriate error.\n        this.raise(Errors.ForOfAsync, init);\n      }\n    }\n    if (isForOf || this.match(tt._in)) {\n      this.checkDestructuringPrivate(refExpressionErrors);\n      this.toAssignable(init, /* isLHS */ true);\n      const type = isForOf ? \"ForOfStatement\" : \"ForInStatement\";\n      this.checkLVal(init, { type });\n      return this.parseForIn(\n        node as Undone<N.ForInStatement | N.ForOfStatement>,\n        // @ts-expect-error init has been transformed to an assignable\n        init,\n        awaitAt,\n      );\n    } else {\n      this.checkExpressionErrors(refExpressionErrors, true);\n    }\n    if (awaitAt !== null) {\n      this.unexpected(awaitAt);\n    }\n    return this.parseFor(node as Undone<N.ForStatement>, init);\n  }\n\n  // https://tc39.es/ecma262/#prod-HoistableDeclaration\n  parseFunctionStatement(\n    this: Parser,\n    node: Undone<N.FunctionDeclaration>,\n    isAsync: boolean,\n    isHangingDeclaration: boolean,\n  ): N.FunctionDeclaration {\n    this.next(); // eat 'function'\n    return this.parseFunction(\n      node,\n      ParseFunctionFlag.Declaration |\n        (isHangingDeclaration ? ParseFunctionFlag.HangingDeclaration : 0) |\n        (isAsync ? ParseFunctionFlag.Async : 0),\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-IfStatement\n  parseIfStatement(this: Parser, node: Undone<N.IfStatement>) {\n    this.next();\n    node.test = this.parseHeaderExpression();\n    // Annex B.3.3\n    // https://tc39.es/ecma262/#sec-functiondeclarations-in-ifstatement-statement-clauses\n    node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();\n    node.alternate = this.eat(tt._else)\n      ? this.parseStatementOrSloppyAnnexBFunctionDeclaration()\n      : null;\n    return this.finishNode(node, \"IfStatement\");\n  }\n\n  parseReturnStatement(this: Parser, node: Undone<N.ReturnStatement>) {\n    if (\n      !this.prodParam.hasReturn &&\n      !(this.optionFlags & OptionFlags.AllowReturnOutsideFunction)\n    ) {\n      this.raise(Errors.IllegalReturn, this.state.startLoc);\n    }\n\n    this.next();\n\n    // In `return` (and `break`/`continue`), the keywords with\n    // optional arguments, we eagerly look for a semicolon or the\n    // possibility to insert one.\n\n    if (this.isLineTerminator()) {\n      node.argument = null;\n    } else {\n      node.argument = this.parseExpression();\n      this.semicolon();\n    }\n\n    return this.finishNode(node, \"ReturnStatement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-SwitchStatement\n  parseSwitchStatement(this: Parser, node: Undone<N.SwitchStatement>) {\n    this.next();\n    node.discriminant = this.parseHeaderExpression();\n    const cases: N.SwitchStatement[\"cases\"] = (node.cases = []);\n    this.expect(tt.braceL);\n    this.state.labels.push(switchLabel);\n    this.scope.enter(ScopeFlag.OTHER);\n\n    // Statements under must be grouped (by label) in SwitchCase\n    // nodes. `cur` is used to keep the node that we are currently\n    // adding statements to.\n\n    let cur;\n    for (let sawDefault; !this.match(tt.braceR); ) {\n      if (this.match(tt._case) || this.match(tt._default)) {\n        const isCase = this.match(tt._case);\n        if (cur) this.finishNode(cur, \"SwitchCase\");\n        // @ts-expect-error Fixme\n        cases.push((cur = this.startNode<N.SwitchCase>()));\n        cur.consequent = [];\n        this.next();\n        if (isCase) {\n          cur.test = this.parseExpression();\n        } else {\n          if (sawDefault) {\n            this.raise(\n              Errors.MultipleDefaultsInSwitch,\n              this.state.lastTokStartLoc,\n            );\n          }\n          sawDefault = true;\n          cur.test = null;\n        }\n        this.expect(tt.colon);\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(); // Closing brace\n    this.state.labels.pop();\n    return this.finishNode(node, \"SwitchStatement\");\n  }\n\n  parseThrowStatement(this: Parser, node: Undone<N.ThrowStatement>) {\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\n  parseCatchClauseParam(this: Parser): N.Pattern {\n    const param = this.parseBindingAtom();\n\n    this.scope.enter(\n      this.options.annexB && param.type === \"Identifier\"\n        ? ScopeFlag.SIMPLE_CATCH\n        : 0,\n    );\n    this.checkLVal(\n      param,\n      { type: \"CatchClause\" },\n      BindingFlag.TYPE_CATCH_PARAM,\n    );\n\n    return param;\n  }\n\n  parseTryStatement(\n    this: Parser,\n    node: Undone<N.TryStatement>,\n  ): N.TryStatement {\n    this.next();\n\n    node.block = this.parseBlock();\n    node.handler = null;\n\n    if (this.match(tt._catch)) {\n      const clause = this.startNode<N.CatchClause>();\n      this.next();\n      if (this.match(tt.parenL)) {\n        this.expect(tt.parenL);\n        clause.param = this.parseCatchClauseParam();\n        this.expect(tt.parenR);\n      } else {\n        clause.param = null;\n        this.scope.enter(ScopeFlag.OTHER);\n      }\n\n      // Parse the catch clause's body.\n      clause.body =\n        // For the smartPipelines plugin: Disable topic references from outer\n        // contexts within the catch clause's body.\n        this.withSmartMixTopicForbiddingContext(() =>\n          // Parse the catch clause's body.\n          this.parseBlock(false, false),\n        );\n\n      this.scope.exit();\n      node.handler = this.finishNode(clause, \"CatchClause\");\n    }\n\n    node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;\n\n    if (!node.handler && !node.finalizer) {\n      this.raise(Errors.NoCatchOrFinally, node);\n    }\n\n    return this.finishNode(node, \"TryStatement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-VariableStatement\n  // https://tc39.es/ecma262/#prod-LexicalDeclaration\n  parseVarStatement(\n    this: Parser,\n    node: Undone<N.VariableDeclaration>,\n    kind: \"var\" | \"let\" | \"const\" | \"using\" | \"await using\",\n    allowMissingInitializer: boolean = false,\n  ): N.VariableDeclaration {\n    this.next();\n    this.parseVar(node, false, kind, allowMissingInitializer);\n    this.semicolon();\n    return this.finishNode(node, \"VariableDeclaration\");\n  }\n\n  // https://tc39.es/ecma262/#prod-WhileStatement\n  parseWhileStatement(\n    this: Parser,\n    node: Undone<N.WhileStatement>,\n  ): N.WhileStatement {\n    this.next();\n    node.test = this.parseHeaderExpression();\n    this.state.labels.push(loopLabel);\n\n    // Parse the loop body.\n    node.body =\n      // For the smartPipelines plugin:\n      // Disable topic references from outer contexts within the loop body.\n      // They are permitted in test expressions, outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse loop body.\n        this.parseStatement(),\n      );\n\n    this.state.labels.pop();\n\n    return this.finishNode(node, \"WhileStatement\");\n  }\n\n  parseWithStatement(\n    this: Parser,\n    node: Undone<N.WithStatement>,\n  ): N.WithStatement {\n    if (this.state.strict) {\n      this.raise(Errors.StrictWith, this.state.startLoc);\n    }\n    this.next();\n    node.object = this.parseHeaderExpression();\n\n    // Parse the statement body.\n    node.body =\n      // For the smartPipelines plugin:\n      // Disable topic references from outer contexts within the with statement's body.\n      // They are permitted in function default-parameter expressions, which are\n      // part of the outer context, outside of the with statement's body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse the statement body.\n        this.parseStatement(),\n      );\n\n    return this.finishNode(node, \"WithStatement\");\n  }\n\n  parseEmptyStatement(node: Undone<N.EmptyStatement>): N.EmptyStatement {\n    this.next();\n    return this.finishNode(node, \"EmptyStatement\");\n  }\n\n  // https://tc39.es/ecma262/#prod-LabelledStatement\n  parseLabeledStatement(\n    this: Parser,\n    node: Undone<N.LabeledStatement>,\n    maybeName: string,\n    expr: N.Identifier,\n    flags: ParseStatementFlag,\n  ): N.LabeledStatement {\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\n    const kind = tokenIsLoop(this.state.type)\n      ? LoopLabelKind.Loop\n      : this.match(tt._switch)\n        ? LoopLabelKind.Switch\n        : 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.sourceToOffsetPos(this.state.start);\n        label.kind = kind;\n      } else {\n        break;\n      }\n    }\n\n    this.state.labels.push({\n      name: maybeName,\n      kind: kind,\n      statementStart: this.sourceToOffsetPos(this.state.start),\n    });\n    // https://tc39.es/ecma262/#prod-LabelledItem\n    node.body =\n      flags & ParseStatementFlag.AllowLabeledFunction\n        ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true)\n        : this.parseStatement();\n\n    this.state.labels.pop();\n    node.label = expr;\n    return this.finishNode(node, \"LabeledStatement\");\n  }\n\n  parseExpressionStatement(\n    node: Undone<N.ExpressionStatement>,\n    expr: N.Expression,\n    /* eslint-disable-next-line @typescript-eslint/no-unused-vars -- used in TypeScript parser */\n    decorators: N.Decorator[] | null,\n  ) {\n    node.expression = expr;\n    this.semicolon();\n    return this.finishNode(node, \"ExpressionStatement\");\n  }\n\n  // Parse a semicolon-enclosed block of statements, handling `\"use\n  // strict\"` declarations when `allowDirectives` is true (used for\n  // function bodies).\n\n  parseBlock(\n    this: Parser,\n    allowDirectives: boolean = false,\n    createNewLexicalScope: boolean = true,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): N.BlockStatement {\n    const node = this.startNode<N.BlockStatement>();\n    if (allowDirectives) {\n      this.state.strictErrors.clear();\n    }\n    this.expect(tt.braceL);\n    if (createNewLexicalScope) {\n      this.scope.enter(ScopeFlag.OTHER);\n    }\n    this.parseBlockBody(\n      node,\n      allowDirectives,\n      false,\n      tt.braceR,\n      afterBlockParse,\n    );\n    if (createNewLexicalScope) {\n      this.scope.exit();\n    }\n    return this.finishNode(node, \"BlockStatement\");\n  }\n\n  isValidDirective(stmt: N.Statement): boolean {\n    return (\n      stmt.type === \"ExpressionStatement\" &&\n      stmt.expression.type === \"StringLiteral\" &&\n      !stmt.expression.extra.parenthesized\n    );\n  }\n\n  parseBlockBody(\n    this: Parser,\n    node: Undone<N.BlockStatementLike>,\n    allowDirectives: boolean | undefined | null,\n    topLevel: boolean,\n    end: TokenType,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): void {\n    const body: N.BlockStatementLike[\"body\"] = (node.body = []);\n    const directives: N.BlockStatementLike[\"directives\"] = (node.directives =\n      []);\n    this.parseBlockOrModuleBlockBody(\n      body,\n      allowDirectives ? directives : undefined,\n      topLevel,\n      end,\n      afterBlockParse,\n    );\n  }\n\n  // Undefined directives means that directives are not allowed.\n  // https://tc39.es/ecma262/#prod-Block\n  // https://tc39.es/ecma262/#prod-ModuleBody\n  parseBlockOrModuleBlockBody(\n    this: Parser,\n    body: N.Statement[],\n    directives: N.Directive[] | undefined | null,\n    topLevel: boolean,\n    end: TokenType,\n    afterBlockParse?: (hasStrictModeDirective: boolean) => void,\n  ): void {\n    const oldStrict = this.state.strict;\n    let hasStrictModeDirective = false;\n    let parsedNonDirective = false;\n\n    while (!this.match(end)) {\n      const stmt = topLevel\n        ? this.parseModuleItem()\n        : this.parseStatementListItem();\n\n      if (directives && !parsedNonDirective) {\n        if (this.isValidDirective(stmt)) {\n          const directive = this.stmtToDirective(stmt);\n          directives.push(directive);\n\n          if (\n            !hasStrictModeDirective &&\n            directive.value.value === \"use strict\"\n          ) {\n            hasStrictModeDirective = true;\n            this.setStrict(true);\n          }\n\n          continue;\n        }\n        parsedNonDirective = true;\n        // clear strict errors since the strict mode will not change within the block\n        this.state.strictErrors.clear();\n      }\n      body.push(stmt);\n    }\n\n    afterBlockParse?.call(this, hasStrictModeDirective);\n\n    if (!oldStrict) {\n      this.setStrict(false);\n    }\n\n    this.next();\n  }\n\n  // Parse a regular `for` loop. The disambiguation code in\n  // `parseStatement` will already have parsed the init statement or\n  // expression.\n\n  parseFor(\n    this: Parser,\n    node: Undone<N.ForStatement>,\n    init?: N.VariableDeclaration | N.Expression | null,\n  ): N.ForStatement {\n    node.init = init;\n    this.semicolon(/* allowAsi */ false);\n    node.test = this.match(tt.semi) ? null : this.parseExpression();\n    this.semicolon(/* allowAsi */ false);\n    node.update = this.match(tt.parenR) ? null : this.parseExpression();\n    this.expect(tt.parenR);\n\n    // Parse the loop body.\n    node.body =\n      // For the smartPipelines plugin: Disable topic references from outer\n      // contexts within the loop body. They are permitted in test expressions,\n      // outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse the loop body.\n        this.parseStatement(),\n      );\n\n    this.scope.exit();\n    this.state.labels.pop();\n\n    return this.finishNode(node, \"ForStatement\");\n  }\n\n  // Parse a `for`/`in` and `for`/`of` loop, which are almost\n  // same from parser's perspective.\n\n  parseForIn(\n    this: Parser,\n    node: Undone<N.ForInOf>,\n    init: N.VariableDeclaration | N.AssignmentPattern,\n    awaitAt?: Position | null,\n  ): N.ForInOf {\n    const isForIn = this.match(tt._in);\n    this.next();\n\n    if (isForIn) {\n      if (awaitAt !== null) this.unexpected(awaitAt);\n    } else {\n      node.await = awaitAt !== null;\n    }\n\n    if (\n      init.type === \"VariableDeclaration\" &&\n      init.declarations[0].init != null &&\n      (!isForIn ||\n        !this.options.annexB ||\n        this.state.strict ||\n        init.kind !== \"var\" ||\n        init.declarations[0].id.type !== \"Identifier\")\n    ) {\n      this.raise(Errors.ForInOfLoopInitializer, init, {\n        type: isForIn ? \"ForInStatement\" : \"ForOfStatement\",\n      });\n    }\n\n    if (init.type === \"AssignmentPattern\") {\n      this.raise(Errors.InvalidLhs, init, {\n        ancestor: { type: \"ForStatement\" },\n      });\n    }\n\n    node.left = init;\n    node.right = isForIn\n      ? this.parseExpression()\n      : this.parseMaybeAssignAllowIn();\n    this.expect(tt.parenR);\n\n    // Parse the loop body.\n    node.body =\n      // For the smartPipelines plugin:\n      // Disable topic references from outer contexts within the loop body.\n      // They are permitted in test expressions, outside of the loop body.\n      this.withSmartMixTopicForbiddingContext(() =>\n        // Parse loop body.\n        this.parseStatement(),\n      );\n\n    this.scope.exit();\n    this.state.labels.pop();\n\n    return this.finishNode(node, isForIn ? \"ForInStatement\" : \"ForOfStatement\");\n  }\n\n  // Parse a list of variable declarations.\n\n  parseVar(\n    this: Parser,\n    node: Undone<N.VariableDeclaration>,\n    isFor: boolean,\n    kind: \"var\" | \"let\" | \"const\" | \"using\" | \"await using\",\n    allowMissingInitializer: boolean = false,\n  ): Undone<N.VariableDeclaration> {\n    const declarations: N.VariableDeclarator[] = (node.declarations = []);\n    node.kind = kind;\n    for (;;) {\n      const decl = this.startNode<N.VariableDeclarator>();\n      this.parseVarId(decl, kind);\n      decl.init = !this.eat(tt.eq)\n        ? null\n        : isFor\n          ? this.parseMaybeAssignDisallowIn()\n          : this.parseMaybeAssignAllowIn();\n\n      if (decl.init === null && !allowMissingInitializer) {\n        if (\n          decl.id.type !== \"Identifier\" &&\n          !(isFor && (this.match(tt._in) || this.isContextual(tt._of)))\n        ) {\n          this.raise(\n            Errors.DeclarationMissingInitializer,\n            this.state.lastTokEndLoc,\n            {\n              kind: \"destructuring\",\n            },\n          );\n        } else if (\n          (kind === \"const\" || kind === \"using\" || kind === \"await using\") &&\n          !(this.match(tt._in) || this.isContextual(tt._of))\n        ) {\n          this.raise(\n            Errors.DeclarationMissingInitializer,\n            this.state.lastTokEndLoc,\n            { kind },\n          );\n        }\n      }\n      declarations.push(this.finishNode(decl, \"VariableDeclarator\"));\n      if (!this.eat(tt.comma)) break;\n    }\n    return node;\n  }\n\n  parseVarId(\n    this: Parser,\n    decl: Undone<N.VariableDeclarator>,\n    kind: \"var\" | \"let\" | \"const\" | \"using\" | \"await using\",\n  ): void {\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(\n      id,\n      { type: \"VariableDeclarator\" },\n      kind === \"var\" ? BindingFlag.TYPE_VAR : BindingFlag.TYPE_LEXICAL,\n    );\n    decl.id = id;\n  }\n\n  // https://tc39.es/ecma262/#prod-AsyncFunctionExpression\n  parseAsyncFunctionExpression(\n    this: Parser,\n    node: Undone<N.FunctionExpression>,\n  ): N.FunctionExpression {\n    return this.parseFunction(node, ParseFunctionFlag.Async);\n  }\n\n  // Parse a function declaration or expression (depending on the\n  // ParseFunctionFlag.Declaration flag).\n\n  parseFunction<T extends N.NormalFunction>(\n    this: Parser,\n    node: Undone<T>,\n    flags: ParseFunctionFlag = ParseFunctionFlag.Expression,\n  ): T {\n    const hangingDeclaration = flags & ParseFunctionFlag.HangingDeclaration;\n    const isDeclaration = !!(flags & ParseFunctionFlag.Declaration);\n    const requireId = isDeclaration && !(flags & ParseFunctionFlag.NullableId);\n    const isAsync = !!(flags & ParseFunctionFlag.Async);\n\n    this.initFunction(node, isAsync);\n\n    if (this.match(tt.star)) {\n      if (hangingDeclaration) {\n        this.raise(\n          Errors.GeneratorInSingleStatementContext,\n          this.state.startLoc,\n        );\n      }\n      this.next(); // eat *\n      node.generator = true;\n    }\n\n    if (isDeclaration) {\n      node.id = this.parseFunctionId(requireId);\n    }\n\n    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n    this.state.maybeInArrowParameters = false;\n    this.scope.enter(ScopeFlag.FUNCTION);\n    this.prodParam.enter(functionFlags(isAsync, node.generator));\n\n    if (!isDeclaration) {\n      node.id = this.parseFunctionId();\n    }\n\n    this.parseFunctionParams(node, /* isConstructor */ false);\n\n    // For the smartPipelines plugin: Disable topic references from outer\n    // contexts within the function body. They are permitted in function\n    // default-parameter expressions, outside of the function body.\n    this.withSmartMixTopicForbiddingContext(() => {\n      // Parse the function body.\n      this.parseFunctionBodyAndFinish(\n        node,\n        isDeclaration ? \"FunctionDeclaration\" : \"FunctionExpression\",\n      );\n    });\n\n    this.prodParam.exit();\n    this.scope.exit();\n\n    if (isDeclaration && !hangingDeclaration) {\n      // We need to register this _after_ parsing the function body\n      // because of TypeScript body-less function declarations,\n      // which shouldn't be added to the scope.\n      this.registerFunctionStatementId(node as T);\n    }\n\n    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n    return node as T;\n  }\n\n  parseFunctionId(requireId?: boolean): N.Identifier | undefined | null {\n    return requireId || tokenIsIdentifier(this.state.type)\n      ? this.parseIdentifier()\n      : null;\n  }\n\n  parseFunctionParams(\n    this: Parser,\n    node: Undone<N.Function>,\n    isConstructor?: boolean,\n  ): void {\n    this.expect(tt.parenL);\n    this.expressionScope.enter(newParameterDeclarationScope());\n    node.params = this.parseBindingList(\n      tt.parenR,\n      charCodes.rightParenthesis,\n      ParseBindingListFlags.IS_FUNCTION_PARAMS |\n        (isConstructor ? ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS : 0),\n    );\n\n    this.expressionScope.exit();\n  }\n\n  registerFunctionStatementId(node: N.Function): void {\n    if (!node.id) return;\n\n    // If it is a regular function declaration in sloppy mode, then it is\n    // subject to Annex B semantics (BindingFlag.TYPE_FUNCTION). Otherwise, the binding\n    // mode depends on properties of the current scope (see\n    // treatFunctionsAsVar).\n    this.scope.declareName(\n      node.id.name,\n      !this.options.annexB || this.state.strict || node.generator || node.async\n        ? this.scope.treatFunctionsAsVar\n          ? BindingFlag.TYPE_VAR\n          : BindingFlag.TYPE_LEXICAL\n        : BindingFlag.TYPE_FUNCTION,\n      node.id.loc.start,\n    );\n  }\n\n  // Parse a class declaration or literal (depending on the\n  // `isStatement` parameter).\n\n  parseClass<T extends N.Class>(\n    this: Parser,\n    node: Undone<T>,\n    isStatement: /* T === ClassDeclaration */ boolean,\n    optionalId?: boolean,\n  ): T {\n    this.next(); // 'class'\n\n    // A class definition is always strict mode code.\n    const oldStrict = this.state.strict;\n    this.state.strict = true;\n\n    this.parseClassId(node, isStatement, optionalId);\n    this.parseClassSuper(node);\n    // this.state.strict is restored in parseClassBody\n    node.body = this.parseClassBody(!!node.superClass, oldStrict);\n\n    return this.finishNode(\n      node,\n      isStatement ? \"ClassDeclaration\" : \"ClassExpression\",\n    );\n  }\n\n  isClassProperty(): boolean {\n    return this.match(tt.eq) || this.match(tt.semi) || this.match(tt.braceR);\n  }\n\n  isClassMethod(): boolean {\n    return this.match(tt.parenL);\n  }\n\n  nameIsConstructor(key: N.Expression | N.PrivateName): boolean {\n    return (\n      (key.type === \"Identifier\" && key.name === \"constructor\") ||\n      (key.type === \"StringLiteral\" && key.value === \"constructor\")\n    );\n  }\n\n  isNonstaticConstructor(method: N.ClassMethod | N.ClassProperty): boolean {\n    return (\n      !method.computed && !method.static && this.nameIsConstructor(method.key)\n    );\n  }\n\n  // https://tc39.es/ecma262/#prod-ClassBody\n  parseClassBody(\n    this: Parser,\n    hadSuperClass: boolean,\n    oldStrict: boolean,\n  ): N.ClassBody {\n    this.classScope.enter();\n\n    const state: N.ParseClassMemberState = {\n      hadConstructor: false,\n      hadSuperClass,\n    };\n    let decorators: N.Decorator[] = [];\n    const classBody = this.startNode<N.ClassBody>();\n    classBody.body = [];\n\n    this.expect(tt.braceL);\n\n    // For the smartPipelines plugin: Disable topic references from outer\n    // contexts within the class body.\n    this.withSmartMixTopicForbiddingContext(() => {\n      // Parse the contents within the braces.\n      while (!this.match(tt.braceR)) {\n        if (this.eat(tt.semi)) {\n          if (decorators.length > 0) {\n            throw this.raise(\n              Errors.DecoratorSemicolon,\n              this.state.lastTokEndLoc,\n            );\n          }\n          continue;\n        }\n\n        if (this.match(tt.at)) {\n          decorators.push(this.parseDecorator());\n          continue;\n        }\n\n        const member = this.startNode<N.ClassMember>();\n\n        // steal the decorators if there are any\n        if (decorators.length) {\n          // @ts-expect-error Fixme\n          member.decorators = decorators;\n          this.resetStartLocationFromNode(member, decorators[0]);\n          decorators = [];\n        }\n\n        this.parseClassMember(classBody, member, state);\n\n        if (\n          // @ts-expect-error Fixme\n          member.kind === \"constructor\" &&\n          // @ts-expect-error Fixme\n          member.decorators &&\n          // @ts-expect-error Fixme\n          member.decorators.length > 0\n        ) {\n          this.raise(Errors.DecoratorConstructor, member);\n        }\n      }\n    });\n\n    this.state.strict = oldStrict;\n\n    this.next(); // eat `}`\n\n    if (decorators.length) {\n      throw this.raise(Errors.TrailingDecorator, this.state.startLoc);\n    }\n\n    this.classScope.exit();\n\n    return this.finishNode(classBody, \"ClassBody\");\n  }\n\n  // returns true if the current identifier is a method/field name,\n  // false if it is a modifier\n  parseClassMemberFromModifier(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<N.ClassMember>,\n  ): boolean {\n    const key = this.parseIdentifier(true); // eats the modifier\n\n    if (this.isClassMethod()) {\n      const method: N.ClassMethod = member as any;\n\n      // a method named like the modifier\n      method.kind = \"method\";\n      method.computed = false;\n      method.key = key;\n      method.static = false;\n      this.pushClassMethod(\n        classBody,\n        method,\n        false,\n        false,\n        /* isConstructor */ false,\n        false,\n      );\n      return true;\n    } else if (this.isClassProperty()) {\n      const prop: N.ClassProperty = member as any;\n\n      // a property named like the modifier\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\n  parseClassMember(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<N.ClassMember>,\n    state: N.ParseClassMemberState,\n  ): void {\n    const isStatic = this.isContextual(tt._static);\n\n    if (isStatic) {\n      if (this.parseClassMemberFromModifier(classBody, member)) {\n        // a class element named 'static'\n        return;\n      }\n      if (this.eat(tt.braceL)) {\n        this.parseClassStaticBlock(classBody, member as any as N.StaticBlock);\n        return;\n      }\n    }\n\n    this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);\n  }\n\n  parseClassMemberWithIsStatic(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<N.ClassMember>,\n    state: N.ParseClassMemberState,\n    isStatic: boolean,\n  ) {\n    const publicMethod = member as N.ClassMethod;\n    const privateMethod = member as N.ClassPrivateMethod;\n    const publicProp = member as N.ClassProperty;\n    const privateProp = member as N.ClassPrivateProperty;\n    const accessorProp = member as N.ClassAccessorProperty;\n\n    const method: typeof publicMethod | typeof privateMethod = publicMethod;\n    const publicMember: typeof publicMethod | typeof publicProp = publicMethod;\n\n    member.static = isStatic;\n    this.parsePropertyNamePrefixOperator(member);\n\n    if (this.eat(tt.star)) {\n      // a generator\n      method.kind = \"method\";\n      const isPrivateName = this.match(tt.privateName);\n      this.parseClassElementName(method);\n\n      if (isPrivateName) {\n        // Private generator method\n        this.pushClassPrivateMethod(classBody, privateMethod, true, false);\n        return;\n      }\n\n      if (this.isNonstaticConstructor(publicMethod)) {\n        this.raise(Errors.ConstructorIsGenerator, publicMethod.key);\n      }\n\n      this.pushClassMethod(\n        classBody,\n        publicMethod,\n        true,\n        false,\n        /* isConstructor */ false,\n        false,\n      );\n\n      return;\n    }\n\n    const isContextual =\n      !this.state.containsEsc && tokenIsIdentifier(this.state.type);\n    const key = this.parseClassElementName(member);\n    const maybeContextualKw = isContextual ? (key as N.Identifier).name : null;\n    const isPrivate = this.isPrivateName(key);\n    const maybeQuestionTokenStartLoc = this.state.startLoc;\n\n    this.parsePostMemberNameModifiers(publicMember);\n\n    if (this.isClassMethod()) {\n      method.kind = \"method\";\n\n      if (isPrivate) {\n        this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n        return;\n      }\n\n      // a normal method\n      const isConstructor = this.isNonstaticConstructor(publicMethod);\n      let allowsDirectSuper = false;\n      if (isConstructor) {\n        publicMethod.kind = \"constructor\";\n\n        // TypeScript allows multiple overloaded constructor declarations.\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\n      this.pushClassMethod(\n        classBody,\n        publicMethod,\n        false,\n        false,\n        isConstructor,\n        allowsDirectSuper,\n      );\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      // an async method\n      this.resetPreviousNodeTrailingComments(key);\n      const isGenerator = this.eat(tt.star);\n\n      if (publicMember.optional) {\n        this.unexpected(maybeQuestionTokenStartLoc);\n      }\n\n      method.kind = \"method\";\n      // The so-called parsed name would have been \"async\": get the real name.\n      const isPrivate = this.match(tt.privateName);\n      this.parseClassElementName(method);\n      this.parsePostMemberNameModifiers(publicMember);\n\n      if (isPrivate) {\n        // private async method\n        this.pushClassPrivateMethod(\n          classBody,\n          privateMethod,\n          isGenerator,\n          true,\n        );\n      } else {\n        if (this.isNonstaticConstructor(publicMethod)) {\n          this.raise(Errors.ConstructorIsAsync, publicMethod.key);\n        }\n\n        this.pushClassMethod(\n          classBody,\n          publicMethod,\n          isGenerator,\n          true,\n          /* isConstructor */ false,\n          false,\n        );\n      }\n    } else if (\n      (maybeContextualKw === \"get\" || maybeContextualKw === \"set\") &&\n      !(this.match(tt.star) && this.isLineTerminator())\n    ) {\n      // `get\\n*` is an uninitialized property named 'get' followed by a generator.\n      // a getter or setter\n      this.resetPreviousNodeTrailingComments(key);\n      method.kind = maybeContextualKw;\n      // The so-called parsed name would have been \"get/set\": get the real name.\n      const isPrivate = this.match(tt.privateName);\n      this.parseClassElementName(publicMethod);\n\n      if (isPrivate) {\n        // private getter/setter\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(\n          classBody,\n          publicMethod,\n          false,\n          false,\n          /* isConstructor */ false,\n          false,\n        );\n      }\n\n      this.checkGetterSetterParams(publicMethod);\n    } else if (maybeContextualKw === \"accessor\" && !this.isLineTerminator()) {\n      this.expectPlugin(\"decoratorAutoAccessors\");\n      this.resetPreviousNodeTrailingComments(key);\n\n      // The so-called parsed name would have been \"accessor\": get the real name.\n      const isPrivate = this.match(tt.privateName);\n      this.parseClassElementName(publicProp);\n      this.pushClassAccessorProperty(classBody, accessorProp, isPrivate);\n    } else if (this.isLineTerminator()) {\n      // an uninitialized class property (due to ASI, since we don't otherwise recognize the next token)\n      if (isPrivate) {\n        this.pushClassPrivateProperty(classBody, privateProp);\n      } else {\n        this.pushClassProperty(classBody, publicProp);\n      }\n    } else {\n      this.unexpected();\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-ClassElementName\n  parseClassElementName(\n    this: Parser,\n    member: Undone<N.ClassMember>,\n  ): N.Expression | N.Identifier | N.PrivateName {\n    const { type, value } = this.state;\n    if (\n      (type === tt.name || type === tt.string) &&\n      member.static &&\n      value === \"prototype\"\n    ) {\n      this.raise(Errors.StaticPrototype, this.state.startLoc);\n    }\n\n    if (type === tt.privateName) {\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\n    this.parsePropertyName(member);\n    return member.key;\n  }\n\n  parseClassStaticBlock(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    member: Undone<\n      N.StaticBlock & {\n        decorators?: Array<N.Decorator>;\n      }\n    >,\n  ) {\n    // Start a new lexical scope\n    this.scope.enter(\n      ScopeFlag.CLASS | ScopeFlag.STATIC_BLOCK | ScopeFlag.SUPER,\n    );\n    // Start a new scope with regard to loop labels\n    const oldLabels = this.state.labels;\n    this.state.labels = [];\n    // ClassStaticBlockStatementList:\n    //   StatementList[~Yield, ~Await, ~Return] opt\n    this.prodParam.enter(ParamKind.PARAM);\n    const body: N.Statement[] = (member.body = []);\n    this.parseBlockOrModuleBlockBody(body, undefined, false, tt.braceR);\n    this.prodParam.exit();\n    this.scope.exit();\n    this.state.labels = oldLabels;\n    classBody.body.push(this.finishNode<N.StaticBlock>(member, \"StaticBlock\"));\n    if (member.decorators?.length) {\n      this.raise(Errors.DecoratorStaticBlock, member);\n    }\n  }\n\n  pushClassProperty(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    prop: N.ClassProperty,\n  ) {\n    if (!prop.computed && this.nameIsConstructor(prop.key)) {\n      // Non-computed field, which is either an identifier named \"constructor\"\n      // or a string literal named \"constructor\"\n      this.raise(Errors.ConstructorClassField, prop.key);\n    }\n\n    classBody.body.push(this.parseClassProperty(prop));\n  }\n\n  pushClassPrivateProperty(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    prop: Undone<N.ClassPrivateProperty>,\n  ) {\n    const node = this.parseClassPrivateProperty(prop);\n    classBody.body.push(node);\n\n    this.classScope.declarePrivateName(\n      this.getPrivateNameSV(node.key),\n      ClassElementType.OTHER,\n      node.key.loc.start,\n    );\n  }\n\n  pushClassAccessorProperty(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    prop: N.ClassAccessorProperty,\n    isPrivate: boolean,\n  ) {\n    if (!isPrivate && !prop.computed && this.nameIsConstructor(prop.key)) {\n      // Non-computed field, which is either an identifier named \"constructor\"\n      // or a string literal named \"constructor\"\n      this.raise(Errors.ConstructorClassField, prop.key);\n    }\n\n    const node = this.parseClassAccessorProperty(prop);\n    classBody.body.push(node);\n\n    if (isPrivate) {\n      this.classScope.declarePrivateName(\n        this.getPrivateNameSV(node.key as N.PrivateName),\n        ClassElementType.OTHER,\n        node.key.loc.start,\n      );\n    }\n  }\n\n  pushClassMethod(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    method: Undone<N.ClassMethod>,\n    isGenerator: boolean,\n    isAsync: boolean,\n    isConstructor: boolean,\n    allowsDirectSuper: boolean,\n  ): void {\n    classBody.body.push(\n      this.parseMethod(\n        method,\n        isGenerator,\n        isAsync,\n        isConstructor,\n        allowsDirectSuper,\n        \"ClassMethod\",\n        true,\n      ),\n    );\n  }\n\n  pushClassPrivateMethod(\n    this: Parser,\n    classBody: Undone<N.ClassBody>,\n    method: Undone<N.ClassPrivateMethod>,\n    isGenerator: boolean,\n    isAsync: boolean,\n  ): void {\n    const node = this.parseMethod(\n      method,\n      isGenerator,\n      isAsync,\n      /* isConstructor */ false,\n      false,\n      \"ClassPrivateMethod\",\n      true,\n    );\n    classBody.body.push(node);\n\n    const kind =\n      node.kind === \"get\"\n        ? node.static\n          ? ClassElementType.STATIC_GETTER\n          : ClassElementType.INSTANCE_GETTER\n        : node.kind === \"set\"\n          ? node.static\n            ? ClassElementType.STATIC_SETTER\n            : ClassElementType.INSTANCE_SETTER\n          : ClassElementType.OTHER;\n    this.declareClassPrivateMethodInScope(node, kind);\n  }\n\n  declareClassPrivateMethodInScope(\n    node: Undone<N.ClassPrivateMethod | N.TSDeclareMethod>,\n    kind: number,\n  ) {\n    this.classScope.declarePrivateName(\n      this.getPrivateNameSV(node.key as N.PrivateName),\n      kind,\n      node.key.loc.start,\n    );\n  }\n\n  // Overridden in typescript.js\n  parsePostMemberNameModifiers(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    methodOrProp: Undone<N.ClassMethod | N.ClassProperty>,\n  ): void {}\n\n  // https://tc39.es/ecma262/#prod-FieldDefinition\n  parseClassPrivateProperty(\n    this: Parser,\n    node: Undone<N.ClassPrivateProperty>,\n  ): N.ClassPrivateProperty {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassPrivateProperty\");\n  }\n\n  // https://tc39.es/ecma262/#prod-FieldDefinition\n  parseClassProperty(this: Parser, node: N.ClassProperty): N.ClassProperty {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassProperty\");\n  }\n\n  parseClassAccessorProperty(\n    this: Parser,\n    node: N.ClassAccessorProperty,\n  ): N.ClassAccessorProperty {\n    this.parseInitializer(node);\n    this.semicolon();\n    return this.finishNode(node, \"ClassAccessorProperty\");\n  }\n\n  // https://tc39.es/ecma262/#prod-Initializer\n  parseInitializer(\n    this: Parser,\n    node: Undone<\n      N.ClassProperty | N.ClassPrivateProperty | N.ClassAccessorProperty\n    >,\n  ): void {\n    this.scope.enter(ScopeFlag.CLASS | ScopeFlag.SUPER);\n    this.expressionScope.enter(newExpressionScope());\n    this.prodParam.enter(ParamKind.PARAM);\n    node.value = this.eat(tt.eq) ? this.parseMaybeAssignAllowIn() : null;\n    this.expressionScope.exit();\n    this.prodParam.exit();\n    this.scope.exit();\n  }\n\n  parseClassId(\n    node: Undone<N.Class>,\n    isStatement: boolean,\n    optionalId?: boolean | null,\n    bindingType: BindingFlag = BindingFlag.TYPE_CLASS,\n  ): void {\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\n  // https://tc39.es/ecma262/#prod-ClassHeritage\n  parseClassSuper(this: Parser, node: Undone<N.Class>): void {\n    node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null;\n  }\n\n  // Parses module export declaration.\n  // https://tc39.es/ecma262/#prod-ExportDeclaration\n\n  parseExport(\n    this: Parser,\n    node: Undone<\n      | N.ExportDefaultDeclaration\n      | N.ExportAllDeclaration\n      | N.ExportNamedDeclaration\n    >,\n    decorators: N.Decorator[] | null,\n  ): N.AnyExport {\n    const maybeDefaultIdentifier = this.parseMaybeImportPhase(\n      node,\n      /* isExport */ true,\n    );\n    const hasDefault = this.maybeParseExportDefaultSpecifier(\n      node,\n      maybeDefaultIdentifier,\n    );\n    const parseAfterDefault = !hasDefault || this.eat(tt.comma);\n    const hasStar = parseAfterDefault && this.eatExportStar(node);\n    const hasNamespace =\n      hasStar && this.maybeParseExportNamespaceSpecifier(node);\n    const parseAfterNamespace =\n      parseAfterDefault && (!hasNamespace || this.eat(tt.comma));\n    const isFromRequired = hasDefault || hasStar;\n\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\n      return this.finishNode(node, \"ExportAllDeclaration\");\n    }\n\n    const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);\n\n    if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {\n      this.unexpected(null, tt.braceL);\n    }\n\n    if (hasNamespace && parseAfterNamespace) {\n      this.unexpected(null, tt._from);\n    }\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(\n        node as Undone<N.ExportNamedDeclaration>,\n        isFromRequired,\n      );\n    } else {\n      hasDeclaration = this.maybeParseExportDeclaration(\n        node as Undone<N.ExportNamedDeclaration>,\n      );\n    }\n\n    if (isFromRequired || hasSpecifiers || hasDeclaration) {\n      const node2 = node as Undone<N.ExportNamedDeclaration>;\n      this.checkExport(node2, true, false, !!node2.source);\n      if (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\n    if (this.eat(tt._default)) {\n      const node2 = node as Undone<N.ExportDefaultDeclaration>;\n      // export default ...\n      const decl = this.parseExportDefaultExpression();\n      node2.declaration = decl;\n\n      if (decl.type === \"ClassDeclaration\") {\n        this.maybeTakeDecorators(decorators, decl as N.ClassDeclaration, node2);\n      } else if (decorators) {\n        throw this.raise(Errors.UnsupportedDecoratorExport, node);\n      }\n\n      this.checkExport(node2, true, true);\n\n      return this.finishNode(node2, \"ExportDefaultDeclaration\");\n    }\n\n    this.unexpected(null, tt.braceL);\n  }\n\n  eatExportStar(\n    node: Undone<N.Node>,\n  ): node is Undone<N.ExportNamedDeclaration | N.ExportAllDeclaration> {\n    return this.eat(tt.star);\n  }\n\n  maybeParseExportDefaultSpecifier(\n    node: Undone<\n      | N.ExportDefaultDeclaration\n      | N.ExportAllDeclaration\n      | N.ExportNamedDeclaration\n    >,\n    maybeDefaultIdentifier: N.Identifier | null,\n  ): node is Undone<N.ExportNamedDeclaration> {\n    if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {\n      // export defaultObj ...\n      this.expectPlugin(\"exportDefaultFrom\", maybeDefaultIdentifier?.loc.start);\n      const id = maybeDefaultIdentifier || this.parseIdentifier(true);\n      const specifier = this.startNodeAtNode<N.ExportDefaultSpecifier>(id);\n      specifier.exported = id;\n      (node as Undone<N.ExportNamedDeclaration>).specifiers = [\n        this.finishNode(specifier, \"ExportDefaultSpecifier\"),\n      ];\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseExportNamespaceSpecifier(\n    node: Undone<N.ExportNamedDeclaration | N.ExportAllDeclaration>,\n  ): node is Undone<N.ExportNamedDeclaration> {\n    if (this.isContextual(tt._as)) {\n      (node as Undone<N.ExportNamedDeclaration>).specifiers ??= [];\n\n      const specifier = this.startNodeAt<N.ExportNamespaceSpecifier>(\n        this.state.lastTokStartLoc,\n      );\n\n      this.next();\n\n      specifier.exported = this.parseModuleExportName();\n      (node as Undone<N.ExportNamedDeclaration>).specifiers.push(\n        this.finishNode(specifier, \"ExportNamespaceSpecifier\"),\n      );\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseExportNamedSpecifiers(\n    node: Undone<N.Node>,\n  ): node is Undone<N.ExportNamedDeclaration> {\n    if (this.match(tt.braceL)) {\n      const node2 = node as Undone<N.ExportNamedDeclaration>;\n\n      if (!node2.specifiers) node2.specifiers = [];\n      const isTypeExport = node2.exportKind === \"type\";\n      node2.specifiers.push(...this.parseExportSpecifiers(isTypeExport));\n\n      node2.source = null;\n      node2.declaration = null;\n      if (!process.env.BABEL_8_BREAKING && this.hasPlugin(\"importAssertions\")) {\n        node2.assertions = [];\n      }\n\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseExportDeclaration(\n    this: Parser,\n    node: Undone<N.ExportNamedDeclaration>,\n  ): boolean {\n    if (this.shouldParseExportDeclaration()) {\n      node.specifiers = [];\n      node.source = null;\n      if (!process.env.BABEL_8_BREAKING && this.hasPlugin(\"importAssertions\")) {\n        node.assertions = [];\n      }\n      node.declaration = this.parseExportDeclaration(node);\n      return true;\n    }\n    return false;\n  }\n\n  isAsyncFunction(): boolean {\n    if (!this.isContextual(tt._async)) return false;\n    const next = this.nextTokenInLineStart();\n    return this.isUnparsedContextual(next, \"function\");\n  }\n\n  parseExportDefaultExpression(\n    this: Parser,\n  ): N.ExportDefaultDeclaration[\"declaration\"] {\n    const expr = this.startNode();\n\n    if (this.match(tt._function)) {\n      this.next();\n      return this.parseFunction(\n        expr as Undone<N.FunctionDeclaration>,\n        ParseFunctionFlag.Declaration | ParseFunctionFlag.NullableId,\n      );\n    } else if (this.isAsyncFunction()) {\n      this.next(); // eat 'async'\n      this.next(); // eat 'function'\n      return this.parseFunction(\n        expr as Undone<N.FunctionDeclaration>,\n        ParseFunctionFlag.Declaration |\n          ParseFunctionFlag.NullableId |\n          ParseFunctionFlag.Async,\n      );\n    }\n\n    if (this.match(tt._class)) {\n      return this.parseClass(expr as Undone<N.ClassExpression>, true, true);\n    }\n\n    if (this.match(tt.at)) {\n      if (\n        this.hasPlugin(\"decorators\") &&\n        this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") === true\n      ) {\n        this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);\n      }\n      return this.parseClass(\n        this.maybeTakeDecorators(\n          this.parseDecorators(false),\n          this.startNode<N.ClassDeclaration>(),\n        ),\n        true,\n        true,\n      );\n    }\n\n    if (this.match(tt._const) || this.match(tt._var) || this.isLet()) {\n      throw this.raise(Errors.UnsupportedDefaultExport, this.state.startLoc);\n    }\n\n    const res = this.parseMaybeAssignAllowIn();\n    this.semicolon();\n    return res;\n  }\n\n  // https://tc39.es/ecma262/#prod-ExportDeclaration\n  parseExportDeclaration(\n    this: Parser,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    node: Undone<N.ExportNamedDeclaration>,\n  ): N.Declaration | undefined | null {\n    if (this.match(tt._class)) {\n      const node = this.parseClass(\n        this.startNode<N.ClassDeclaration>(),\n        true,\n        false,\n      );\n      return node;\n    }\n    return this.parseStatementListItem() as N.Declaration;\n  }\n\n  isExportDefaultSpecifier(): boolean {\n    const { type } = this.state;\n    if (tokenIsIdentifier(type)) {\n      if ((type === tt._async && !this.state.containsEsc) || type === tt._let) {\n        return false;\n      }\n      if (\n        (type === tt._type || type === tt._interface) &&\n        !this.state.containsEsc\n      ) {\n        const { type: nextType } = this.lookahead();\n        // If we see any variable name other than `from` after `type` keyword,\n        // we consider it as flow/typescript type exports\n        // note that this approach may fail on some pedantic cases\n        // export type from = number\n        if (\n          (tokenIsIdentifier(nextType) && nextType !== tt._from) ||\n          nextType === tt.braceL\n        ) {\n          this.expectOnePlugin([\"flow\", \"typescript\"]);\n          return false;\n        }\n      }\n    } else if (!this.match(tt._default)) {\n      return false;\n    }\n\n    const next = this.nextTokenStart();\n    const hasFrom = this.isUnparsedContextual(next, \"from\");\n    if (\n      this.input.charCodeAt(next) === charCodes.comma ||\n      (tokenIsIdentifier(this.state.type) && hasFrom)\n    ) {\n      return true;\n    }\n    // lookahead again when `export default from` is seen\n    if (this.match(tt._default) && hasFrom) {\n      const nextAfterFrom = this.input.charCodeAt(\n        this.nextTokenStartSince(next + 4),\n      );\n      return (\n        nextAfterFrom === charCodes.quotationMark ||\n        nextAfterFrom === charCodes.apostrophe\n      );\n    }\n    return false;\n  }\n\n  parseExportFrom(\n    this: Parser,\n    node: Undone<N.ExportNamedDeclaration | N.ExportAllDeclaration>,\n    expect?: boolean,\n  ): void {\n    if (this.eatContextual(tt._from)) {\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\n    this.semicolon();\n  }\n\n  shouldParseExportDeclaration(): boolean {\n    const { type } = this.state;\n    if (type === tt.at) {\n      this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n      if (this.hasPlugin(\"decorators\")) {\n        if (\n          this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") === true\n        ) {\n          this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);\n        }\n\n        return true;\n      }\n    }\n\n    if (this.isContextual(tt._using)) {\n      this.raise(Errors.UsingDeclarationExport, this.state.startLoc);\n      return true;\n    }\n\n    if (this.isContextual(tt._await) && this.startsAwaitUsing()) {\n      this.raise(Errors.UsingDeclarationExport, this.state.startLoc);\n      return true;\n    }\n\n    return (\n      type === tt._var ||\n      type === tt._const ||\n      type === tt._function ||\n      type === tt._class ||\n      this.isLet() ||\n      this.isAsyncFunction()\n    );\n  }\n\n  checkExport(\n    node: Undone<\n      | N.ExportNamedDeclaration\n      | N.ExportAllDeclaration\n      | N.ExportDefaultDeclaration\n    >,\n    checkNames?: boolean,\n    isDefault?: boolean,\n    isFrom?: boolean,\n  ): void {\n    if (checkNames) {\n      // Check for duplicate exports\n      if (isDefault) {\n        // Default exports\n        this.checkDuplicateExports(node, \"default\");\n        if (this.hasPlugin(\"exportDefaultFrom\")) {\n          const declaration = (node as any as N.ExportDefaultDeclaration)\n            .declaration;\n          if (\n            declaration.type === \"Identifier\" &&\n            declaration.name === \"from\" &&\n            declaration.end - declaration.start === 4 && // does not contain escape\n            !declaration.extra?.parenthesized\n          ) {\n            this.raise(Errors.ExportDefaultFromAsIdentifier, declaration);\n          }\n        }\n        // @ts-expect-error node.specifiers may not exist\n      } else if (node.specifiers?.length) {\n        // Named exports\n        // @ts-expect-error node.specifiers may not exist\n        for (const specifier of node.specifiers) {\n          const { exported } = specifier;\n          const exportName =\n            exported.type === \"Identifier\" ? exported.name : exported.value;\n          this.checkDuplicateExports(specifier, exportName);\n          if (!isFrom && specifier.local) {\n            const { local } = specifier;\n            if (local.type !== \"Identifier\") {\n              this.raise(Errors.ExportBindingIsString, specifier, {\n                localName: local.value,\n                exportName,\n              });\n            } else {\n              // check for keywords used as local names\n              this.checkReservedWord(local.name, local.loc.start, true, false);\n              // check if export is defined\n              this.scope.checkLocalExport(local);\n            }\n          }\n        }\n      } else if ((node as Undone<N.ExportNamedDeclaration>).declaration) {\n        const decl = (node as Undone<N.ExportNamedDeclaration>).declaration;\n        // Exported declarations\n        if (\n          decl.type === \"FunctionDeclaration\" ||\n          decl.type === \"ClassDeclaration\"\n        ) {\n          const { id } = decl;\n          if (!id) throw new Error(\"Assertion failure\");\n\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\n  checkDeclaration(node: N.Pattern | N.ObjectProperty): void {\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      // @ts-expect-error migrate to Babel types\n      this.checkDeclaration(node.value);\n    } else if (node.type === \"RestElement\") {\n      this.checkDeclaration(node.argument);\n    } else if (node.type === \"AssignmentPattern\") {\n      this.checkDeclaration(node.left);\n    }\n  }\n\n  checkDuplicateExports(\n    node: Undone<\n      | N.Identifier\n      | N.StringLiteral\n      | N.ExportNamedDeclaration\n      | N.ExportSpecifier\n      | N.ExportDefaultSpecifier\n    >,\n    exportName: string,\n  ): void {\n    if (this.exportedIdentifiers.has(exportName)) {\n      if (exportName === \"default\") {\n        this.raise(Errors.DuplicateDefaultExport, node);\n      } else {\n        this.raise(Errors.DuplicateExport, node, { exportName });\n      }\n    }\n    this.exportedIdentifiers.add(exportName);\n  }\n\n  // Parses a comma-separated list of module exports.\n\n  parseExportSpecifiers(isInTypeExport: boolean): Array<N.ExportSpecifier> {\n    const nodes = [];\n    let first = true;\n\n    // export { x, y as z } [from '...']\n    this.expect(tt.braceL);\n\n    while (!this.eat(tt.braceR)) {\n      if (first) {\n        first = false;\n      } else {\n        this.expect(tt.comma);\n        if (this.eat(tt.braceR)) break;\n      }\n      const isMaybeTypeOnly = this.isContextual(tt._type);\n      const isString = this.match(tt.string);\n      const node = this.startNode<N.ExportSpecifier>();\n      node.local = this.parseModuleExportName() as N.Identifier;\n      nodes.push(\n        this.parseExportSpecifier(\n          node,\n          isString,\n          isInTypeExport,\n          isMaybeTypeOnly,\n        ),\n      );\n    }\n\n    return nodes;\n  }\n\n  parseExportSpecifier(\n    node: any,\n    isString: boolean,\n    /* eslint-disable @typescript-eslint/no-unused-vars -- used in TypeScript parser */\n    isInTypeExport: boolean,\n    isMaybeTypeOnly: boolean,\n    /* eslint-enable @typescript-eslint/no-unused-vars */\n  ): N.ExportSpecifier {\n    if (this.eatContextual(tt._as)) {\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<N.ExportSpecifier>(node, \"ExportSpecifier\");\n  }\n\n  // https://tc39.es/ecma262/#prod-ModuleExportName\n  parseModuleExportName(): N.StringLiteral | N.Identifier {\n    if (this.match(tt.string)) {\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\n  isJSONModuleImport(\n    node: Undone<\n      N.ExportAllDeclaration | N.ExportNamedDeclaration | N.ImportDeclaration\n    >,\n  ): boolean {\n    if (node.assertions != null) {\n      return node.assertions.some(({ key, value }) => {\n        return (\n          value.value === \"json\" &&\n          (key.type === \"Identifier\"\n            ? key.name === \"type\"\n            : key.value === \"type\")\n        );\n      });\n    }\n    return false;\n  }\n\n  checkImportReflection(node: Undone<N.ImportDeclaration>) {\n    const { specifiers } = node;\n    const singleBindingType =\n      specifiers.length === 1 ? specifiers[0].type : null;\n\n    if (node.phase === \"source\") {\n      if (singleBindingType !== \"ImportDefaultSpecifier\") {\n        this.raise(\n          Errors.SourcePhaseImportRequiresDefault,\n          specifiers[0].loc.start,\n        );\n      }\n    } else if (node.phase === \"defer\") {\n      if (singleBindingType !== \"ImportNamespaceSpecifier\") {\n        this.raise(\n          Errors.DeferImportRequiresNamespace,\n          specifiers[0].loc.start,\n        );\n      }\n    } else if (node.module) {\n      if (singleBindingType !== \"ImportDefaultSpecifier\") {\n        this.raise(Errors.ImportReflectionNotBinding, specifiers[0].loc.start);\n      }\n      if (node.assertions?.length > 0) {\n        this.raise(\n          Errors.ImportReflectionHasAssertion,\n          specifiers[0].loc.start,\n        );\n      }\n    }\n  }\n\n  checkJSONModuleImport(\n    node: Undone<\n      N.ExportAllDeclaration | N.ExportNamedDeclaration | N.ImportDeclaration\n    >,\n  ) {\n    // @ts-expect-error Fixme: node.type must be undefined because they are undone\n    if (this.isJSONModuleImport(node) && node.type !== \"ExportAllDeclaration\") {\n      // @ts-expect-error specifiers may not index node\n      const { specifiers } = node;\n      if (specifiers != null) {\n        // @ts-expect-error refine specifier types\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\"\n              ? imported.name !== \"default\"\n              : imported.value !== \"default\";\n          }\n        });\n        if (nonDefaultNamedSpecifier !== undefined) {\n          this.raise(\n            Errors.ImportJSONBindingNotDefault,\n            nonDefaultNamedSpecifier.loc.start,\n          );\n        }\n      }\n    }\n  }\n\n  isPotentialImportPhase(isExport: boolean): boolean {\n    if (isExport) return false;\n    return (\n      this.isContextual(tt._source) ||\n      this.isContextual(tt._defer) ||\n      (!process.env.BABEL_8_BREAKING && this.isContextual(tt._module))\n    );\n  }\n\n  applyImportPhase(\n    node: Undone<N.ImportDeclaration | N.ExportNamedDeclaration>,\n    isExport: boolean,\n    phase: string | null,\n    loc?: Position,\n  ): void {\n    if (isExport) {\n      if (!process.env.IS_PUBLISH) {\n        if (\n          (!process.env.BABEL_8_BREAKING && phase === \"module\") ||\n          phase === \"source\"\n        ) {\n          throw new Error(\n            `Assertion failure: export declarations do not support the '${phase}' phase.`,\n          );\n        }\n      }\n      return;\n    }\n\n    if (!process.env.BABEL_8_BREAKING && phase === \"module\") {\n      this.expectPlugin(\"importReflection\", loc);\n      (node as N.ImportDeclaration).module = true;\n    } else if (this.hasPlugin(\"importReflection\")) {\n      (node as N.ImportDeclaration).module = false;\n    }\n\n    if (phase === \"source\") {\n      this.expectPlugin(\"sourcePhaseImports\", loc);\n      (node as N.ImportDeclaration).phase = \"source\";\n    } else if (phase === \"defer\") {\n      this.expectPlugin(\"deferredImportEvaluation\", loc);\n      (node as N.ImportDeclaration).phase = \"defer\";\n    } else if (this.hasPlugin(\"sourcePhaseImports\")) {\n      (node as N.ImportDeclaration).phase = null;\n    }\n  }\n\n  /*\n   * Parse `source` in `import source x from \"x\"`, disambiguating\n   * `import source from \"x\"` and `import source from from \"x\"`.\n   *\n   * This function might return an identifier representing the `source`\n   * if it eats `source` and then discovers that it was the default import\n   * binding and not the import reflection.\n   *\n   * This function is also used to parse `import type` and `import typeof`\n   * in the TS and Flow plugins, and for parsing `import defer`.\n   */\n  parseMaybeImportPhase(\n    node: Undone<N.ImportDeclaration | N.TsImportEqualsDeclaration>,\n    isExport: boolean,\n  ): N.Identifier | null {\n    if (!this.isPotentialImportPhase(isExport)) {\n      this.applyImportPhase(\n        node as Undone<N.ImportDeclaration>,\n        isExport,\n        null,\n      );\n      return null;\n    }\n\n    const phaseIdentifier = this.parseIdentifier(true);\n\n    const { type } = this.state;\n    const isImportPhase = tokenIsKeywordOrIdentifier(type)\n      ? // OK: import <phase> x from \"foo\";\n        // OK: import <phase> from from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // NO: import <phase> from 'foo';\n        // With the module declarations proposals, we will need further disambiguation\n        // for `import module from from;`.\n        type !== tt._from || this.lookaheadCharCode() === charCodes.lowercaseF\n      : // OK: import <phase> { x } from \"foo\";\n        // OK: import <phase> x from \"foo\";\n        // OK: import <phase> * as T from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // OK: import <phase> \"foo\";\n        // The last one is invalid, we will continue parsing and throw\n        // an error later\n        type !== tt.comma;\n\n    if (isImportPhase) {\n      this.resetPreviousIdentifierLeadingComments(phaseIdentifier);\n      this.applyImportPhase(\n        node as Undone<N.ImportDeclaration>,\n        isExport,\n        phaseIdentifier.name,\n        phaseIdentifier.loc.start,\n      );\n      return null;\n    } else {\n      this.applyImportPhase(\n        node as Undone<N.ImportDeclaration>,\n        isExport,\n        null,\n      );\n      // `<phase>` is a default binding, return it to the main import declaration parser\n      return phaseIdentifier;\n    }\n  }\n\n  isPrecedingIdImportPhase(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    phase: string,\n  ) {\n    const { type } = this.state;\n    return tokenIsIdentifier(type)\n      ? // OK: import <phase> x from \"foo\";\n        // OK: import <phase> from from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // NO: import <phase> from 'foo';\n        // With the module declarations proposals, we will need further disambiguation\n        // for `import module from from;`.\n        type !== tt._from || this.lookaheadCharCode() === charCodes.lowercaseF\n      : // OK: import <phase> { x } from \"foo\";\n        // OK: import <phase> x from \"foo\";\n        // OK: import <phase> * as T from \"foo\";\n        // NO: import <phase> from \"foo\";\n        // OK: import <phase> \"foo\";\n        // The last one is invalid, we will continue parsing and throw\n        // an error later\n        type !== tt.comma;\n  }\n\n  // Parses import declaration.\n  // https://tc39.es/ecma262/#prod-ImportDeclaration\n\n  parseImport(this: Parser, node: Undone<N.ImportDeclaration>): N.AnyImport {\n    if (this.match(tt.string)) {\n      // import '...'\n      return this.parseImportSourceAndAttributes(node);\n    }\n\n    return this.parseImportSpecifiersAndAfter(\n      node,\n      this.parseMaybeImportPhase(node, /* isExport */ false),\n    );\n  }\n\n  parseImportSpecifiersAndAfter(\n    this: Parser,\n    node: Undone<N.ImportDeclaration>,\n    maybeDefaultIdentifier: N.Identifier | null,\n  ): N.AnyImport {\n    node.specifiers = [];\n\n    // check if we have a default import like\n    // import React from \"react\";\n    const hasDefault = this.maybeParseDefaultImportSpecifier(\n      node,\n      maybeDefaultIdentifier,\n    );\n    /* we are checking if we do not have a default import, then it is obvious that we need named imports\n     * import { get } from \"axios\";\n     * but if we do have a default import\n     * we need to check if we have a comma after that and\n     * that is where this `|| this.eat` condition comes into play\n     */\n    const parseNext = !hasDefault || this.eat(tt.comma);\n    // if we do have to parse the next set of specifiers, we first check for star imports\n    // import React, * from \"react\";\n    const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);\n    // now we check if we need to parse the next imports\n    // but only if they are not importing * (everything)\n    if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);\n    this.expectContextual(tt._from);\n\n    return this.parseImportSourceAndAttributes(node);\n  }\n\n  parseImportSourceAndAttributes(\n    this: Parser,\n    node: Undone<N.ImportDeclaration>,\n  ): N.AnyImport {\n    node.specifiers ??= [];\n    node.source = this.parseImportSource();\n    this.maybeParseImportAttributes(node);\n    this.checkImportReflection(node);\n    this.checkJSONModuleImport(node);\n\n    this.semicolon();\n    return this.finishNode(node, \"ImportDeclaration\");\n  }\n\n  parseImportSource(this: Parser): N.StringLiteral {\n    if (!this.match(tt.string)) this.unexpected();\n    return this.parseExprAtom() as N.StringLiteral;\n  }\n\n  parseImportSpecifierLocal<\n    T extends\n      | N.ImportSpecifier\n      | N.ImportDefaultSpecifier\n      | N.ImportNamespaceSpecifier,\n  >(\n    node: Undone<N.ImportDeclaration>,\n    specifier: Undone<T>,\n    type: T[\"type\"],\n  ): void {\n    specifier.local = this.parseIdentifier();\n    node.specifiers.push(this.finishImportSpecifier(specifier, type));\n  }\n\n  finishImportSpecifier<\n    T extends\n      | N.ImportSpecifier\n      | N.ImportDefaultSpecifier\n      | N.ImportNamespaceSpecifier,\n  >(\n    specifier: Undone<T>,\n    type: T[\"type\"],\n    bindingType: BindingFlag = BindingFlag.TYPE_LEXICAL,\n  ) {\n    this.checkLVal(specifier.local, { type }, bindingType);\n    return this.finishNode(specifier, type);\n  }\n\n  /**\n   * parse assert entries\n   *\n   * @see {@link https://tc39.es/proposal-import-attributes/#prod-WithEntries WithEntries}\n   */\n  parseImportAttributes(): N.ImportAttribute[] {\n    this.expect(tt.braceL);\n\n    const attrs = [];\n    const attrNames = new Set();\n\n    do {\n      if (this.match(tt.braceR)) {\n        break;\n      }\n\n      const node = this.startNode<N.ImportAttribute>();\n\n      // parse AssertionKey : IdentifierName, StringLiteral\n      const keyName = this.state.value;\n      // check if we already have an entry for an attribute\n      // if a duplicate entry is found, throw an error\n      // for now this logic will come into play only when someone declares `type` twice\n      if (attrNames.has(keyName)) {\n        this.raise(\n          Errors.ModuleAttributesWithDuplicateKeys,\n          this.state.startLoc,\n          {\n            key: keyName,\n          },\n        );\n      }\n      attrNames.add(keyName);\n      if (this.match(tt.string)) {\n        node.key = this.parseStringLiteral(keyName);\n      } else {\n        node.key = this.parseIdentifier(true);\n      }\n      this.expect(tt.colon);\n\n      if (!this.match(tt.string)) {\n        throw this.raise(\n          Errors.ModuleAttributeInvalidValue,\n          this.state.startLoc,\n        );\n      }\n      node.value = this.parseStringLiteral(this.state.value);\n      attrs.push(this.finishNode(node, \"ImportAttribute\"));\n    } while (this.eat(tt.comma));\n\n    this.expect(tt.braceR);\n\n    return attrs;\n  }\n\n  /**\n   * parse module attributes\n   * @deprecated It will be removed in Babel 8\n   */\n  parseModuleAttributes() {\n    const attrs: N.ImportAttribute[] = [];\n    const attributes = new Set();\n    do {\n      const node = this.startNode<N.ImportAttribute>();\n      node.key = this.parseIdentifier(true);\n\n      if (node.key.name !== \"type\") {\n        this.raise(Errors.ModuleAttributeDifferentFromType, node.key);\n      }\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(tt.colon);\n      if (!this.match(tt.string)) {\n        throw this.raise(\n          Errors.ModuleAttributeInvalidValue,\n          this.state.startLoc,\n        );\n      }\n      node.value = this.parseStringLiteral(this.state.value);\n      attrs.push(this.finishNode(node, \"ImportAttribute\"));\n    } while (this.eat(tt.comma));\n\n    return attrs;\n  }\n\n  maybeParseImportAttributes(\n    node: Undone<\n      N.ImportDeclaration | N.ExportNamedDeclaration | N.ExportAllDeclaration\n    >,\n  ) {\n    let attributes: N.ImportAttribute[];\n    if (!process.env.BABEL_8_BREAKING) {\n      // eslint-disable-next-line no-var\n      var useWith = false;\n    }\n\n    // https://tc39.es/proposal-import-attributes/#prod-WithClause\n    if (this.match(tt._with)) {\n      if (\n        this.hasPrecedingLineBreak() &&\n        this.lookaheadCharCode() === charCodes.leftParenthesis\n      ) {\n        // This will be parsed as a with statement, and we will throw a\n        // better error about it not being supported in strict mode.\n        return;\n      }\n\n      this.next(); // eat `with`\n\n      if (!process.env.BABEL_8_BREAKING && this.hasPlugin(\"moduleAttributes\")) {\n        attributes = this.parseModuleAttributes();\n      } else {\n        attributes = this.parseImportAttributes();\n      }\n      if (!process.env.BABEL_8_BREAKING) {\n        useWith = true;\n      }\n    } else if (this.isContextual(tt._assert) && !this.hasPrecedingLineBreak()) {\n      if (\n        !this.hasPlugin(\"deprecatedImportAssert\") &&\n        (process.env.BABEL_8_BREAKING || !this.hasPlugin(\"importAssertions\"))\n      ) {\n        this.raise(Errors.ImportAttributesUseAssert, this.state.startLoc);\n      }\n      if (process.env.BABEL_8_BREAKING || !this.hasPlugin(\"importAssertions\")) {\n        this.addExtra(node, \"deprecatedAssertSyntax\", true);\n      }\n      this.next(); // eat `assert`\n      attributes = this.parseImportAttributes();\n    } else {\n      attributes = [];\n    }\n\n    if (\n      !process.env.BABEL_8_BREAKING &&\n      !useWith &&\n      this.hasPlugin(\"importAssertions\")\n    ) {\n      node.assertions = attributes;\n    } else {\n      node.attributes = attributes;\n    }\n  }\n\n  maybeParseDefaultImportSpecifier(\n    node: Undone<N.ImportDeclaration>,\n    maybeDefaultIdentifier: N.Identifier | null,\n  ): boolean {\n    // import defaultObj, { x, y as z } from '...'\n    if (maybeDefaultIdentifier) {\n      const specifier = this.startNodeAtNode<N.ImportDefaultSpecifier>(\n        maybeDefaultIdentifier,\n      );\n      specifier.local = maybeDefaultIdentifier;\n      node.specifiers.push(\n        this.finishImportSpecifier(specifier, \"ImportDefaultSpecifier\"),\n      );\n      return true;\n    } else if (\n      // We allow keywords, and parseImportSpecifierLocal will report a recoverable error\n      tokenIsKeywordOrIdentifier(this.state.type)\n    ) {\n      this.parseImportSpecifierLocal(\n        node,\n        this.startNode<N.ImportDefaultSpecifier>(),\n        \"ImportDefaultSpecifier\",\n      );\n      return true;\n    }\n    return false;\n  }\n\n  maybeParseStarImportSpecifier(node: Undone<N.ImportDeclaration>): boolean {\n    if (this.match(tt.star)) {\n      const specifier = this.startNode<N.ImportNamespaceSpecifier>();\n      this.next();\n      this.expectContextual(tt._as);\n\n      this.parseImportSpecifierLocal(\n        node,\n        specifier,\n        \"ImportNamespaceSpecifier\",\n      );\n      return true;\n    }\n    return false;\n  }\n\n  parseNamedImportSpecifiers(node: Undone<N.ImportDeclaration>) {\n    let first = true;\n    this.expect(tt.braceL);\n    while (!this.eat(tt.braceR)) {\n      if (first) {\n        first = false;\n      } else {\n        // Detect an attempt to deep destructure\n        if (this.eat(tt.colon)) {\n          throw this.raise(Errors.DestructureNamedImport, this.state.startLoc);\n        }\n\n        this.expect(tt.comma);\n        if (this.eat(tt.braceR)) break;\n      }\n\n      const specifier = this.startNode<N.ImportSpecifier>();\n      const importedIsString = this.match(tt.string);\n      const isMaybeTypeOnly = this.isContextual(tt._type);\n      specifier.imported = this.parseModuleExportName();\n      const importSpecifier = this.parseImportSpecifier(\n        specifier,\n        importedIsString,\n        node.importKind === \"type\" || node.importKind === \"typeof\",\n        isMaybeTypeOnly,\n        undefined,\n      );\n      node.specifiers.push(importSpecifier);\n    }\n  }\n\n  // https://tc39.es/ecma262/#prod-ImportSpecifier\n  parseImportSpecifier(\n    specifier: Undone<N.ImportSpecifier>,\n    importedIsString: boolean,\n    /* used in TypeScript and Flow parser */\n    isInTypeOnlyImport: boolean,\n    isMaybeTypeOnly: boolean,\n    bindingType: BindingFlag | undefined,\n  ): N.ImportSpecifier {\n    if (this.eatContextual(tt._as)) {\n      specifier.local = this.parseIdentifier();\n    } else {\n      const { imported } = specifier;\n      if (importedIsString) {\n        throw this.raise(Errors.ImportBindingIsString, specifier, {\n          importName: (imported as N.StringLiteral).value,\n        });\n      }\n      this.checkReservedWord(\n        (imported as N.Identifier).name,\n        specifier.loc.start,\n        true,\n        true,\n      );\n      if (!specifier.local) {\n        specifier.local = cloneIdentifier(imported);\n      }\n    }\n    return this.finishImportSpecifier(\n      specifier,\n      \"ImportSpecifier\",\n      bindingType,\n    );\n  }\n\n  // This is used in flow and typescript plugin\n  // Determine whether a parameter is a this param\n  isThisParam(\n    param: N.Pattern | N.Identifier | N.TSParameterProperty,\n  ): boolean {\n    return param.type === \"Identifier\" && param.name === \"this\";\n  }\n}\n","import type { Options } from \"../options.ts\";\nimport type * as N from \"../types.ts\";\nimport { getOptions, OptionFlags } from \"../options.ts\";\nimport StatementParser from \"./statement.ts\";\nimport ScopeHandler from \"../util/scope.ts\";\n\nexport type PluginsMap = Map<\n  string,\n  {\n    [x: string]: any;\n  }\n>;\n\nexport default class Parser extends StatementParser {\n  // Forward-declaration so typescript plugin can override jsx plugin\n  // todo(flow->ts) - this probably can be removed\n  // abstract jsxParseOpeningElementAfterName(\n  //   node: N.JSXOpeningElement,\n  // ): N.JSXOpeningElement;\n\n  constructor(\n    options: Options | undefined | null,\n    input: string,\n    pluginsMap: PluginsMap,\n  ) {\n    options = getOptions(options);\n    super(options, input);\n\n    this.options = options;\n    this.initializeScopes();\n    this.plugins = pluginsMap;\n    this.filename = options.sourceFilename;\n    this.startIndex = options.startIndex;\n\n    let optionFlags = 0;\n    if (options.allowAwaitOutsideFunction) {\n      optionFlags |= OptionFlags.AllowAwaitOutsideFunction;\n    }\n    if (options.allowReturnOutsideFunction) {\n      optionFlags |= OptionFlags.AllowReturnOutsideFunction;\n    }\n    if (options.allowImportExportEverywhere) {\n      optionFlags |= OptionFlags.AllowImportExportEverywhere;\n    }\n    if (options.allowSuperOutsideMethod) {\n      optionFlags |= OptionFlags.AllowSuperOutsideMethod;\n    }\n    if (options.allowUndeclaredExports) {\n      optionFlags |= OptionFlags.AllowUndeclaredExports;\n    }\n    if (options.allowNewTargetOutsideFunction) {\n      optionFlags |= OptionFlags.AllowNewTargetOutsideFunction;\n    }\n    if (options.ranges) {\n      optionFlags |= OptionFlags.Ranges;\n    }\n    if (options.tokens) {\n      optionFlags |= OptionFlags.Tokens;\n    }\n    if (options.createImportExpressions) {\n      optionFlags |= OptionFlags.CreateImportExpressions;\n    }\n    if (options.createParenthesizedExpressions) {\n      optionFlags |= OptionFlags.CreateParenthesizedExpressions;\n    }\n    if (options.errorRecovery) {\n      optionFlags |= OptionFlags.ErrorRecovery;\n    }\n    if (options.attachComment) {\n      optionFlags |= OptionFlags.AttachComment;\n    }\n    if (options.annexB) {\n      optionFlags |= OptionFlags.AnnexB;\n    }\n\n    this.optionFlags = optionFlags;\n  }\n\n  // This can be overwritten, for example, by the TypeScript plugin.\n  getScopeHandler(): new (...args: any) => ScopeHandler {\n    return ScopeHandler;\n  }\n\n  parse(): N.File {\n    this.enterInitialScopes();\n    const file = this.startNode<N.File>();\n    const program = this.startNode<N.Program>();\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 as N.File;\n  }\n}\n","import type { Options } from \"./options.ts\";\nimport {\n  validatePlugins,\n  mixinPluginNames,\n  mixinPlugins,\n} from \"./plugin-utils.ts\";\nimport type {\n  PluginConfig as ParserPlugin,\n  FlowPluginOptions,\n  RecordAndTuplePluginOptions,\n  PipelineOperatorPluginOptions,\n} from \"./typings.ts\";\nimport Parser, { type PluginsMap } from \"./parser/index.ts\";\n\nimport type { ExportedTokenType } from \"./tokenizer/types.ts\";\nimport {\n  getExportedToken,\n  tt as internalTokenTypes,\n  type InternalTokenTypes,\n} from \"./tokenizer/types.ts\";\nexport type { Token } from \"./tokenizer/index.ts\";\n\nimport type { Expression, File } from \"./types.ts\";\nexport type { Expression, File };\n\nexport function parse(input: string, options?: Options): File {\n  if (options?.sourceType === \"unambiguous\") {\n    options = {\n      ...options,\n    };\n    try {\n      options.sourceType = \"module\";\n      const parser = getParser(options, input);\n      const ast = parser.parse();\n\n      if (parser.sawUnambiguousESM) {\n        return ast;\n      }\n\n      if (parser.ambiguousScriptDifferentAst) {\n        // Top level await introduces code which can be both a valid script and\n        // a valid module, but which produces different ASTs:\n        //    await\n        //    0\n        // can be parsed either as an AwaitExpression, or as two ExpressionStatements.\n        try {\n          options.sourceType = \"script\";\n          return getParser(options, input).parse();\n        } catch {}\n      } else {\n        // This is both a valid module and a valid script, but\n        // we parse it as a script by default\n        ast.program.sourceType = \"script\";\n      }\n\n      return ast;\n    } catch (moduleError) {\n      try {\n        options.sourceType = \"script\";\n        return getParser(options, input).parse();\n      } catch {}\n\n      throw moduleError;\n    }\n  } else {\n    return getParser(options, input).parse();\n  }\n}\n\nexport function parseExpression(input: string, options?: Options): Expression {\n  const parser = getParser(options, input);\n  if (parser.options.strictMode) {\n    parser.state.strict = true;\n  }\n  return parser.getExpression();\n}\n\nfunction generateExportedTokenTypes(\n  internalTokenTypes: InternalTokenTypes,\n): Record<string, ExportedTokenType> {\n  const tokenTypes: Record<string, ExportedTokenType> = {};\n  for (const typeName of Object.keys(\n    internalTokenTypes,\n  ) as (keyof InternalTokenTypes)[]) {\n    tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);\n  }\n  return tokenTypes;\n}\n\nexport const tokTypes = generateExportedTokenTypes(internalTokenTypes);\n\nfunction getParser(options: Options | undefined | null, input: string): Parser {\n  let cls = Parser;\n  const pluginsMap: PluginsMap = new Map();\n  if (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\n  return new cls(options, input, pluginsMap);\n}\n\nconst parserClassCache = new Map<string, new (...args: any) => Parser>();\n\n/** Get a Parser class with plugins applied. */\nfunction getParserClass(\n  pluginsMap: Map<string, any>,\n): new (...args: any) => Parser {\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      // @ts-expect-error todo(flow->ts)\n      cls = mixinPlugins[plugin](cls);\n    }\n    parserClassCache.set(key, cls);\n  }\n  return cls;\n}\n\nexport type {\n  FlowPluginOptions,\n  ParserPlugin,\n  PipelineOperatorPluginOptions,\n  RecordAndTuplePluginOptions,\n};\nexport type ParserOptions = Partial<Options>;\n","import { writeFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport type { Channel } from 'storybook/internal/channels';\nimport {\n\ttype RequestData,\n\ttype ResponseData,\n\tSTORY_RENDERED,\n} from 'storybook/internal/core-events';\nimport { readCsf } from 'storybook/internal/csf-tools';\nimport type { Options } from 'storybook/internal/types';\nimport { generateStoryCode } from './codegen/generate-story-code';\nimport { EVENTS } from './constants';\nimport type {\n\tSaveNewStoryRequestPayload,\n\tSaveNewStoryResponsePayload,\n} from './data';\n\nexport const experimental_serverChannel = async (\n\tchannel: Channel,\n\toptions: Options,\n) => {\n\tchannel.on(\n\t\tEVENTS.SAVE_NEW_STORY_REQUEST,\n\t\tasync ({ id, payload }: RequestData<SaveNewStoryRequestPayload>) => {\n\t\t\tconst { csfId, importPath, args, name, code } = payload;\n\n\t\t\ttry {\n\t\t\t\tconst sourceFilePath = join(process.cwd(), importPath);\n\n\t\t\t\tconst csf = await readCsf(sourceFilePath, {\n\t\t\t\t\tmakeTitle: (userTitle: string) => userTitle || 'myTitle',\n\t\t\t\t});\n\n\t\t\t\tconst { storyCode, newStoryId } = await generateStoryCode({\n\t\t\t\t\tcsf,\n\t\t\t\t\tcsfId,\n\t\t\t\t\tname,\n\t\t\t\t\targs,\n\t\t\t\t\tcode,\n\t\t\t\t});\n\n\t\t\t\t// Writing the CSF file should trigger HMR, which causes the story to rerender. Delay the\n\t\t\t\t// response until that happens, but don't wait too long.\n\t\t\t\tawait Promise.all([\n\t\t\t\t\tnew Promise<void>((resolve) => {\n\t\t\t\t\t\tchannel.on(STORY_RENDERED, resolve);\n\t\t\t\t\t\tsetTimeout(() => resolve(channel.off(STORY_RENDERED, resolve)), 3000);\n\t\t\t\t\t}),\n\t\t\t\t\twriteFile(sourceFilePath, storyCode),\n\t\t\t\t]);\n\n\t\t\t\tchannel.emit(EVENTS.SAVE_NEW_STORY_RESPONSE, {\n\t\t\t\t\tid,\n\t\t\t\t\tsuccess: true,\n\t\t\t\t\tpayload: { newStoryId },\n\t\t\t\t\terror: null,\n\t\t\t\t} satisfies ResponseData<SaveNewStoryResponsePayload>);\n\t\t\t} catch (error) {\n\t\t\t\tchannel.emit(EVENTS.SAVE_NEW_STORY_RESPONSE, {\n\t\t\t\t\tid,\n\t\t\t\t\tsuccess: false,\n\t\t\t\t\terror: error instanceof Error ? error.message : 'Unknown error',\n\t\t\t\t} satisfies ResponseData<SaveNewStoryResponsePayload>);\n\n\t\t\t\tif (error instanceof Error) {\n\t\t\t\t\tconsole.error(\n\t\t\t\t\t\t`Error saving story: ${error.stack || error.message || error.toString()}`,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t);\n\n\treturn channel;\n};\n","// Copied from storybook package\n// Except for \"updatePlayInCsfFile\" and \"updateImportsInCsfFile\"\n\nimport { parser, types as t, traverse } from 'storybook/internal/babel';\nimport type { CsfFile } from 'storybook/internal/csf-tools';\n\nclass SaveStoryError extends Error {}\n\n// biome-ignore lint/suspicious/noExplicitAny:\nexport function valueToAST<T>(literal: T): any {\n\tif (literal === null) {\n\t\treturn t.nullLiteral();\n\t}\n\tswitch (typeof literal) {\n\t\tcase 'function':\n\t\t\treturn parser.parse(literal.toString(), {\n\t\t\t\tallowReturnOutsideFunction: true,\n\t\t\t\tallowSuperOutsideMethod: true,\n\t\t\t\t// @ts-expect-error (it's the contents of the function, it's an expression, trust me)\n\t\t\t}).program.body[0]?.expression;\n\n\t\tcase 'number':\n\t\t\treturn t.numericLiteral(literal);\n\t\tcase 'string':\n\t\t\treturn t.stringLiteral(literal);\n\t\tcase 'boolean':\n\t\t\treturn t.booleanLiteral(literal);\n\t\tcase 'undefined':\n\t\t\treturn t.identifier('undefined');\n\t\tdefault:\n\t\t\tif (Array.isArray(literal)) {\n\t\t\t\treturn t.arrayExpression(literal.map(valueToAST));\n\t\t\t}\n\t\t\treturn t.objectExpression(\n\t\t\t\tObject.keys(literal)\n\t\t\t\t\t.filter((k) => {\n\t\t\t\t\t\t// @ts-expect-error (it's a completely unknown object)\n\t\t\t\t\t\tconst value = literal[k];\n\t\t\t\t\t\treturn typeof value !== 'undefined';\n\t\t\t\t\t})\n\t\t\t\t\t.map((k) => {\n\t\t\t\t\t\t// @ts-expect-error (it's a completely unknown object)\n\t\t\t\t\t\tconst value = literal[k];\n\t\t\t\t\t\treturn t.objectProperty(t.stringLiteral(k), valueToAST(value));\n\t\t\t\t\t}),\n\t\t\t);\n\t}\n}\n\nexport const updateArgsInCsfFile = async (\n\tnode: t.Node,\n\t// biome-ignore lint/suspicious/noExplicitAny:\n\tinput: Record<string, any>,\n) => {\n\tlet found = false;\n\tconst args = Object.fromEntries(\n\t\tObject.entries(input).map(([k, v]) => {\n\t\t\treturn [k, valueToAST(v)];\n\t\t}),\n\t);\n\n\t// detect CSF2 and throw\n\tif (t.isArrowFunctionExpression(node) || t.isCallExpression(node)) {\n\t\tthrow new SaveStoryError('Updating a CSF2 story is not supported');\n\t}\n\n\tif (t.isObjectExpression(node)) {\n\t\tconst properties = node.properties;\n\t\tconst argsProperty = properties.find((property) => {\n\t\t\tif (t.isObjectProperty(property)) {\n\t\t\t\tconst key = property.key;\n\t\t\t\treturn t.isIdentifier(key) && key.name === 'args';\n\t\t\t}\n\t\t\treturn false;\n\t\t});\n\n\t\tif (argsProperty) {\n\t\t\tif (t.isObjectProperty(argsProperty)) {\n\t\t\t\tconst a = argsProperty.value;\n\t\t\t\tif (t.isObjectExpression(a)) {\n\t\t\t\t\tfor (const p of a.properties) {\n\t\t\t\t\t\tif (t.isObjectProperty(p)) {\n\t\t\t\t\t\t\tconst key = p.key;\n\t\t\t\t\t\t\tif (t.isIdentifier(key) && key.name in args) {\n\t\t\t\t\t\t\t\tp.value = args[key.name];\n\t\t\t\t\t\t\t\tdelete args[key.name];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tconst remainder = Object.entries(args);\n\t\t\t\t\tif (Object.keys(args).length) {\n\t\t\t\t\t\tfor (const [key, value] of remainder) {\n\t\t\t\t\t\t\ta.properties.push(t.objectProperty(t.identifier(key), value));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif (Object.keys(args).length) {\n\t\t\t\tproperties.unshift(\n\t\t\t\t\tt.objectProperty(\n\t\t\t\t\t\tt.identifier('args'),\n\t\t\t\t\t\tt.objectExpression(\n\t\t\t\t\t\t\tObject.entries(args).map(([key, value]) =>\n\t\t\t\t\t\t\t\tt.objectProperty(t.identifier(key), value),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t),\n\t\t\t\t\t),\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t\treturn;\n\t}\n\n\ttraverse(node, {\n\t\tObjectExpression(path) {\n\t\t\tif (found) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tfound = true;\n\t\t\tconst properties = path.get('properties');\n\t\t\tconst argsProperty = properties.find((property) => {\n\t\t\t\tif (property.isObjectProperty()) {\n\t\t\t\t\tconst key = property.get('key');\n\t\t\t\t\treturn key.isIdentifier() && key.node.name === 'args';\n\t\t\t\t}\n\t\t\t\treturn false;\n\t\t\t});\n\n\t\t\tif (argsProperty) {\n\t\t\t\tif (argsProperty.isObjectProperty()) {\n\t\t\t\t\tconst a = argsProperty.get('value');\n\t\t\t\t\tif (a.isObjectExpression()) {\n\t\t\t\t\t\ta.traverse({\n\t\t\t\t\t\t\tObjectProperty(p) {\n\t\t\t\t\t\t\t\tconst key = p.get('key');\n\t\t\t\t\t\t\t\tif (key.isIdentifier() && key.node.name in args) {\n\t\t\t\t\t\t\t\t\tp.get('value').replaceWith(args[key.node.name]);\n\t\t\t\t\t\t\t\t\tdelete args[key.node.name];\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tnoScope: true,\n\t\t\t\t\t\t});\n\n\t\t\t\t\t\tconst remainder = Object.entries(args);\n\t\t\t\t\t\tif (Object.keys(args).length) {\n\t\t\t\t\t\t\tfor (const [key, value] of remainder) {\n\t\t\t\t\t\t\t\ta.pushContainer(\n\t\t\t\t\t\t\t\t\t'properties',\n\t\t\t\t\t\t\t\t\tt.objectProperty(t.identifier(key), value),\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (Object.keys(args).length) {\n\t\t\t\t\tpath.unshiftContainer(\n\t\t\t\t\t\t'properties',\n\t\t\t\t\t\tt.objectProperty(\n\t\t\t\t\t\t\tt.identifier('args'),\n\t\t\t\t\t\t\tt.objectExpression(\n\t\t\t\t\t\t\t\tObject.entries(args).map(([key, value]) =>\n\t\t\t\t\t\t\t\t\tt.objectProperty(t.identifier(key), value),\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t),\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\tnoScope: true,\n\t});\n};\n\ntype In = ReturnType<CsfFile['parse']>;\n\nexport const duplicateStoryWithNewName = (\n\tcsfFile: In,\n\toriginalStoryName: string,\n\tnewStoryName: string,\n) => {\n\tconst node = csfFile._storyExports[originalStoryName];\n\tconst cloned = t.cloneNode(node) as t.VariableDeclarator;\n\n\tif (!cloned) {\n\t\tthrow new SaveStoryError('cannot clone Node');\n\t}\n\n\tlet found = false;\n\ttraverse(cloned, {\n\t\tIdentifier(path) {\n\t\t\tif (found) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif (path.node.name === originalStoryName) {\n\t\t\t\tfound = true;\n\t\t\t\tpath.node.name = newStoryName;\n\t\t\t}\n\t\t},\n\t\tObjectProperty(path) {\n\t\t\tconst key = path.get('key');\n\t\t\t// Remove args and name properties when duplicating a story\n\t\t\tif (\n\t\t\t\tkey.isIdentifier() &&\n\t\t\t\t(key.node.name === 'args' || key.node.name === 'name')\n\t\t\t) {\n\t\t\t\tpath.remove();\n\t\t\t}\n\t\t},\n\n\t\tnoScope: true,\n\t});\n\n\t// detect CSF2 and throw\n\tif (\n\t\tt.isArrowFunctionExpression(cloned.init) ||\n\t\tt.isCallExpression(cloned.init)\n\t) {\n\t\tthrow new SaveStoryError(\n\t\t\t'Creating a new story based on a CSF2 story is not supported',\n\t\t);\n\t}\n\n\ttraverse(csfFile._ast, {\n\t\tProgram(path) {\n\t\t\tpath.pushContainer(\n\t\t\t\t'body',\n\t\t\t\tt.exportNamedDeclaration(t.variableDeclaration('const', [cloned])),\n\t\t\t);\n\t\t},\n\t});\n\n\treturn cloned;\n};\n\n// biome-ignore lint/suspicious/noExplicitAny:\nexport const parseArgs = (args: string): Record<string, any> =>\n\tJSON.parse(args, (_, value) => {\n\t\tif (value === '__sb_empty_function_arg__') {\n\t\t\treturn () => {};\n\t\t}\n\t\treturn value;\n\t});\n\n// Removes extra newlines between story properties. See https://github.com/benjamn/recast/issues/242\n// Only updates the part of the code for the story with the given name.\nexport const removeExtraNewlines = (code: string, name: string) => {\n\tconst anything = '([\\\\s\\\\S])'; // Multiline match for any character.\n\tconst newline = '(\\\\r\\\\n|\\\\r|\\\\n)'; // Either newlines or carriage returns may be used in the file.\n\tconst closing = `${newline}};${newline}`; // Marks the end of the story definition.\n\tconst regex = new RegExp(\n\t\t// Looks for an export by the given name, considers the first closing brace on its own line\n\t\t// to be the end of the story definition.\n\t\t`^(?<before>${anything}*)(?<story>export const ${name} =${anything}+?${closing})(?<after>${anything}*)$`,\n\t);\n\tconst { before, story, after } = code.match(regex)?.groups || {};\n\treturn story\n\t\t? before +\n\t\t\t\tstory.replaceAll(\n\t\t\t\t\t/(\\r\\n|\\r|\\n)(\\r\\n|\\r|\\n)([ \\t]*[a-z0-9_]+): /gi,\n\t\t\t\t\t'$2$3:',\n\t\t\t\t) +\n\t\t\t\tafter\n\t\t: code;\n};\n\nexport const updatePlayInCsfFile = async (node: t.Node, play: string[]) => {\n\tlet found = false;\n\n\t// detect CSF2 and throw\n\tif (t.isArrowFunctionExpression(node) || t.isCallExpression(node)) {\n\t\tthrow new SaveStoryError('Updating a CSF2 story is not supported');\n\t}\n\n\ttraverse(node, {\n\t\tObjectExpression(path) {\n\t\t\tif (found) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tfound = true;\n\t\t\tconst properties = path.get('properties');\n\t\t\tconst playProperty = properties.find((property) => {\n\t\t\t\tif (property.isObjectProperty()) {\n\t\t\t\t\tconst key = property.get('key');\n\t\t\t\t\treturn key.isIdentifier() && key.node.name === 'play';\n\t\t\t\t}\n\t\t\t\treturn false;\n\t\t\t});\n\n\t\t\tconst playExpression = t.arrowFunctionExpression(\n\t\t\t\t[t.identifier('async ({ canvasElement })')],\n\t\t\t\tt.blockStatement(\n\t\t\t\t\tpreparePlay(play).map((line) => t.expressionStatement(t.identifier(line))),\n\t\t\t\t),\n\t\t\t);\n\n\t\t\tif (playProperty) {\n\t\t\t\tif (playProperty.isObjectProperty()) {\n\t\t\t\t\tplayProperty.get('value').replaceWith(playExpression);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tpath.pushContainer(\n\t\t\t\t\t'properties',\n\t\t\t\t\tt.objectProperty(t.identifier('play'), playExpression),\n\t\t\t\t);\n\t\t\t}\n\t\t},\n\n\t\tnoScope: true,\n\t});\n};\n\nconst preparePlay = (play: string[]) => play.slice(1, -1).map(prepareLine);\n\nconst prepareLine = (line: string) => {\n\tlet result = line;\n\n\tif (result.endsWith(';')) {\n\t\tresult = result.slice(0, -1);\n\t}\n\n\tif (result.startsWith('\\t')) {\n\t\tresult = result.slice(1);\n\t}\n\n\treturn result;\n};\n\nexport const updateImportsInCsfFile = async (\n\tnode: t.Node,\n\timports: string[],\n) => {\n\tlet found = false;\n\n\t// detect CSF2 and throw an error\n\tif (t.isArrowFunctionExpression(node) || t.isCallExpression(node)) {\n\t\tthrow new SaveStoryError('Updating a CSF2 story is not supported');\n\t}\n\n\ttraverse(node, {\n\t\tProgram(path) {\n\t\t\tif (found) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tfound = true;\n\n\t\t\tconst parser = require('@babel/parser');\n\n\t\t\tconst packagesToImport = imports.map((importString) => {\n\t\t\t\tconst importStatement = parser.parse(importString, {\n\t\t\t\t\tsourceType: 'module',\n\t\t\t\t});\n\n\t\t\t\treturn {\n\t\t\t\t\timportNode: importStatement.program.body[0],\n\t\t\t\t\timportString,\n\t\t\t\t};\n\t\t\t});\n\n\t\t\tconst importNodesBySource = new Map<string, t.ImportDeclaration>();\n\t\t\tfor (const { node } of path.get('body')) {\n\t\t\t\tif (t.isImportDeclaration(node)) {\n\t\t\t\t\timportNodesBySource.set(node.source.value, node);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor (const { importNode, importString } of packagesToImport) {\n\t\t\t\tconst source = importNode.source.value;\n\t\t\t\tconst existingImport = importNodesBySource.get(source);\n\n\t\t\t\tif (existingImport) {\n\t\t\t\t\tconst specifiers = importNode.specifiers;\n\t\t\t\t\tconst existingSpecifiers = existingImport.specifiers;\n\n\t\t\t\t\tconst existingSpecifierNames = new Set(\n\t\t\t\t\t\texistingSpecifiers.map((s) => s.local.name),\n\t\t\t\t\t);\n\n\t\t\t\t\tfor (const specifier of specifiers) {\n\t\t\t\t\t\tif (!existingSpecifierNames.has(specifier.local.name)) {\n\t\t\t\t\t\t\texistingSpecifiers.push(specifier);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tif (t.isFile(node)) {\n\t\t\t\t\t\tnode.program.body.unshift(\n\t\t\t\t\t\t\tt.expressionStatement(\n\t\t\t\t\t\t\t\tt.identifier(\n\t\t\t\t\t\t\t\t\timportString.endsWith(';') ? importString.slice(0, -1) : importString,\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\tnoScope: true,\n\t});\n};\n","import { formatFileContent } from 'storybook/internal/common';\nimport { storyNameFromExport, toId } from 'storybook/internal/csf';\nimport { type CsfFile, printCsf } from 'storybook/internal/csf-tools';\nimport type { GeneratedCode } from './interactions-to-code';\nimport {\n\tduplicateStoryWithNewName,\n\tparseArgs,\n\tremoveExtraNewlines,\n\tupdateArgsInCsfFile,\n\tupdateImportsInCsfFile,\n\tupdatePlayInCsfFile,\n} from './save-story-utils';\n\nexport const generateStoryCode = async ({\n\tcsf,\n\tcsfId,\n\tname,\n\targs,\n\tcode,\n}: {\n\tcsf: CsfFile;\n\tcsfId: string;\n\tname: string;\n\targs: string;\n\tcode: GeneratedCode;\n}) => {\n\tconst parsed = csf.parse();\n\tconst stories = Object.entries(parsed._stories);\n\n\tconst [componentId, storyId] = csfId.split('--');\n\n\tconst originalStoryName = stories.find(([key, value]) =>\n\t\tvalue.id.endsWith(`--${storyId}`),\n\t)?.[0];\n\tif (!originalStoryName) {\n\t\tthrow new Error('Source story not found.');\n\t}\n\n\t// Format the new story name to follow Storybook naming conventions\n\tconst newStoryName = name\n\t\t.replace(/^[^a-z]/i, '')\n\t\t.replace(/^\\d+/, '')\n\t\t.replace(/[^a-z0-9-_ ]/gi, '')\n\t\t.replaceAll(/([-_ ]+[a-z0-9])/gi, (match) =>\n\t\t\tmatch.toUpperCase().replace(/[-_ ]/g, ''),\n\t\t); // from https://github.com/storybookjs/storybook/blob/1fdd2d6c675b81269125af5027e45a357c09f1fa/code/addons/controls/src/SaveStory.tsx#L122\n\n\t// Check if we're updating an existing story\n\tconst existingStoryToUpdate =\n\t\t// Check for story.name property matching our target\n\t\tstories.find(([key, story]) => {\n\t\t\tif (story.name === name) {\n\t\t\t\treturn true;\n\t\t\t}\n\n\t\t\treturn false;\n\t\t}) ||\n\t\t// If no story with matching name property, look for a story by its export name\n\t\tstories.find(([key]) => key === name || storyNameFromExport(key) === name);\n\n\tconst newStoryId = existingStoryToUpdate\n\t\t? toId(componentId, storyId)\n\t\t: toId(componentId, storyNameFromExport(newStoryName));\n\n\t// If we're updating an existing story, use that node, otherwise create a new one\n\tconst node = existingStoryToUpdate\n\t\t? csf._storyExports[existingStoryToUpdate[0]]\n\t\t: (csf._storyExports[newStoryName] ??\n\t\t\tduplicateStoryWithNewName(parsed, originalStoryName, newStoryName));\n\n\tawait updateArgsInCsfFile(node, args ? parseArgs(args) : {});\n\n\tawait updatePlayInCsfFile(\n\t\tnode,\n\t\tcode.play.map((line) => line.text),\n\t);\n\n\tawait updateImportsInCsfFile(\n\t\tcsf._ast,\n\t\tcode.imports.map((line) => line.text),\n\t);\n\n\treturn {\n\t\tstoryCode: await formatFileContent(\n\t\t\t'.',\n\t\t\tremoveExtraNewlines(printCsf(csf).code, newStoryName),\n\t\t),\n\t\tnewStoryId,\n\t};\n};\n","export const ADDON_ID = 'storybook/test-codegen';\nexport const PANEL_ID = `${ADDON_ID}/panel`;\nexport const PARAMETER = 'testCodegen';\n\nexport const IS_RECORDING_KEY = `${ADDON_ID}/is-recording`;\nexport const IS_ASSERTING_KEY = `${ADDON_ID}/is-asserting`;\n\nexport const EVENTS = {\n\tINTERACTION: `${ADDON_ID}/interaction`,\n\tSAVE_NEW_STORY_REQUEST: `${ADDON_ID}/save-new-story-request`,\n\tSAVE_NEW_STORY_RESPONSE: `${ADDON_ID}/save-new-story-response`,\n};\n\nexport const DOM_EVENTS = [\n\t'pointerdown',\n\t'dblclick',\n\t'keydown',\n\t'keyup',\n\t'input',\n\t'focus',\n];\n"]}