%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /home/opti/public_html/ncf/static/js/
Upload File :
Create Path :
Current File : /home/opti/public_html/ncf/static/js/10.04bffb74.chunk.js.map

{"version":3,"sources":["../../../../src/validators/generated/index.ts","../node_modules/swiper/esm/components/pagination/pagination.js","../../../../src/builders/generated/index.ts","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js","../../../src/definitions/index.ts","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/toConsumableArray.js","../../../src/definitions/utils.ts","../../../src/constants/index.ts","../../../src/clone/cloneNode.ts","../node_modules/regenerator-runtime/runtime.js","../../../src/validators/is.ts","../../../src/validators/isValidIdentifier.ts","../../src/index.ts","../../../src/retrievers/getBindingIdentifiers.ts","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/regenerator/index.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","../../../src/utils/shallowEqual.ts","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","../../../src/validators/validate.ts","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/slicedToArray.js","../../../src/validators/isType.ts","../../../src/utils/inherit.ts","../../../src/validators/buildMatchMemberExpression.ts","../../../src/validators/matchesPattern.ts","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/arrayLikeToArray.js","../../../src/definitions/core.ts","../../../src/validators/isPlaceholderType.ts","../../../src/definitions/placeholders.ts","../../../src/validators/isNode.ts","../../../../src/modifications/flow/removeTypeDuplicates.ts","../../../src/comments/addComments.ts","../../../src/comments/inheritInnerComments.ts","../../../src/comments/inheritLeadingComments.ts","../../../src/comments/inheritsComments.ts","../../../src/comments/inheritTrailingComments.ts","../../../src/converters/toBlock.ts","../../../src/converters/toIdentifier.ts","../../../src/modifications/removePropertiesDeep.ts","../../../src/traverse/traverseFast.ts","../../../src/modifications/removeProperties.ts","../../../src/validators/isLet.ts","../../../../src/validators/react/isReactComponent.ts","../../../../src/validators/react/isCompatTag.ts","../../../../src/builders/react/buildChildren.ts","../../../../src/utils/react/cleanJSXElementLiteralChild.ts","../../../src/builders/validateNode.ts","../node_modules/to-fast-properties/index.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/arrayWithHoles.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/nonIterableRest.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/iterableToArray.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/nonIterableSpread.js","../../src/identifier.ts","../../src/keyword.ts","../../../src/definitions/flow.ts","../../../src/definitions/jsx.ts","../../../src/definitions/misc.ts","../../../src/definitions/experimental.ts","../../../src/definitions/typescript.ts","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/defineProperty.js","../../../src/asserts/assertNode.ts","../../../../src/asserts/generated/index.ts","../../../../src/builders/flow/createTypeAnnotationBasedOnTypeof.ts","../../../../src/builders/flow/createFlowUnionType.ts","../../../../src/builders/typescript/createTSUnionType.ts","../../../../src/modifications/typescript/removeTypeDuplicates.ts","../../../../src/builders/generated/uppercase.js","../../../src/clone/clone.ts","../../../src/clone/cloneDeep.ts","../../../src/clone/cloneDeepWithoutLoc.ts","../../../src/clone/cloneWithoutLoc.ts","../../../src/comments/addComment.ts","../../../src/comments/removeComments.ts","../../../../src/constants/generated/index.ts","../../../src/converters/ensureBlock.ts","../../../src/converters/toBindingIdentifierName.ts","../../../src/converters/toComputedKey.ts","../../../src/converters/toExpression.ts","../../../src/converters/toKeyAlias.ts","../../../src/converters/toSequenceExpression.ts","../../../src/converters/gatherSequenceExpressions.ts","../../../src/converters/toStatement.ts","../../../src/converters/valueToNode.ts","../../../src/modifications/appendToMemberExpression.ts","../../../src/modifications/inherits.ts","../../../src/modifications/prependToMemberExpression.ts","../../../src/retrievers/getOuterBindingIdentifiers.ts","../../../src/traverse/traverse.ts","../../../src/validators/isBinding.ts","../../../src/validators/isBlockScoped.ts","../../../src/validators/isImmutable.ts","../../../src/validators/isNodesEquivalent.ts","../../../src/validators/isReferenced.ts","../../../src/validators/isScope.ts","../../../src/validators/isSpecifierDefault.ts","../../../src/validators/isValidES3Identifier.ts","../../../src/validators/isVar.ts"],"names":["node","opts","type","nodeType","expectedNode","console","trace","_extends","Object","assign","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","Pagination","update","swiper","rtl","params","pagination","el","$el","current","slidesLength","virtual","enabled","slides","total","loop","Math","ceil","loopedSlides","slidesPerGroup","snapGrid","activeIndex","paginationType","snapIndex","bullets","firstIndex","lastIndex","midIndex","dynamicBullets","bulletSize","eq","isHorizontal","css","dynamicMainBullets","undefined","previousIndex","dynamicBulletIndex","min","removeClass","bulletActiveClass","each","bullet","$bullet","$","bulletIndex","index","addClass","prev","next","$firstDisplayedBullet","$lastDisplayedBullet","_i","dynamicBulletsLength","bulletsOffset","offsetProp","find","classesToSelector","currentClass","text","formatFractionCurrent","totalClass","formatFractionTotal","progressbarDirection","progressbarOpposite","scale","scaleX","scaleY","progressbarFillClass","transform","transition","speed","renderCustom","html","emit","watchOverflow","isLocked","lockClass","render","paginationHTML","numberOfBullets","freeMode","renderBullet","bulletClass","bulletElement","renderFraction","renderProgressbar","init","createElementIfNotDefined","createElements","uniqueNavElements","clickable","clickableClass","modifierClass","progressbarOppositeClass","on","e","preventDefault","slideTo","extend","destroy","hiddenClass","off","name","hideOnClick","number","create","bindModuleMethods","activeIndexChange","snapIndexChange","slidesLengthChange","snapGridLengthChange","click","targetEl","hasClass","navigation","nextEl","prevEl","toggleClass","elements","elementType","body","async","expression","operator","left","right","argument","value","object","callee","directives","label","_arguments","param","typeAnnotation","decorators","computed","_static","static","id","superClass","typeParameters","kind","generator","test","consequent","alternate","extends","declaration","specifiers","supertype","members","explicitType","hasUnknownMembers","exported","local","program","comments","tokens","_await","await","rest","returnType","imported","objectType","indexType","types","openingElement","closingElement","children","selfClosing","openingFragment","closingFragment","property","namespace","attributes","optional","meta","numericLiteral","properties","shorthand","indexers","callProperties","internalSlots","exact","variance","method","proto","impltype","sourceType","interpreter","sourceFile","qualification","pattern","flags","regExpLiteral","restElement","expressions","spreadElement","discriminant","cases","tag","quasi","tail","quasis","block","handler","finalizer","parameters","checkType","extendsType","trueType","falseType","initializer","moduleReference","isExport","qualifier","typeParameter","literal","nameType","parameter","elementTypes","constraint","_default","default","parameterName","asserts","exprName","typeName","bound","prefix","declarations","delegate","unsupportedIterableToArray","module","exports","o","allowArrayLike","it","Symbol","iterator","Array","isArray","F","s","n","done","_e","f","TypeError","err","normalCompletion","didErr","step","_e2","toFastProperties","VISITOR_KEYS","ALIAS_KEYS","FLIPPED_ALIAS_KEYS","NODE_FIELDS","BUILDER_KEYS","DEPRECATED_KEYS","PLACEHOLDERS_ALIAS","PLACEHOLDERS_FLIPPED_ALIAS","TYPES","concat","keys","arrayWithoutHoles","iterableToArray","nonIterableSpread","arr","validate","val","getType","validateChild","JSON","stringify","oneOfNodeOrValueTypes","values","indexOf","oneOf","shape","errors","validateField","error","push","message","join","shapeOf","aliases","defined","inherits","store","slice","additional","filter","a","includes","unshift","defineType","arrayOfType","typeIs","NODE_PARENT_VALIDATIONS","assertNodeType","arrayOf","chain","assertValueType","assertEach","callback","validator","subkey","v","process","BABEL_TYPES_8_BREAKING","oneOfNodeTypes","fns","fn","chainOf","Error","validTypeOpts","validFieldKeys","fields","getOwnPropertyNames","field","def","visitor","builder","k","deprecatedAlias","forEach","alias","LOGICAL_OPERATORS","BOOLEAN_NUMBER_BINARY_OPERATORS","EQUALITY_BINARY_OPERATORS","COMPARISON_BINARY_OPERATORS","BOOLEAN_BINARY_OPERATORS","NUMBER_BINARY_OPERATORS","BINARY_OPERATORS","ASSIGNMENT_OPERATORS","map","op","BOOLEAN_UNARY_OPERATORS","NUMBER_UNARY_OPERATORS","STRING_UNARY_OPERATORS","UNARY_OPERATORS","force","BLOCK_SCOPED_SYMBOL","for","NOT_LOCAL_BINDING","deep","withoutLoc","cloneNodeInternal","Map","has","Function","bind","cloneIfNode","obj","commentsCache","cloneIfNodeOrArray","newNode","isIdentifier","isFile","maybeCloneComments","loc","leadingComments","innerComments","trailingComments","extra","comment","cache","get","ret","set","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","defineProperty","enumerable","configurable","writable","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","context","Context","_invoke","state","GenStateSuspendedStart","arg","GenStateExecuting","GenStateCompleted","doneResult","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","GenStateSuspendedYield","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","invoke","resolve","reject","result","__await","then","unwrapped","previousPromise","callInvokeWithMethodAndArg","info","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","constructor","displayName","isGeneratorFunction","genFun","ctor","mark","setPrototypeOf","__proto__","awrap","Promise","iter","toString","reverse","pop","skipTempReset","charAt","stop","rootRecord","rval","exception","handle","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","reserved","isKeyword","isStrictReservedWord","isIdentifierName","react","isReactComponent","isCompatTag","buildChildren","getBindingIdentifiers","duplicates","outerOnly","search","ids","shift","isExportDeclaration","isExportAllDeclaration","isFunctionDeclaration","isFunctionExpression","nodes","isDeclaration","DeclareClass","DeclareFunction","DeclareModule","DeclareVariable","DeclareInterface","DeclareTypeAlias","DeclareOpaqueType","InterfaceDeclaration","TypeAlias","OpaqueType","CatchClause","LabeledStatement","UnaryExpression","AssignmentExpression","ImportSpecifier","ImportNamespaceSpecifier","ImportDefaultSpecifier","ImportDeclaration","ExportSpecifier","ExportNamespaceSpecifier","ExportDefaultSpecifier","FunctionDeclaration","FunctionExpression","ArrowFunctionExpression","ObjectMethod","ClassMethod","ClassPrivateMethod","ForInStatement","ForOfStatement","ClassDeclaration","ClassExpression","RestElement","UpdateExpression","ObjectProperty","AssignmentPattern","ArrayPattern","ObjectPattern","VariableDeclaration","VariableDeclarator","asyncGeneratorStep","gen","_next","_throw","_asyncToGenerator","args","actual","expected","arrayLikeToArray","minLen","from","arrayWithHoles","iterableToArrayLimit","nonIterableRest","targetType","child","parent","Set","Boolean","match","allowPartial","parts","split","member","isMemberExpression","j","isStringLiteral","isThisExpression","len","arr2","defineAliasedType","assertNodeOrValueType","identifier","assertOneOf","inOp","typeArguments","functionCommon","functionTypeAnnotationCommon","functionDeclarationCommon","declare","predicate","patternLikeCommon","exec","parentKey","nonComp","isReservedWord","invalid","normal","listKey","UPDATE_OPERATORS","without","definite","superTypeParameters","implements","mixins","abstract","exportKind","validateOptional","assertions","sourced","sourceless","lval","importKind","classMethodOrPropertyCommon","accessibility","override","classMethodOrDeclareMethodCommon","access","assertShape","raw","cooked","unterminatedCalled","readStringContents","unterminated","strictNumericEscape","invalidEscapeSequence","numericSeparatorInEscapeSequence","unexpectedNumericSeparator","invalidDigit","invalidCodePoint","str","firstInvalidLoc","assertOptionalChainStart","readonly","placeholderType","PLACEHOLDERS","Declaration","Pattern","removeTypeDuplicates","generics","bases","typeGroups","isAnyTypeAnnotation","isFlowBaseAnnotation","isUnionTypeAnnotation","add","isGenericTypeAnnotation","getQualifiedName","existing","baseType","genericName","isBlockStatement","blockNodes","isEmptyStatement","isStatement","isFunction","returnStatement","expressionStatement","blockStatement","input","c","isIdentifierChar","codePointAt","replace","toUpperCase","tree","removeProperties","traverseFast","enter","subNode","preserveComments","CLEAR_KEYS","CLEAR_KEYS_PLUS_COMMENTS","symbols","getOwnPropertySymbols","sym","COMMENT_KEYS","isVariableDeclaration","tagName","isJSXText","isJSXExpressionContainer","isJSXEmptyExpression","lines","lastNonEmptyLine","line","isFirstLine","isLastLine","isLastNonEmptyLine","trimmedLine","stringLiteral","fastProto","FastObject","_arr","_n","_d","_s","isFirst","cp","charCodeAt","trail","isIdentifierStart","nonASCIIidentifierStartChars","nonASCIIidentifierChars","nonASCIIidentifierStart","RegExp","nonASCIIidentifier","astralIdentifierStartCodes","astralIdentifierCodes","isInAstralSet","code","pos","String","fromCharCode","word","keywords","inModule","isStrictBindOnlyReservedWord","reservedWords","reservedWordsStrictSet","reservedWordsStrictBindSet","lineStart","curLine","initialPos","initialLineStart","initialCurLine","out","chunkStart","ch","isStringEnd","res","readEscapedChar","containsInvalid","forbiddenNumericSeparatorSiblings","decBinOct","hex","isAllowedNumericSeparatorSibling","bin","oct","dec","inTemplate","throwOnInvalid","readHexChar","readCodePoint","fromCodePoint","startPos","octalStr","octal","parseInt","forceLen","readInt","radix","allowNumSeparator","bailOnError","start","forbiddenSiblings","isAllowedSibling","Infinity","Number","defineInterfaceishType","validateType","validateOptionalType","inexact","validateArrayOfType","bool","tSFunctionTypeAnnotationCommon","signatureDeclarationCommon","callConstructSignatureDeclaration","namedTypeElementCommon","fnOrCtrBase","unionOrIntersection","unaryExpression","unaryOperator","TSTypeExpression","const","global","in","assert","stringTypeAnnotation","numberTypeAnnotation","voidTypeAnnotation","booleanTypeAnnotation","genericTypeAnnotation","anyTypeAnnotation","flattened","unionTypeAnnotation","typeAnnotations","isTSTypeAnnotation","tsUnionType","isTSAnyKeyword","isTSBaseType","isTSUnionType","isTSTypeReference","content","STANDARDIZED_TYPES","EXPRESSION_TYPES","BINARY_TYPES","SCOPABLE_TYPES","BLOCKPARENT_TYPES","BLOCK_TYPES","STATEMENT_TYPES","TERMINATORLESS_TYPES","COMPLETIONSTATEMENT_TYPES","CONDITIONAL_TYPES","LOOP_TYPES","WHILE_TYPES","EXPRESSIONWRAPPER_TYPES","FOR_TYPES","FORXSTATEMENT_TYPES","FUNCTION_TYPES","FUNCTIONPARENT_TYPES","PUREISH_TYPES","DECLARATION_TYPES","PATTERNLIKE_TYPES","LVAL_TYPES","TSENTITYNAME_TYPES","LITERAL_TYPES","IMMUTABLE_TYPES","USERWHITESPACABLE_TYPES","METHOD_TYPES","OBJECTMEMBER_TYPES","PROPERTY_TYPES","UNARYLIKE_TYPES","PATTERN_TYPES","CLASS_TYPES","MODULEDECLARATION_TYPES","EXPORTDECLARATION_TYPES","MODULESPECIFIER_TYPES","ACCESSOR_TYPES","PRIVATE_TYPES","FLOW_TYPES","FLOWTYPE_TYPES","FLOWBASEANNOTATION_TYPES","FLOWDECLARATION_TYPES","FLOWPREDICATE_TYPES","ENUMBODY_TYPES","ENUMMEMBER_TYPES","JSX_TYPES","MISCELLANEOUS_TYPES","TYPESCRIPT_TYPES","TSTYPEELEMENT_TYPES","TSTYPE_TYPES","TSBASETYPE_TYPES","isExpressionStatement","isExpression","isClass","toKeyAlias","increment","uid","MAX_SAFE_INTEGER","scope","declars","declar","gatherSequenceExpressions","exprs","ensureLastUndefined","bindings","assignmentExpression","isIfStatement","buildUndefinedNode","conditionalExpression","sequenceExpression","ignore","newType","mustHaveId","isAssignmentExpression","valueToNode","booleanLiteral","nullLiteral","numerator","isFinite","abs","binaryExpression","is","objectToString","isRegExp","arrayExpression","isPlainObject","props","nodeKey","objectProperty","objectExpression","append","memberExpression","INHERIT_KEYS","prepend","isSuper","handlers","exit","traverseSimpleImpl","ancestors","grandparent","isClassDeclaration","isNodesEquivalent","b","visitorKeys","val_a","val_b","isCatchClause","isPattern","isScopable","specifier","isImportDefaultSpecifier","RESERVED_WORDS_ES3_ONLY"],"mappings":"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GAAG,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,IAAI,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,EAAE,IAAI,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,IAAI,GAAG,IAAI,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,IAAI,EAAE,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,KAAK,GAAG,GAAG,KAAK,GAAG,EAAE,KAAK,IAAI,KAAK,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,IAAI,KAAK,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,KAAK,GAAG,EAAE,EAAE,IAAI,GAAG,IAAI,GAAG,GAAG,EAAE,GAAG,EAAE,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,KAAK,MAAM,GAAG,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,KAAK,KAAK,IAAI,KAAK,KAAK,EAAE,MAEt9CC,EAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,IAAI,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,IAAI,GAAG,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,KAAK,E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","file":"static/js/10.04bffb74.chunk.js","sourcesContent":["/*\n * This file is auto-generated! Do not modify it directly.\n * To re-generate run 'make build'\n */\nimport shallowEqual from \"../../utils/shallowEqual\";\nimport type * as t from \"../..\";\n\nexport function isArrayExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ArrayExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ArrayExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isAssignmentExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.AssignmentExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"AssignmentExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBinaryExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.BinaryExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"BinaryExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isInterpreterDirective(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.InterpreterDirective {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"InterpreterDirective\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDirective(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Directive {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"Directive\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDirectiveLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DirectiveLiteral {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DirectiveLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBlockStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.BlockStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"BlockStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBreakStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.BreakStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"BreakStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isCallExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.CallExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"CallExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isCatchClause(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.CatchClause {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"CatchClause\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isConditionalExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ConditionalExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ConditionalExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isContinueStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ContinueStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ContinueStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDebuggerStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DebuggerStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DebuggerStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDoWhileStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DoWhileStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DoWhileStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEmptyStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EmptyStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EmptyStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExpressionStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ExpressionStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ExpressionStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFile(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.File {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"File\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isForInStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ForInStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ForInStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isForStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ForStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ForStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFunctionDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.FunctionDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"FunctionDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFunctionExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.FunctionExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"FunctionExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isIdentifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Identifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"Identifier\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isIfStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.IfStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"IfStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isLabeledStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.LabeledStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"LabeledStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isStringLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.StringLiteral {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"StringLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isNumericLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.NumericLiteral {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"NumericLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isNullLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.NullLiteral {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"NullLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBooleanLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.BooleanLiteral {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"BooleanLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isRegExpLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.RegExpLiteral {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"RegExpLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isLogicalExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.LogicalExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"LogicalExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isMemberExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.MemberExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"MemberExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isNewExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.NewExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"NewExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isProgram(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Program {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"Program\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ObjectExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectMethod(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectMethod {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ObjectMethod\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectProperty {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ObjectProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isRestElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.RestElement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"RestElement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isReturnStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ReturnStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ReturnStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isSequenceExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.SequenceExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"SequenceExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isParenthesizedExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ParenthesizedExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ParenthesizedExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isSwitchCase(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.SwitchCase {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"SwitchCase\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isSwitchStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.SwitchStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"SwitchStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isThisExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ThisExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ThisExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isThrowStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ThrowStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ThrowStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTryStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TryStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TryStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isUnaryExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.UnaryExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"UnaryExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isUpdateExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.UpdateExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"UpdateExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isVariableDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.VariableDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"VariableDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isVariableDeclarator(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.VariableDeclarator {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"VariableDeclarator\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isWhileStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.WhileStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"WhileStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isWithStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.WithStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"WithStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isAssignmentPattern(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.AssignmentPattern {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"AssignmentPattern\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isArrayPattern(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ArrayPattern {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ArrayPattern\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isArrowFunctionExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ArrowFunctionExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ArrowFunctionExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isClassBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ClassBody {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ClassBody\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isClassExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ClassExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ClassExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isClassDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ClassDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ClassDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExportAllDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ExportAllDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ExportAllDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExportDefaultDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ExportDefaultDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ExportDefaultDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExportNamedDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ExportNamedDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ExportNamedDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExportSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ExportSpecifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ExportSpecifier\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isForOfStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ForOfStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ForOfStatement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isImportDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ImportDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ImportDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isImportDefaultSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ImportDefaultSpecifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ImportDefaultSpecifier\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isImportNamespaceSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ImportNamespaceSpecifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ImportNamespaceSpecifier\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isImportSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ImportSpecifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ImportSpecifier\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isMetaProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.MetaProperty {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"MetaProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isClassMethod(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ClassMethod {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ClassMethod\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectPattern(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectPattern {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ObjectPattern\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isSpreadElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.SpreadElement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"SpreadElement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isSuper(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Super {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"Super\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTaggedTemplateExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TaggedTemplateExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TaggedTemplateExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTemplateElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TemplateElement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TemplateElement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTemplateLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TemplateLiteral {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TemplateLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isYieldExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.YieldExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"YieldExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isAwaitExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.AwaitExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"AwaitExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isImport(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Import {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"Import\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBigIntLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.BigIntLiteral {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"BigIntLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExportNamespaceSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ExportNamespaceSpecifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ExportNamespaceSpecifier\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isOptionalMemberExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.OptionalMemberExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"OptionalMemberExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isOptionalCallExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.OptionalCallExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"OptionalCallExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isClassProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ClassProperty {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ClassProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isClassAccessorProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ClassAccessorProperty {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ClassAccessorProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isClassPrivateProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ClassPrivateProperty {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ClassPrivateProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isClassPrivateMethod(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ClassPrivateMethod {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ClassPrivateMethod\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isPrivateName(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.PrivateName {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"PrivateName\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isStaticBlock(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.StaticBlock {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"StaticBlock\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isAnyTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.AnyTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"AnyTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isArrayTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ArrayTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ArrayTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBooleanTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.BooleanTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"BooleanTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBooleanLiteralTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.BooleanLiteralTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"BooleanLiteralTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isNullLiteralTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.NullLiteralTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"NullLiteralTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isClassImplements(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ClassImplements {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ClassImplements\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclareClass(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclareClass {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclareClass\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclareFunction(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclareFunction {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclareFunction\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclareInterface(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclareInterface {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclareInterface\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclareModule(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclareModule {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclareModule\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclareModuleExports(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclareModuleExports {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclareModuleExports\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclareTypeAlias(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclareTypeAlias {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclareTypeAlias\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclareOpaqueType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclareOpaqueType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclareOpaqueType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclareVariable(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclareVariable {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclareVariable\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclareExportDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclareExportDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclareExportDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclareExportAllDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclareExportAllDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclareExportAllDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclaredPredicate(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DeclaredPredicate {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DeclaredPredicate\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExistsTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ExistsTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ExistsTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFunctionTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.FunctionTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"FunctionTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFunctionTypeParam(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.FunctionTypeParam {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"FunctionTypeParam\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isGenericTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.GenericTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"GenericTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isInferredPredicate(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.InferredPredicate {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"InferredPredicate\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isInterfaceExtends(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.InterfaceExtends {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"InterfaceExtends\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isInterfaceDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.InterfaceDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"InterfaceDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isInterfaceTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.InterfaceTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"InterfaceTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isIntersectionTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.IntersectionTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"IntersectionTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isMixedTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.MixedTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"MixedTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEmptyTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EmptyTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EmptyTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isNullableTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.NullableTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"NullableTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isNumberLiteralTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.NumberLiteralTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"NumberLiteralTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isNumberTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.NumberTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"NumberTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ObjectTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectTypeInternalSlot(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectTypeInternalSlot {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ObjectTypeInternalSlot\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectTypeCallProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectTypeCallProperty {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ObjectTypeCallProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectTypeIndexer(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectTypeIndexer {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ObjectTypeIndexer\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectTypeProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectTypeProperty {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ObjectTypeProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectTypeSpreadProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectTypeSpreadProperty {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ObjectTypeSpreadProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isOpaqueType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.OpaqueType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"OpaqueType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isQualifiedTypeIdentifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.QualifiedTypeIdentifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"QualifiedTypeIdentifier\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isStringLiteralTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.StringLiteralTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"StringLiteralTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isStringTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.StringTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"StringTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isSymbolTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.SymbolTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"SymbolTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isThisTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ThisTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ThisTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTupleTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TupleTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TupleTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTypeofTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TypeofTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TypeofTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTypeAlias(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TypeAlias {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TypeAlias\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTypeCastExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TypeCastExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TypeCastExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTypeParameter(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TypeParameter {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TypeParameter\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTypeParameterDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TypeParameterDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TypeParameterDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTypeParameterInstantiation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TypeParameterInstantiation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TypeParameterInstantiation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isUnionTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.UnionTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"UnionTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isVariance(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Variance {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"Variance\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isVoidTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.VoidTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"VoidTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EnumDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumBooleanBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumBooleanBody {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EnumBooleanBody\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumNumberBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumNumberBody {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EnumNumberBody\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumStringBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumStringBody {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EnumStringBody\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumSymbolBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumSymbolBody {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EnumSymbolBody\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumBooleanMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumBooleanMember {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EnumBooleanMember\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumNumberMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumNumberMember {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EnumNumberMember\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumStringMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumStringMember {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EnumStringMember\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumDefaultedMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumDefaultedMember {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"EnumDefaultedMember\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isIndexedAccessType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.IndexedAccessType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"IndexedAccessType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isOptionalIndexedAccessType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.OptionalIndexedAccessType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"OptionalIndexedAccessType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXAttribute(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXAttribute {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXAttribute\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXClosingElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXClosingElement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXClosingElement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXElement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXElement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXEmptyExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXEmptyExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXEmptyExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXExpressionContainer(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXExpressionContainer {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXExpressionContainer\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXSpreadChild(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXSpreadChild {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXSpreadChild\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXIdentifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXIdentifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXIdentifier\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXMemberExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXMemberExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXMemberExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXNamespacedName(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXNamespacedName {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXNamespacedName\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXOpeningElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXOpeningElement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXOpeningElement\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXSpreadAttribute(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXSpreadAttribute {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXSpreadAttribute\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXText(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXText {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXText\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXFragment(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXFragment {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXFragment\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXOpeningFragment(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXOpeningFragment {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXOpeningFragment\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSXClosingFragment(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSXClosingFragment {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"JSXClosingFragment\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isNoop(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Noop {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"Noop\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isPlaceholder(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Placeholder {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"Placeholder\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isV8IntrinsicIdentifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.V8IntrinsicIdentifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"V8IntrinsicIdentifier\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isArgumentPlaceholder(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ArgumentPlaceholder {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ArgumentPlaceholder\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBindExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.BindExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"BindExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isImportAttribute(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ImportAttribute {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ImportAttribute\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDecorator(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Decorator {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"Decorator\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDoExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DoExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DoExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExportDefaultSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ExportDefaultSpecifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ExportDefaultSpecifier\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isRecordExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.RecordExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"RecordExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTupleExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TupleExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TupleExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDecimalLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.DecimalLiteral {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"DecimalLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isModuleExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ModuleExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"ModuleExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTopicReference(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TopicReference {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TopicReference\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isPipelineTopicExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.PipelineTopicExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"PipelineTopicExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isPipelineBareFunction(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.PipelineBareFunction {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"PipelineBareFunction\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isPipelinePrimaryTopicReference(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.PipelinePrimaryTopicReference {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"PipelinePrimaryTopicReference\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSParameterProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSParameterProperty {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSParameterProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSDeclareFunction(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSDeclareFunction {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSDeclareFunction\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSDeclareMethod(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSDeclareMethod {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSDeclareMethod\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSQualifiedName(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSQualifiedName {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSQualifiedName\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSCallSignatureDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSCallSignatureDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSCallSignatureDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSConstructSignatureDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSConstructSignatureDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSConstructSignatureDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSPropertySignature(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSPropertySignature {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSPropertySignature\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSMethodSignature(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSMethodSignature {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSMethodSignature\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSIndexSignature(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSIndexSignature {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSIndexSignature\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSAnyKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSAnyKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSAnyKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSBooleanKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSBooleanKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSBooleanKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSBigIntKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSBigIntKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSBigIntKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSIntrinsicKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSIntrinsicKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSIntrinsicKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSNeverKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSNeverKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSNeverKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSNullKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSNullKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSNullKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSNumberKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSNumberKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSNumberKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSObjectKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSObjectKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSObjectKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSStringKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSStringKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSStringKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSSymbolKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSSymbolKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSSymbolKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSUndefinedKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSUndefinedKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSUndefinedKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSUnknownKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSUnknownKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSUnknownKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSVoidKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSVoidKeyword {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSVoidKeyword\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSThisType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSThisType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSThisType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSFunctionType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSFunctionType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSFunctionType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSConstructorType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSConstructorType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSConstructorType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeReference(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeReference {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypeReference\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypePredicate(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypePredicate {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypePredicate\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeQuery(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeQuery {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypeQuery\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeLiteral {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypeLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSArrayType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSArrayType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSArrayType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTupleType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTupleType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTupleType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSOptionalType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSOptionalType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSOptionalType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSRestType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSRestType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSRestType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSNamedTupleMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSNamedTupleMember {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSNamedTupleMember\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSUnionType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSUnionType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSUnionType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSIntersectionType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSIntersectionType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSIntersectionType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSConditionalType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSConditionalType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSConditionalType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSInferType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSInferType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSInferType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSParenthesizedType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSParenthesizedType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSParenthesizedType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeOperator(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeOperator {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypeOperator\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSIndexedAccessType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSIndexedAccessType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSIndexedAccessType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSMappedType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSMappedType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSMappedType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSLiteralType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSLiteralType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSLiteralType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSExpressionWithTypeArguments(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSExpressionWithTypeArguments {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSExpressionWithTypeArguments\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSInterfaceDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSInterfaceDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSInterfaceDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSInterfaceBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSInterfaceBody {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSInterfaceBody\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeAliasDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeAliasDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypeAliasDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSInstantiationExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSInstantiationExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSInstantiationExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSAsExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSAsExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSAsExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSSatisfiesExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSSatisfiesExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSSatisfiesExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeAssertion(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeAssertion {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypeAssertion\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSEnumDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSEnumDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSEnumDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSEnumMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSEnumMember {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSEnumMember\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSModuleDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSModuleDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSModuleDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSModuleBlock(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSModuleBlock {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSModuleBlock\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSImportType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSImportType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSImportType\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSImportEqualsDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSImportEqualsDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSImportEqualsDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSExternalModuleReference(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSExternalModuleReference {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSExternalModuleReference\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSNonNullExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSNonNullExpression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSNonNullExpression\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSExportAssignment(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSExportAssignment {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSExportAssignment\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSNamespaceExportDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSNamespaceExportDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSNamespaceExportDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypeAnnotation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeParameterInstantiation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeParameterInstantiation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypeParameterInstantiation\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeParameterDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeParameterDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypeParameterDeclaration\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeParameter(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeParameter {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"TSTypeParameter\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isStandardized(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Standardized {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ArrayExpression\" === nodeType ||\n    \"AssignmentExpression\" === nodeType ||\n    \"BinaryExpression\" === nodeType ||\n    \"InterpreterDirective\" === nodeType ||\n    \"Directive\" === nodeType ||\n    \"DirectiveLiteral\" === nodeType ||\n    \"BlockStatement\" === nodeType ||\n    \"BreakStatement\" === nodeType ||\n    \"CallExpression\" === nodeType ||\n    \"CatchClause\" === nodeType ||\n    \"ConditionalExpression\" === nodeType ||\n    \"ContinueStatement\" === nodeType ||\n    \"DebuggerStatement\" === nodeType ||\n    \"DoWhileStatement\" === nodeType ||\n    \"EmptyStatement\" === nodeType ||\n    \"ExpressionStatement\" === nodeType ||\n    \"File\" === nodeType ||\n    \"ForInStatement\" === nodeType ||\n    \"ForStatement\" === nodeType ||\n    \"FunctionDeclaration\" === nodeType ||\n    \"FunctionExpression\" === nodeType ||\n    \"Identifier\" === nodeType ||\n    \"IfStatement\" === nodeType ||\n    \"LabeledStatement\" === nodeType ||\n    \"StringLiteral\" === nodeType ||\n    \"NumericLiteral\" === nodeType ||\n    \"NullLiteral\" === nodeType ||\n    \"BooleanLiteral\" === nodeType ||\n    \"RegExpLiteral\" === nodeType ||\n    \"LogicalExpression\" === nodeType ||\n    \"MemberExpression\" === nodeType ||\n    \"NewExpression\" === nodeType ||\n    \"Program\" === nodeType ||\n    \"ObjectExpression\" === nodeType ||\n    \"ObjectMethod\" === nodeType ||\n    \"ObjectProperty\" === nodeType ||\n    \"RestElement\" === nodeType ||\n    \"ReturnStatement\" === nodeType ||\n    \"SequenceExpression\" === nodeType ||\n    \"ParenthesizedExpression\" === nodeType ||\n    \"SwitchCase\" === nodeType ||\n    \"SwitchStatement\" === nodeType ||\n    \"ThisExpression\" === nodeType ||\n    \"ThrowStatement\" === nodeType ||\n    \"TryStatement\" === nodeType ||\n    \"UnaryExpression\" === nodeType ||\n    \"UpdateExpression\" === nodeType ||\n    \"VariableDeclaration\" === nodeType ||\n    \"VariableDeclarator\" === nodeType ||\n    \"WhileStatement\" === nodeType ||\n    \"WithStatement\" === nodeType ||\n    \"AssignmentPattern\" === nodeType ||\n    \"ArrayPattern\" === nodeType ||\n    \"ArrowFunctionExpression\" === nodeType ||\n    \"ClassBody\" === nodeType ||\n    \"ClassExpression\" === nodeType ||\n    \"ClassDeclaration\" === nodeType ||\n    \"ExportAllDeclaration\" === nodeType ||\n    \"ExportDefaultDeclaration\" === nodeType ||\n    \"ExportNamedDeclaration\" === nodeType ||\n    \"ExportSpecifier\" === nodeType ||\n    \"ForOfStatement\" === nodeType ||\n    \"ImportDeclaration\" === nodeType ||\n    \"ImportDefaultSpecifier\" === nodeType ||\n    \"ImportNamespaceSpecifier\" === nodeType ||\n    \"ImportSpecifier\" === nodeType ||\n    \"MetaProperty\" === nodeType ||\n    \"ClassMethod\" === nodeType ||\n    \"ObjectPattern\" === nodeType ||\n    \"SpreadElement\" === nodeType ||\n    \"Super\" === nodeType ||\n    \"TaggedTemplateExpression\" === nodeType ||\n    \"TemplateElement\" === nodeType ||\n    \"TemplateLiteral\" === nodeType ||\n    \"YieldExpression\" === nodeType ||\n    \"AwaitExpression\" === nodeType ||\n    \"Import\" === nodeType ||\n    \"BigIntLiteral\" === nodeType ||\n    \"ExportNamespaceSpecifier\" === nodeType ||\n    \"OptionalMemberExpression\" === nodeType ||\n    \"OptionalCallExpression\" === nodeType ||\n    \"ClassProperty\" === nodeType ||\n    \"ClassAccessorProperty\" === nodeType ||\n    \"ClassPrivateProperty\" === nodeType ||\n    \"ClassPrivateMethod\" === nodeType ||\n    \"PrivateName\" === nodeType ||\n    \"StaticBlock\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      (\"Identifier\" === (node as t.Placeholder).expectedNode ||\n        \"StringLiteral\" === (node as t.Placeholder).expectedNode ||\n        \"BlockStatement\" === (node as t.Placeholder).expectedNode ||\n        \"ClassBody\" === (node as t.Placeholder).expectedNode))\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Expression {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ArrayExpression\" === nodeType ||\n    \"AssignmentExpression\" === nodeType ||\n    \"BinaryExpression\" === nodeType ||\n    \"CallExpression\" === nodeType ||\n    \"ConditionalExpression\" === nodeType ||\n    \"FunctionExpression\" === nodeType ||\n    \"Identifier\" === nodeType ||\n    \"StringLiteral\" === nodeType ||\n    \"NumericLiteral\" === nodeType ||\n    \"NullLiteral\" === nodeType ||\n    \"BooleanLiteral\" === nodeType ||\n    \"RegExpLiteral\" === nodeType ||\n    \"LogicalExpression\" === nodeType ||\n    \"MemberExpression\" === nodeType ||\n    \"NewExpression\" === nodeType ||\n    \"ObjectExpression\" === nodeType ||\n    \"SequenceExpression\" === nodeType ||\n    \"ParenthesizedExpression\" === nodeType ||\n    \"ThisExpression\" === nodeType ||\n    \"UnaryExpression\" === nodeType ||\n    \"UpdateExpression\" === nodeType ||\n    \"ArrowFunctionExpression\" === nodeType ||\n    \"ClassExpression\" === nodeType ||\n    \"MetaProperty\" === nodeType ||\n    \"Super\" === nodeType ||\n    \"TaggedTemplateExpression\" === nodeType ||\n    \"TemplateLiteral\" === nodeType ||\n    \"YieldExpression\" === nodeType ||\n    \"AwaitExpression\" === nodeType ||\n    \"Import\" === nodeType ||\n    \"BigIntLiteral\" === nodeType ||\n    \"OptionalMemberExpression\" === nodeType ||\n    \"OptionalCallExpression\" === nodeType ||\n    \"TypeCastExpression\" === nodeType ||\n    \"JSXElement\" === nodeType ||\n    \"JSXFragment\" === nodeType ||\n    \"BindExpression\" === nodeType ||\n    \"DoExpression\" === nodeType ||\n    \"RecordExpression\" === nodeType ||\n    \"TupleExpression\" === nodeType ||\n    \"DecimalLiteral\" === nodeType ||\n    \"ModuleExpression\" === nodeType ||\n    \"TopicReference\" === nodeType ||\n    \"PipelineTopicExpression\" === nodeType ||\n    \"PipelineBareFunction\" === nodeType ||\n    \"PipelinePrimaryTopicReference\" === nodeType ||\n    \"TSInstantiationExpression\" === nodeType ||\n    \"TSAsExpression\" === nodeType ||\n    \"TSSatisfiesExpression\" === nodeType ||\n    \"TSTypeAssertion\" === nodeType ||\n    \"TSNonNullExpression\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      (\"Expression\" === (node as t.Placeholder).expectedNode ||\n        \"Identifier\" === (node as t.Placeholder).expectedNode ||\n        \"StringLiteral\" === (node as t.Placeholder).expectedNode))\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBinary(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Binary {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\"BinaryExpression\" === nodeType || \"LogicalExpression\" === nodeType) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isScopable(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Scopable {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"BlockStatement\" === nodeType ||\n    \"CatchClause\" === nodeType ||\n    \"DoWhileStatement\" === nodeType ||\n    \"ForInStatement\" === nodeType ||\n    \"ForStatement\" === nodeType ||\n    \"FunctionDeclaration\" === nodeType ||\n    \"FunctionExpression\" === nodeType ||\n    \"Program\" === nodeType ||\n    \"ObjectMethod\" === nodeType ||\n    \"SwitchStatement\" === nodeType ||\n    \"WhileStatement\" === nodeType ||\n    \"ArrowFunctionExpression\" === nodeType ||\n    \"ClassExpression\" === nodeType ||\n    \"ClassDeclaration\" === nodeType ||\n    \"ForOfStatement\" === nodeType ||\n    \"ClassMethod\" === nodeType ||\n    \"ClassPrivateMethod\" === nodeType ||\n    \"StaticBlock\" === nodeType ||\n    \"TSModuleBlock\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      \"BlockStatement\" === (node as t.Placeholder).expectedNode)\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBlockParent(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.BlockParent {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"BlockStatement\" === nodeType ||\n    \"CatchClause\" === nodeType ||\n    \"DoWhileStatement\" === nodeType ||\n    \"ForInStatement\" === nodeType ||\n    \"ForStatement\" === nodeType ||\n    \"FunctionDeclaration\" === nodeType ||\n    \"FunctionExpression\" === nodeType ||\n    \"Program\" === nodeType ||\n    \"ObjectMethod\" === nodeType ||\n    \"SwitchStatement\" === nodeType ||\n    \"WhileStatement\" === nodeType ||\n    \"ArrowFunctionExpression\" === nodeType ||\n    \"ForOfStatement\" === nodeType ||\n    \"ClassMethod\" === nodeType ||\n    \"ClassPrivateMethod\" === nodeType ||\n    \"StaticBlock\" === nodeType ||\n    \"TSModuleBlock\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      \"BlockStatement\" === (node as t.Placeholder).expectedNode)\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isBlock(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Block {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"BlockStatement\" === nodeType ||\n    \"Program\" === nodeType ||\n    \"TSModuleBlock\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      \"BlockStatement\" === (node as t.Placeholder).expectedNode)\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Statement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"BlockStatement\" === nodeType ||\n    \"BreakStatement\" === nodeType ||\n    \"ContinueStatement\" === nodeType ||\n    \"DebuggerStatement\" === nodeType ||\n    \"DoWhileStatement\" === nodeType ||\n    \"EmptyStatement\" === nodeType ||\n    \"ExpressionStatement\" === nodeType ||\n    \"ForInStatement\" === nodeType ||\n    \"ForStatement\" === nodeType ||\n    \"FunctionDeclaration\" === nodeType ||\n    \"IfStatement\" === nodeType ||\n    \"LabeledStatement\" === nodeType ||\n    \"ReturnStatement\" === nodeType ||\n    \"SwitchStatement\" === nodeType ||\n    \"ThrowStatement\" === nodeType ||\n    \"TryStatement\" === nodeType ||\n    \"VariableDeclaration\" === nodeType ||\n    \"WhileStatement\" === nodeType ||\n    \"WithStatement\" === nodeType ||\n    \"ClassDeclaration\" === nodeType ||\n    \"ExportAllDeclaration\" === nodeType ||\n    \"ExportDefaultDeclaration\" === nodeType ||\n    \"ExportNamedDeclaration\" === nodeType ||\n    \"ForOfStatement\" === nodeType ||\n    \"ImportDeclaration\" === nodeType ||\n    \"DeclareClass\" === nodeType ||\n    \"DeclareFunction\" === nodeType ||\n    \"DeclareInterface\" === nodeType ||\n    \"DeclareModule\" === nodeType ||\n    \"DeclareModuleExports\" === nodeType ||\n    \"DeclareTypeAlias\" === nodeType ||\n    \"DeclareOpaqueType\" === nodeType ||\n    \"DeclareVariable\" === nodeType ||\n    \"DeclareExportDeclaration\" === nodeType ||\n    \"DeclareExportAllDeclaration\" === nodeType ||\n    \"InterfaceDeclaration\" === nodeType ||\n    \"OpaqueType\" === nodeType ||\n    \"TypeAlias\" === nodeType ||\n    \"EnumDeclaration\" === nodeType ||\n    \"TSDeclareFunction\" === nodeType ||\n    \"TSInterfaceDeclaration\" === nodeType ||\n    \"TSTypeAliasDeclaration\" === nodeType ||\n    \"TSEnumDeclaration\" === nodeType ||\n    \"TSModuleDeclaration\" === nodeType ||\n    \"TSImportEqualsDeclaration\" === nodeType ||\n    \"TSExportAssignment\" === nodeType ||\n    \"TSNamespaceExportDeclaration\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      (\"Statement\" === (node as t.Placeholder).expectedNode ||\n        \"Declaration\" === (node as t.Placeholder).expectedNode ||\n        \"BlockStatement\" === (node as t.Placeholder).expectedNode))\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTerminatorless(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Terminatorless {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"BreakStatement\" === nodeType ||\n    \"ContinueStatement\" === nodeType ||\n    \"ReturnStatement\" === nodeType ||\n    \"ThrowStatement\" === nodeType ||\n    \"YieldExpression\" === nodeType ||\n    \"AwaitExpression\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isCompletionStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.CompletionStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"BreakStatement\" === nodeType ||\n    \"ContinueStatement\" === nodeType ||\n    \"ReturnStatement\" === nodeType ||\n    \"ThrowStatement\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isConditional(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Conditional {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\"ConditionalExpression\" === nodeType || \"IfStatement\" === nodeType) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isLoop(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Loop {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"DoWhileStatement\" === nodeType ||\n    \"ForInStatement\" === nodeType ||\n    \"ForStatement\" === nodeType ||\n    \"WhileStatement\" === nodeType ||\n    \"ForOfStatement\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isWhile(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.While {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\"DoWhileStatement\" === nodeType || \"WhileStatement\" === nodeType) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExpressionWrapper(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ExpressionWrapper {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ExpressionStatement\" === nodeType ||\n    \"ParenthesizedExpression\" === nodeType ||\n    \"TypeCastExpression\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFor(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.For {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ForInStatement\" === nodeType ||\n    \"ForStatement\" === nodeType ||\n    \"ForOfStatement\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isForXStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ForXStatement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\"ForInStatement\" === nodeType || \"ForOfStatement\" === nodeType) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFunction(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Function {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"FunctionDeclaration\" === nodeType ||\n    \"FunctionExpression\" === nodeType ||\n    \"ObjectMethod\" === nodeType ||\n    \"ArrowFunctionExpression\" === nodeType ||\n    \"ClassMethod\" === nodeType ||\n    \"ClassPrivateMethod\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFunctionParent(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.FunctionParent {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"FunctionDeclaration\" === nodeType ||\n    \"FunctionExpression\" === nodeType ||\n    \"ObjectMethod\" === nodeType ||\n    \"ArrowFunctionExpression\" === nodeType ||\n    \"ClassMethod\" === nodeType ||\n    \"ClassPrivateMethod\" === nodeType ||\n    \"StaticBlock\" === nodeType ||\n    \"TSModuleBlock\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isPureish(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Pureish {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"FunctionDeclaration\" === nodeType ||\n    \"FunctionExpression\" === nodeType ||\n    \"StringLiteral\" === nodeType ||\n    \"NumericLiteral\" === nodeType ||\n    \"NullLiteral\" === nodeType ||\n    \"BooleanLiteral\" === nodeType ||\n    \"RegExpLiteral\" === nodeType ||\n    \"ArrowFunctionExpression\" === nodeType ||\n    \"BigIntLiteral\" === nodeType ||\n    \"DecimalLiteral\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      \"StringLiteral\" === (node as t.Placeholder).expectedNode)\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Declaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"FunctionDeclaration\" === nodeType ||\n    \"VariableDeclaration\" === nodeType ||\n    \"ClassDeclaration\" === nodeType ||\n    \"ExportAllDeclaration\" === nodeType ||\n    \"ExportDefaultDeclaration\" === nodeType ||\n    \"ExportNamedDeclaration\" === nodeType ||\n    \"ImportDeclaration\" === nodeType ||\n    \"DeclareClass\" === nodeType ||\n    \"DeclareFunction\" === nodeType ||\n    \"DeclareInterface\" === nodeType ||\n    \"DeclareModule\" === nodeType ||\n    \"DeclareModuleExports\" === nodeType ||\n    \"DeclareTypeAlias\" === nodeType ||\n    \"DeclareOpaqueType\" === nodeType ||\n    \"DeclareVariable\" === nodeType ||\n    \"DeclareExportDeclaration\" === nodeType ||\n    \"DeclareExportAllDeclaration\" === nodeType ||\n    \"InterfaceDeclaration\" === nodeType ||\n    \"OpaqueType\" === nodeType ||\n    \"TypeAlias\" === nodeType ||\n    \"EnumDeclaration\" === nodeType ||\n    \"TSDeclareFunction\" === nodeType ||\n    \"TSInterfaceDeclaration\" === nodeType ||\n    \"TSTypeAliasDeclaration\" === nodeType ||\n    \"TSEnumDeclaration\" === nodeType ||\n    \"TSModuleDeclaration\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      \"Declaration\" === (node as t.Placeholder).expectedNode)\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isPatternLike(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.PatternLike {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"Identifier\" === nodeType ||\n    \"RestElement\" === nodeType ||\n    \"AssignmentPattern\" === nodeType ||\n    \"ArrayPattern\" === nodeType ||\n    \"ObjectPattern\" === nodeType ||\n    \"TSAsExpression\" === nodeType ||\n    \"TSSatisfiesExpression\" === nodeType ||\n    \"TSTypeAssertion\" === nodeType ||\n    \"TSNonNullExpression\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      (\"Pattern\" === (node as t.Placeholder).expectedNode ||\n        \"Identifier\" === (node as t.Placeholder).expectedNode))\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isLVal(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.LVal {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"Identifier\" === nodeType ||\n    \"MemberExpression\" === nodeType ||\n    \"RestElement\" === nodeType ||\n    \"AssignmentPattern\" === nodeType ||\n    \"ArrayPattern\" === nodeType ||\n    \"ObjectPattern\" === nodeType ||\n    \"TSParameterProperty\" === nodeType ||\n    \"TSAsExpression\" === nodeType ||\n    \"TSSatisfiesExpression\" === nodeType ||\n    \"TSTypeAssertion\" === nodeType ||\n    \"TSNonNullExpression\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      (\"Pattern\" === (node as t.Placeholder).expectedNode ||\n        \"Identifier\" === (node as t.Placeholder).expectedNode))\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSEntityName(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSEntityName {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"Identifier\" === nodeType ||\n    \"TSQualifiedName\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      \"Identifier\" === (node as t.Placeholder).expectedNode)\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Literal {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"StringLiteral\" === nodeType ||\n    \"NumericLiteral\" === nodeType ||\n    \"NullLiteral\" === nodeType ||\n    \"BooleanLiteral\" === nodeType ||\n    \"RegExpLiteral\" === nodeType ||\n    \"TemplateLiteral\" === nodeType ||\n    \"BigIntLiteral\" === nodeType ||\n    \"DecimalLiteral\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      \"StringLiteral\" === (node as t.Placeholder).expectedNode)\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isImmutable(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Immutable {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"StringLiteral\" === nodeType ||\n    \"NumericLiteral\" === nodeType ||\n    \"NullLiteral\" === nodeType ||\n    \"BooleanLiteral\" === nodeType ||\n    \"BigIntLiteral\" === nodeType ||\n    \"JSXAttribute\" === nodeType ||\n    \"JSXClosingElement\" === nodeType ||\n    \"JSXElement\" === nodeType ||\n    \"JSXExpressionContainer\" === nodeType ||\n    \"JSXSpreadChild\" === nodeType ||\n    \"JSXOpeningElement\" === nodeType ||\n    \"JSXText\" === nodeType ||\n    \"JSXFragment\" === nodeType ||\n    \"JSXOpeningFragment\" === nodeType ||\n    \"JSXClosingFragment\" === nodeType ||\n    \"DecimalLiteral\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      \"StringLiteral\" === (node as t.Placeholder).expectedNode)\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isUserWhitespacable(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.UserWhitespacable {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ObjectMethod\" === nodeType ||\n    \"ObjectProperty\" === nodeType ||\n    \"ObjectTypeInternalSlot\" === nodeType ||\n    \"ObjectTypeCallProperty\" === nodeType ||\n    \"ObjectTypeIndexer\" === nodeType ||\n    \"ObjectTypeProperty\" === nodeType ||\n    \"ObjectTypeSpreadProperty\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isMethod(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Method {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ObjectMethod\" === nodeType ||\n    \"ClassMethod\" === nodeType ||\n    \"ClassPrivateMethod\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isObjectMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ObjectMember {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\"ObjectMethod\" === nodeType || \"ObjectProperty\" === nodeType) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Property {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ObjectProperty\" === nodeType ||\n    \"ClassProperty\" === nodeType ||\n    \"ClassAccessorProperty\" === nodeType ||\n    \"ClassPrivateProperty\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isUnaryLike(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.UnaryLike {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\"UnaryExpression\" === nodeType || \"SpreadElement\" === nodeType) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isPattern(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Pattern {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"AssignmentPattern\" === nodeType ||\n    \"ArrayPattern\" === nodeType ||\n    \"ObjectPattern\" === nodeType ||\n    (nodeType === \"Placeholder\" &&\n      \"Pattern\" === (node as t.Placeholder).expectedNode)\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isClass(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Class {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\"ClassExpression\" === nodeType || \"ClassDeclaration\" === nodeType) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isModuleDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ModuleDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ExportAllDeclaration\" === nodeType ||\n    \"ExportDefaultDeclaration\" === nodeType ||\n    \"ExportNamedDeclaration\" === nodeType ||\n    \"ImportDeclaration\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isExportDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ExportDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ExportAllDeclaration\" === nodeType ||\n    \"ExportDefaultDeclaration\" === nodeType ||\n    \"ExportNamedDeclaration\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isModuleSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.ModuleSpecifier {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ExportSpecifier\" === nodeType ||\n    \"ImportDefaultSpecifier\" === nodeType ||\n    \"ImportNamespaceSpecifier\" === nodeType ||\n    \"ImportSpecifier\" === nodeType ||\n    \"ExportNamespaceSpecifier\" === nodeType ||\n    \"ExportDefaultSpecifier\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isAccessor(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Accessor {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\"ClassAccessorProperty\" === nodeType) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isPrivate(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Private {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"ClassPrivateProperty\" === nodeType ||\n    \"ClassPrivateMethod\" === nodeType ||\n    \"PrivateName\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFlow(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Flow {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"AnyTypeAnnotation\" === nodeType ||\n    \"ArrayTypeAnnotation\" === nodeType ||\n    \"BooleanTypeAnnotation\" === nodeType ||\n    \"BooleanLiteralTypeAnnotation\" === nodeType ||\n    \"NullLiteralTypeAnnotation\" === nodeType ||\n    \"ClassImplements\" === nodeType ||\n    \"DeclareClass\" === nodeType ||\n    \"DeclareFunction\" === nodeType ||\n    \"DeclareInterface\" === nodeType ||\n    \"DeclareModule\" === nodeType ||\n    \"DeclareModuleExports\" === nodeType ||\n    \"DeclareTypeAlias\" === nodeType ||\n    \"DeclareOpaqueType\" === nodeType ||\n    \"DeclareVariable\" === nodeType ||\n    \"DeclareExportDeclaration\" === nodeType ||\n    \"DeclareExportAllDeclaration\" === nodeType ||\n    \"DeclaredPredicate\" === nodeType ||\n    \"ExistsTypeAnnotation\" === nodeType ||\n    \"FunctionTypeAnnotation\" === nodeType ||\n    \"FunctionTypeParam\" === nodeType ||\n    \"GenericTypeAnnotation\" === nodeType ||\n    \"InferredPredicate\" === nodeType ||\n    \"InterfaceExtends\" === nodeType ||\n    \"InterfaceDeclaration\" === nodeType ||\n    \"InterfaceTypeAnnotation\" === nodeType ||\n    \"IntersectionTypeAnnotation\" === nodeType ||\n    \"MixedTypeAnnotation\" === nodeType ||\n    \"EmptyTypeAnnotation\" === nodeType ||\n    \"NullableTypeAnnotation\" === nodeType ||\n    \"NumberLiteralTypeAnnotation\" === nodeType ||\n    \"NumberTypeAnnotation\" === nodeType ||\n    \"ObjectTypeAnnotation\" === nodeType ||\n    \"ObjectTypeInternalSlot\" === nodeType ||\n    \"ObjectTypeCallProperty\" === nodeType ||\n    \"ObjectTypeIndexer\" === nodeType ||\n    \"ObjectTypeProperty\" === nodeType ||\n    \"ObjectTypeSpreadProperty\" === nodeType ||\n    \"OpaqueType\" === nodeType ||\n    \"QualifiedTypeIdentifier\" === nodeType ||\n    \"StringLiteralTypeAnnotation\" === nodeType ||\n    \"StringTypeAnnotation\" === nodeType ||\n    \"SymbolTypeAnnotation\" === nodeType ||\n    \"ThisTypeAnnotation\" === nodeType ||\n    \"TupleTypeAnnotation\" === nodeType ||\n    \"TypeofTypeAnnotation\" === nodeType ||\n    \"TypeAlias\" === nodeType ||\n    \"TypeAnnotation\" === nodeType ||\n    \"TypeCastExpression\" === nodeType ||\n    \"TypeParameter\" === nodeType ||\n    \"TypeParameterDeclaration\" === nodeType ||\n    \"TypeParameterInstantiation\" === nodeType ||\n    \"UnionTypeAnnotation\" === nodeType ||\n    \"Variance\" === nodeType ||\n    \"VoidTypeAnnotation\" === nodeType ||\n    \"EnumDeclaration\" === nodeType ||\n    \"EnumBooleanBody\" === nodeType ||\n    \"EnumNumberBody\" === nodeType ||\n    \"EnumStringBody\" === nodeType ||\n    \"EnumSymbolBody\" === nodeType ||\n    \"EnumBooleanMember\" === nodeType ||\n    \"EnumNumberMember\" === nodeType ||\n    \"EnumStringMember\" === nodeType ||\n    \"EnumDefaultedMember\" === nodeType ||\n    \"IndexedAccessType\" === nodeType ||\n    \"OptionalIndexedAccessType\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFlowType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.FlowType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"AnyTypeAnnotation\" === nodeType ||\n    \"ArrayTypeAnnotation\" === nodeType ||\n    \"BooleanTypeAnnotation\" === nodeType ||\n    \"BooleanLiteralTypeAnnotation\" === nodeType ||\n    \"NullLiteralTypeAnnotation\" === nodeType ||\n    \"ExistsTypeAnnotation\" === nodeType ||\n    \"FunctionTypeAnnotation\" === nodeType ||\n    \"GenericTypeAnnotation\" === nodeType ||\n    \"InterfaceTypeAnnotation\" === nodeType ||\n    \"IntersectionTypeAnnotation\" === nodeType ||\n    \"MixedTypeAnnotation\" === nodeType ||\n    \"EmptyTypeAnnotation\" === nodeType ||\n    \"NullableTypeAnnotation\" === nodeType ||\n    \"NumberLiteralTypeAnnotation\" === nodeType ||\n    \"NumberTypeAnnotation\" === nodeType ||\n    \"ObjectTypeAnnotation\" === nodeType ||\n    \"StringLiteralTypeAnnotation\" === nodeType ||\n    \"StringTypeAnnotation\" === nodeType ||\n    \"SymbolTypeAnnotation\" === nodeType ||\n    \"ThisTypeAnnotation\" === nodeType ||\n    \"TupleTypeAnnotation\" === nodeType ||\n    \"TypeofTypeAnnotation\" === nodeType ||\n    \"UnionTypeAnnotation\" === nodeType ||\n    \"VoidTypeAnnotation\" === nodeType ||\n    \"IndexedAccessType\" === nodeType ||\n    \"OptionalIndexedAccessType\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFlowBaseAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.FlowBaseAnnotation {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"AnyTypeAnnotation\" === nodeType ||\n    \"BooleanTypeAnnotation\" === nodeType ||\n    \"NullLiteralTypeAnnotation\" === nodeType ||\n    \"MixedTypeAnnotation\" === nodeType ||\n    \"EmptyTypeAnnotation\" === nodeType ||\n    \"NumberTypeAnnotation\" === nodeType ||\n    \"StringTypeAnnotation\" === nodeType ||\n    \"SymbolTypeAnnotation\" === nodeType ||\n    \"ThisTypeAnnotation\" === nodeType ||\n    \"VoidTypeAnnotation\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFlowDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.FlowDeclaration {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"DeclareClass\" === nodeType ||\n    \"DeclareFunction\" === nodeType ||\n    \"DeclareInterface\" === nodeType ||\n    \"DeclareModule\" === nodeType ||\n    \"DeclareModuleExports\" === nodeType ||\n    \"DeclareTypeAlias\" === nodeType ||\n    \"DeclareOpaqueType\" === nodeType ||\n    \"DeclareVariable\" === nodeType ||\n    \"DeclareExportDeclaration\" === nodeType ||\n    \"DeclareExportAllDeclaration\" === nodeType ||\n    \"InterfaceDeclaration\" === nodeType ||\n    \"OpaqueType\" === nodeType ||\n    \"TypeAlias\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isFlowPredicate(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.FlowPredicate {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\"DeclaredPredicate\" === nodeType || \"InferredPredicate\" === nodeType) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumBody {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"EnumBooleanBody\" === nodeType ||\n    \"EnumNumberBody\" === nodeType ||\n    \"EnumStringBody\" === nodeType ||\n    \"EnumSymbolBody\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isEnumMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.EnumMember {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"EnumBooleanMember\" === nodeType ||\n    \"EnumNumberMember\" === nodeType ||\n    \"EnumStringMember\" === nodeType ||\n    \"EnumDefaultedMember\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isJSX(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.JSX {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"JSXAttribute\" === nodeType ||\n    \"JSXClosingElement\" === nodeType ||\n    \"JSXElement\" === nodeType ||\n    \"JSXEmptyExpression\" === nodeType ||\n    \"JSXExpressionContainer\" === nodeType ||\n    \"JSXSpreadChild\" === nodeType ||\n    \"JSXIdentifier\" === nodeType ||\n    \"JSXMemberExpression\" === nodeType ||\n    \"JSXNamespacedName\" === nodeType ||\n    \"JSXOpeningElement\" === nodeType ||\n    \"JSXSpreadAttribute\" === nodeType ||\n    \"JSXText\" === nodeType ||\n    \"JSXFragment\" === nodeType ||\n    \"JSXOpeningFragment\" === nodeType ||\n    \"JSXClosingFragment\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isMiscellaneous(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.Miscellaneous {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"Noop\" === nodeType ||\n    \"Placeholder\" === nodeType ||\n    \"V8IntrinsicIdentifier\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTypeScript(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TypeScript {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"TSParameterProperty\" === nodeType ||\n    \"TSDeclareFunction\" === nodeType ||\n    \"TSDeclareMethod\" === nodeType ||\n    \"TSQualifiedName\" === nodeType ||\n    \"TSCallSignatureDeclaration\" === nodeType ||\n    \"TSConstructSignatureDeclaration\" === nodeType ||\n    \"TSPropertySignature\" === nodeType ||\n    \"TSMethodSignature\" === nodeType ||\n    \"TSIndexSignature\" === nodeType ||\n    \"TSAnyKeyword\" === nodeType ||\n    \"TSBooleanKeyword\" === nodeType ||\n    \"TSBigIntKeyword\" === nodeType ||\n    \"TSIntrinsicKeyword\" === nodeType ||\n    \"TSNeverKeyword\" === nodeType ||\n    \"TSNullKeyword\" === nodeType ||\n    \"TSNumberKeyword\" === nodeType ||\n    \"TSObjectKeyword\" === nodeType ||\n    \"TSStringKeyword\" === nodeType ||\n    \"TSSymbolKeyword\" === nodeType ||\n    \"TSUndefinedKeyword\" === nodeType ||\n    \"TSUnknownKeyword\" === nodeType ||\n    \"TSVoidKeyword\" === nodeType ||\n    \"TSThisType\" === nodeType ||\n    \"TSFunctionType\" === nodeType ||\n    \"TSConstructorType\" === nodeType ||\n    \"TSTypeReference\" === nodeType ||\n    \"TSTypePredicate\" === nodeType ||\n    \"TSTypeQuery\" === nodeType ||\n    \"TSTypeLiteral\" === nodeType ||\n    \"TSArrayType\" === nodeType ||\n    \"TSTupleType\" === nodeType ||\n    \"TSOptionalType\" === nodeType ||\n    \"TSRestType\" === nodeType ||\n    \"TSNamedTupleMember\" === nodeType ||\n    \"TSUnionType\" === nodeType ||\n    \"TSIntersectionType\" === nodeType ||\n    \"TSConditionalType\" === nodeType ||\n    \"TSInferType\" === nodeType ||\n    \"TSParenthesizedType\" === nodeType ||\n    \"TSTypeOperator\" === nodeType ||\n    \"TSIndexedAccessType\" === nodeType ||\n    \"TSMappedType\" === nodeType ||\n    \"TSLiteralType\" === nodeType ||\n    \"TSExpressionWithTypeArguments\" === nodeType ||\n    \"TSInterfaceDeclaration\" === nodeType ||\n    \"TSInterfaceBody\" === nodeType ||\n    \"TSTypeAliasDeclaration\" === nodeType ||\n    \"TSInstantiationExpression\" === nodeType ||\n    \"TSAsExpression\" === nodeType ||\n    \"TSSatisfiesExpression\" === nodeType ||\n    \"TSTypeAssertion\" === nodeType ||\n    \"TSEnumDeclaration\" === nodeType ||\n    \"TSEnumMember\" === nodeType ||\n    \"TSModuleDeclaration\" === nodeType ||\n    \"TSModuleBlock\" === nodeType ||\n    \"TSImportType\" === nodeType ||\n    \"TSImportEqualsDeclaration\" === nodeType ||\n    \"TSExternalModuleReference\" === nodeType ||\n    \"TSNonNullExpression\" === nodeType ||\n    \"TSExportAssignment\" === nodeType ||\n    \"TSNamespaceExportDeclaration\" === nodeType ||\n    \"TSTypeAnnotation\" === nodeType ||\n    \"TSTypeParameterInstantiation\" === nodeType ||\n    \"TSTypeParameterDeclaration\" === nodeType ||\n    \"TSTypeParameter\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSTypeElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSTypeElement {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"TSCallSignatureDeclaration\" === nodeType ||\n    \"TSConstructSignatureDeclaration\" === nodeType ||\n    \"TSPropertySignature\" === nodeType ||\n    \"TSMethodSignature\" === nodeType ||\n    \"TSIndexSignature\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"TSAnyKeyword\" === nodeType ||\n    \"TSBooleanKeyword\" === nodeType ||\n    \"TSBigIntKeyword\" === nodeType ||\n    \"TSIntrinsicKeyword\" === nodeType ||\n    \"TSNeverKeyword\" === nodeType ||\n    \"TSNullKeyword\" === nodeType ||\n    \"TSNumberKeyword\" === nodeType ||\n    \"TSObjectKeyword\" === nodeType ||\n    \"TSStringKeyword\" === nodeType ||\n    \"TSSymbolKeyword\" === nodeType ||\n    \"TSUndefinedKeyword\" === nodeType ||\n    \"TSUnknownKeyword\" === nodeType ||\n    \"TSVoidKeyword\" === nodeType ||\n    \"TSThisType\" === nodeType ||\n    \"TSFunctionType\" === nodeType ||\n    \"TSConstructorType\" === nodeType ||\n    \"TSTypeReference\" === nodeType ||\n    \"TSTypePredicate\" === nodeType ||\n    \"TSTypeQuery\" === nodeType ||\n    \"TSTypeLiteral\" === nodeType ||\n    \"TSArrayType\" === nodeType ||\n    \"TSTupleType\" === nodeType ||\n    \"TSOptionalType\" === nodeType ||\n    \"TSRestType\" === nodeType ||\n    \"TSUnionType\" === nodeType ||\n    \"TSIntersectionType\" === nodeType ||\n    \"TSConditionalType\" === nodeType ||\n    \"TSInferType\" === nodeType ||\n    \"TSParenthesizedType\" === nodeType ||\n    \"TSTypeOperator\" === nodeType ||\n    \"TSIndexedAccessType\" === nodeType ||\n    \"TSMappedType\" === nodeType ||\n    \"TSLiteralType\" === nodeType ||\n    \"TSExpressionWithTypeArguments\" === nodeType ||\n    \"TSImportType\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isTSBaseType(\n  node: object | null | undefined,\n  opts?: object | null,\n): node is t.TSBaseType {\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (\n    \"TSAnyKeyword\" === nodeType ||\n    \"TSBooleanKeyword\" === nodeType ||\n    \"TSBigIntKeyword\" === nodeType ||\n    \"TSIntrinsicKeyword\" === nodeType ||\n    \"TSNeverKeyword\" === nodeType ||\n    \"TSNullKeyword\" === nodeType ||\n    \"TSNumberKeyword\" === nodeType ||\n    \"TSObjectKeyword\" === nodeType ||\n    \"TSStringKeyword\" === nodeType ||\n    \"TSSymbolKeyword\" === nodeType ||\n    \"TSUndefinedKeyword\" === nodeType ||\n    \"TSUnknownKeyword\" === nodeType ||\n    \"TSVoidKeyword\" === nodeType ||\n    \"TSThisType\" === nodeType ||\n    \"TSLiteralType\" === nodeType\n  ) {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isNumberLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): boolean {\n  console.trace(\n    \"The node type NumberLiteral has been renamed to NumericLiteral\",\n  );\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"NumberLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isRegexLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): boolean {\n  console.trace(\"The node type RegexLiteral has been renamed to RegExpLiteral\");\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"RegexLiteral\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isRestProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): boolean {\n  console.trace(\"The node type RestProperty has been renamed to RestElement\");\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"RestProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\nexport function isSpreadProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): boolean {\n  console.trace(\n    \"The node type SpreadProperty has been renamed to SpreadElement\",\n  );\n  if (!node) return false;\n\n  const nodeType = (node as t.Node).type;\n  if (nodeType === \"SpreadProperty\") {\n    if (typeof opts === \"undefined\") {\n      return true;\n    } else {\n      return shallowEqual(node, opts);\n    }\n  }\n\n  return false;\n}\n","function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }\n\nimport $ from '../../utils/dom';\nimport { extend, bindModuleMethods, classesToSelector, createElementIfNotDefined } from '../../utils/utils';\nvar Pagination = {\n  update: function update() {\n    // Render || Update Pagination bullets/items\n    var swiper = this;\n    var rtl = swiper.rtl;\n    var params = swiper.params.pagination;\n    if (!params.el || !swiper.pagination.el || !swiper.pagination.$el || swiper.pagination.$el.length === 0) return;\n    var slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.slides.length;\n    var $el = swiper.pagination.$el; // Current/Total\n\n    var current;\n    var total = swiper.params.loop ? Math.ceil((slidesLength - swiper.loopedSlides * 2) / swiper.params.slidesPerGroup) : swiper.snapGrid.length;\n\n    if (swiper.params.loop) {\n      current = Math.ceil((swiper.activeIndex - swiper.loopedSlides) / swiper.params.slidesPerGroup);\n\n      if (current > slidesLength - 1 - swiper.loopedSlides * 2) {\n        current -= slidesLength - swiper.loopedSlides * 2;\n      }\n\n      if (current > total - 1) current -= total;\n      if (current < 0 && swiper.params.paginationType !== 'bullets') current = total + current;\n    } else if (typeof swiper.snapIndex !== 'undefined') {\n      current = swiper.snapIndex;\n    } else {\n      current = swiper.activeIndex || 0;\n    } // Types\n\n\n    if (params.type === 'bullets' && swiper.pagination.bullets && swiper.pagination.bullets.length > 0) {\n      var bullets = swiper.pagination.bullets;\n      var firstIndex;\n      var lastIndex;\n      var midIndex;\n\n      if (params.dynamicBullets) {\n        swiper.pagination.bulletSize = bullets.eq(0)[swiper.isHorizontal() ? 'outerWidth' : 'outerHeight'](true);\n        $el.css(swiper.isHorizontal() ? 'width' : 'height', swiper.pagination.bulletSize * (params.dynamicMainBullets + 4) + \"px\");\n\n        if (params.dynamicMainBullets > 1 && swiper.previousIndex !== undefined) {\n          swiper.pagination.dynamicBulletIndex += current - swiper.previousIndex;\n\n          if (swiper.pagination.dynamicBulletIndex > params.dynamicMainBullets - 1) {\n            swiper.pagination.dynamicBulletIndex = params.dynamicMainBullets - 1;\n          } else if (swiper.pagination.dynamicBulletIndex < 0) {\n            swiper.pagination.dynamicBulletIndex = 0;\n          }\n        }\n\n        firstIndex = current - swiper.pagination.dynamicBulletIndex;\n        lastIndex = firstIndex + (Math.min(bullets.length, params.dynamicMainBullets) - 1);\n        midIndex = (lastIndex + firstIndex) / 2;\n      }\n\n      bullets.removeClass(params.bulletActiveClass + \" \" + params.bulletActiveClass + \"-next \" + params.bulletActiveClass + \"-next-next \" + params.bulletActiveClass + \"-prev \" + params.bulletActiveClass + \"-prev-prev \" + params.bulletActiveClass + \"-main\");\n\n      if ($el.length > 1) {\n        bullets.each(function (bullet) {\n          var $bullet = $(bullet);\n          var bulletIndex = $bullet.index();\n\n          if (bulletIndex === current) {\n            $bullet.addClass(params.bulletActiveClass);\n          }\n\n          if (params.dynamicBullets) {\n            if (bulletIndex >= firstIndex && bulletIndex <= lastIndex) {\n              $bullet.addClass(params.bulletActiveClass + \"-main\");\n            }\n\n            if (bulletIndex === firstIndex) {\n              $bullet.prev().addClass(params.bulletActiveClass + \"-prev\").prev().addClass(params.bulletActiveClass + \"-prev-prev\");\n            }\n\n            if (bulletIndex === lastIndex) {\n              $bullet.next().addClass(params.bulletActiveClass + \"-next\").next().addClass(params.bulletActiveClass + \"-next-next\");\n            }\n          }\n        });\n      } else {\n        var $bullet = bullets.eq(current);\n        var bulletIndex = $bullet.index();\n        $bullet.addClass(params.bulletActiveClass);\n\n        if (params.dynamicBullets) {\n          var $firstDisplayedBullet = bullets.eq(firstIndex);\n          var $lastDisplayedBullet = bullets.eq(lastIndex);\n\n          for (var i = firstIndex; i <= lastIndex; i += 1) {\n            bullets.eq(i).addClass(params.bulletActiveClass + \"-main\");\n          }\n\n          if (swiper.params.loop) {\n            if (bulletIndex >= bullets.length - params.dynamicMainBullets) {\n              for (var _i = params.dynamicMainBullets; _i >= 0; _i -= 1) {\n                bullets.eq(bullets.length - _i).addClass(params.bulletActiveClass + \"-main\");\n              }\n\n              bullets.eq(bullets.length - params.dynamicMainBullets - 1).addClass(params.bulletActiveClass + \"-prev\");\n            } else {\n              $firstDisplayedBullet.prev().addClass(params.bulletActiveClass + \"-prev\").prev().addClass(params.bulletActiveClass + \"-prev-prev\");\n              $lastDisplayedBullet.next().addClass(params.bulletActiveClass + \"-next\").next().addClass(params.bulletActiveClass + \"-next-next\");\n            }\n          } else {\n            $firstDisplayedBullet.prev().addClass(params.bulletActiveClass + \"-prev\").prev().addClass(params.bulletActiveClass + \"-prev-prev\");\n            $lastDisplayedBullet.next().addClass(params.bulletActiveClass + \"-next\").next().addClass(params.bulletActiveClass + \"-next-next\");\n          }\n        }\n      }\n\n      if (params.dynamicBullets) {\n        var dynamicBulletsLength = Math.min(bullets.length, params.dynamicMainBullets + 4);\n        var bulletsOffset = (swiper.pagination.bulletSize * dynamicBulletsLength - swiper.pagination.bulletSize) / 2 - midIndex * swiper.pagination.bulletSize;\n        var offsetProp = rtl ? 'right' : 'left';\n        bullets.css(swiper.isHorizontal() ? offsetProp : 'top', bulletsOffset + \"px\");\n      }\n    }\n\n    if (params.type === 'fraction') {\n      $el.find(classesToSelector(params.currentClass)).text(params.formatFractionCurrent(current + 1));\n      $el.find(classesToSelector(params.totalClass)).text(params.formatFractionTotal(total));\n    }\n\n    if (params.type === 'progressbar') {\n      var progressbarDirection;\n\n      if (params.progressbarOpposite) {\n        progressbarDirection = swiper.isHorizontal() ? 'vertical' : 'horizontal';\n      } else {\n        progressbarDirection = swiper.isHorizontal() ? 'horizontal' : 'vertical';\n      }\n\n      var scale = (current + 1) / total;\n      var scaleX = 1;\n      var scaleY = 1;\n\n      if (progressbarDirection === 'horizontal') {\n        scaleX = scale;\n      } else {\n        scaleY = scale;\n      }\n\n      $el.find(classesToSelector(params.progressbarFillClass)).transform(\"translate3d(0,0,0) scaleX(\" + scaleX + \") scaleY(\" + scaleY + \")\").transition(swiper.params.speed);\n    }\n\n    if (params.type === 'custom' && params.renderCustom) {\n      $el.html(params.renderCustom(swiper, current + 1, total));\n      swiper.emit('paginationRender', $el[0]);\n    } else {\n      swiper.emit('paginationUpdate', $el[0]);\n    }\n\n    if (swiper.params.watchOverflow && swiper.enabled) {\n      $el[swiper.isLocked ? 'addClass' : 'removeClass'](params.lockClass);\n    }\n  },\n  render: function render() {\n    // Render Container\n    var swiper = this;\n    var params = swiper.params.pagination;\n    if (!params.el || !swiper.pagination.el || !swiper.pagination.$el || swiper.pagination.$el.length === 0) return;\n    var slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.slides.length;\n    var $el = swiper.pagination.$el;\n    var paginationHTML = '';\n\n    if (params.type === 'bullets') {\n      var numberOfBullets = swiper.params.loop ? Math.ceil((slidesLength - swiper.loopedSlides * 2) / swiper.params.slidesPerGroup) : swiper.snapGrid.length;\n\n      if (swiper.params.freeMode && !swiper.params.loop && numberOfBullets > slidesLength) {\n        numberOfBullets = slidesLength;\n      }\n\n      for (var i = 0; i < numberOfBullets; i += 1) {\n        if (params.renderBullet) {\n          paginationHTML += params.renderBullet.call(swiper, i, params.bulletClass);\n        } else {\n          paginationHTML += \"<\" + params.bulletElement + \" class=\\\"\" + params.bulletClass + \"\\\"></\" + params.bulletElement + \">\";\n        }\n      }\n\n      $el.html(paginationHTML);\n      swiper.pagination.bullets = $el.find(classesToSelector(params.bulletClass));\n    }\n\n    if (params.type === 'fraction') {\n      if (params.renderFraction) {\n        paginationHTML = params.renderFraction.call(swiper, params.currentClass, params.totalClass);\n      } else {\n        paginationHTML = \"<span class=\\\"\" + params.currentClass + \"\\\"></span>\" + ' / ' + (\"<span class=\\\"\" + params.totalClass + \"\\\"></span>\");\n      }\n\n      $el.html(paginationHTML);\n    }\n\n    if (params.type === 'progressbar') {\n      if (params.renderProgressbar) {\n        paginationHTML = params.renderProgressbar.call(swiper, params.progressbarFillClass);\n      } else {\n        paginationHTML = \"<span class=\\\"\" + params.progressbarFillClass + \"\\\"></span>\";\n      }\n\n      $el.html(paginationHTML);\n    }\n\n    if (params.type !== 'custom') {\n      swiper.emit('paginationRender', swiper.pagination.$el[0]);\n    }\n  },\n  init: function init() {\n    var swiper = this;\n    swiper.params.pagination = createElementIfNotDefined(swiper.$el, swiper.params.pagination, swiper.params.createElements, {\n      el: 'swiper-pagination'\n    });\n    var params = swiper.params.pagination;\n    if (!params.el) return;\n    var $el = $(params.el);\n    if ($el.length === 0) return;\n\n    if (swiper.params.uniqueNavElements && typeof params.el === 'string' && $el.length > 1) {\n      $el = swiper.$el.find(params.el);\n    }\n\n    if (params.type === 'bullets' && params.clickable) {\n      $el.addClass(params.clickableClass);\n    }\n\n    $el.addClass(params.modifierClass + params.type);\n\n    if (params.type === 'bullets' && params.dynamicBullets) {\n      $el.addClass(\"\" + params.modifierClass + params.type + \"-dynamic\");\n      swiper.pagination.dynamicBulletIndex = 0;\n\n      if (params.dynamicMainBullets < 1) {\n        params.dynamicMainBullets = 1;\n      }\n    }\n\n    if (params.type === 'progressbar' && params.progressbarOpposite) {\n      $el.addClass(params.progressbarOppositeClass);\n    }\n\n    if (params.clickable) {\n      $el.on('click', classesToSelector(params.bulletClass), function onClick(e) {\n        e.preventDefault();\n        var index = $(this).index() * swiper.params.slidesPerGroup;\n        if (swiper.params.loop) index += swiper.loopedSlides;\n        swiper.slideTo(index);\n      });\n    }\n\n    extend(swiper.pagination, {\n      $el: $el,\n      el: $el[0]\n    });\n\n    if (!swiper.enabled) {\n      $el.addClass(params.lockClass);\n    }\n  },\n  destroy: function destroy() {\n    var swiper = this;\n    var params = swiper.params.pagination;\n    if (!params.el || !swiper.pagination.el || !swiper.pagination.$el || swiper.pagination.$el.length === 0) return;\n    var $el = swiper.pagination.$el;\n    $el.removeClass(params.hiddenClass);\n    $el.removeClass(params.modifierClass + params.type);\n    if (swiper.pagination.bullets) swiper.pagination.bullets.removeClass(params.bulletActiveClass);\n\n    if (params.clickable) {\n      $el.off('click', classesToSelector(params.bulletClass));\n    }\n  }\n};\nexport default {\n  name: 'pagination',\n  params: {\n    pagination: {\n      el: null,\n      bulletElement: 'span',\n      clickable: false,\n      hideOnClick: false,\n      renderBullet: null,\n      renderProgressbar: null,\n      renderFraction: null,\n      renderCustom: null,\n      progressbarOpposite: false,\n      type: 'bullets',\n      // 'bullets' or 'progressbar' or 'fraction' or 'custom'\n      dynamicBullets: false,\n      dynamicMainBullets: 1,\n      formatFractionCurrent: function formatFractionCurrent(number) {\n        return number;\n      },\n      formatFractionTotal: function formatFractionTotal(number) {\n        return number;\n      },\n      bulletClass: 'swiper-pagination-bullet',\n      bulletActiveClass: 'swiper-pagination-bullet-active',\n      modifierClass: 'swiper-pagination-',\n      // NEW\n      currentClass: 'swiper-pagination-current',\n      totalClass: 'swiper-pagination-total',\n      hiddenClass: 'swiper-pagination-hidden',\n      progressbarFillClass: 'swiper-pagination-progressbar-fill',\n      progressbarOppositeClass: 'swiper-pagination-progressbar-opposite',\n      clickableClass: 'swiper-pagination-clickable',\n      // NEW\n      lockClass: 'swiper-pagination-lock'\n    }\n  },\n  create: function create() {\n    var swiper = this;\n    bindModuleMethods(swiper, {\n      pagination: _extends({\n        dynamicBulletIndex: 0\n      }, Pagination)\n    });\n  },\n  on: {\n    init: function init(swiper) {\n      swiper.pagination.init();\n      swiper.pagination.render();\n      swiper.pagination.update();\n    },\n    activeIndexChange: function activeIndexChange(swiper) {\n      if (swiper.params.loop) {\n        swiper.pagination.update();\n      } else if (typeof swiper.snapIndex === 'undefined') {\n        swiper.pagination.update();\n      }\n    },\n    snapIndexChange: function snapIndexChange(swiper) {\n      if (!swiper.params.loop) {\n        swiper.pagination.update();\n      }\n    },\n    slidesLengthChange: function slidesLengthChange(swiper) {\n      if (swiper.params.loop) {\n        swiper.pagination.render();\n        swiper.pagination.update();\n      }\n    },\n    snapGridLengthChange: function snapGridLengthChange(swiper) {\n      if (!swiper.params.loop) {\n        swiper.pagination.render();\n        swiper.pagination.update();\n      }\n    },\n    destroy: function destroy(swiper) {\n      swiper.pagination.destroy();\n    },\n    'enable disable': function enableDisable(swiper) {\n      var $el = swiper.pagination.$el;\n\n      if ($el) {\n        $el[swiper.enabled ? 'removeClass' : 'addClass'](swiper.params.pagination.lockClass);\n      }\n    },\n    click: function click(swiper, e) {\n      var targetEl = e.target;\n\n      if (swiper.params.pagination.el && swiper.params.pagination.hideOnClick && swiper.pagination.$el.length > 0 && !$(targetEl).hasClass(swiper.params.pagination.bulletClass)) {\n        if (swiper.navigation && (swiper.navigation.nextEl && targetEl === swiper.navigation.nextEl || swiper.navigation.prevEl && targetEl === swiper.navigation.prevEl)) return;\n        var isHidden = swiper.pagination.$el.hasClass(swiper.params.pagination.hiddenClass);\n\n        if (isHidden === true) {\n          swiper.emit('paginationShow');\n        } else {\n          swiper.emit('paginationHide');\n        }\n\n        swiper.pagination.$el.toggleClass(swiper.params.pagination.hiddenClass);\n      }\n    }\n  }\n};","/*\n * This file is auto-generated! Do not modify it directly.\n * To re-generate run 'make build'\n */\nimport validateNode from \"../validateNode\";\nimport type * as t from \"../..\";\nexport function arrayExpression(\n  elements: Array<null | t.Expression | t.SpreadElement> = [],\n): t.ArrayExpression {\n  return validateNode<t.ArrayExpression>({\n    type: \"ArrayExpression\",\n    elements,\n  });\n}\nexport function assignmentExpression(\n  operator: string,\n  left: t.LVal,\n  right: t.Expression,\n): t.AssignmentExpression {\n  return validateNode<t.AssignmentExpression>({\n    type: \"AssignmentExpression\",\n    operator,\n    left,\n    right,\n  });\n}\nexport function binaryExpression(\n  operator:\n    | \"+\"\n    | \"-\"\n    | \"/\"\n    | \"%\"\n    | \"*\"\n    | \"**\"\n    | \"&\"\n    | \"|\"\n    | \">>\"\n    | \">>>\"\n    | \"<<\"\n    | \"^\"\n    | \"==\"\n    | \"===\"\n    | \"!=\"\n    | \"!==\"\n    | \"in\"\n    | \"instanceof\"\n    | \">\"\n    | \"<\"\n    | \">=\"\n    | \"<=\"\n    | \"|>\",\n  left: t.Expression | t.PrivateName,\n  right: t.Expression,\n): t.BinaryExpression {\n  return validateNode<t.BinaryExpression>({\n    type: \"BinaryExpression\",\n    operator,\n    left,\n    right,\n  });\n}\nexport function interpreterDirective(value: string): t.InterpreterDirective {\n  return validateNode<t.InterpreterDirective>({\n    type: \"InterpreterDirective\",\n    value,\n  });\n}\nexport function directive(value: t.DirectiveLiteral): t.Directive {\n  return validateNode<t.Directive>({\n    type: \"Directive\",\n    value,\n  });\n}\nexport function directiveLiteral(value: string): t.DirectiveLiteral {\n  return validateNode<t.DirectiveLiteral>({\n    type: \"DirectiveLiteral\",\n    value,\n  });\n}\nexport function blockStatement(\n  body: Array<t.Statement>,\n  directives: Array<t.Directive> = [],\n): t.BlockStatement {\n  return validateNode<t.BlockStatement>({\n    type: \"BlockStatement\",\n    body,\n    directives,\n  });\n}\nexport function breakStatement(\n  label: t.Identifier | null = null,\n): t.BreakStatement {\n  return validateNode<t.BreakStatement>({\n    type: \"BreakStatement\",\n    label,\n  });\n}\nexport function callExpression(\n  callee: t.Expression | t.Super | t.V8IntrinsicIdentifier,\n  _arguments: Array<\n    t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder\n  >,\n): t.CallExpression {\n  return validateNode<t.CallExpression>({\n    type: \"CallExpression\",\n    callee,\n    arguments: _arguments,\n  });\n}\nexport function catchClause(\n  param:\n    | t.Identifier\n    | t.ArrayPattern\n    | t.ObjectPattern\n    | null\n    | undefined = null,\n  body: t.BlockStatement,\n): t.CatchClause {\n  return validateNode<t.CatchClause>({\n    type: \"CatchClause\",\n    param,\n    body,\n  });\n}\nexport function conditionalExpression(\n  test: t.Expression,\n  consequent: t.Expression,\n  alternate: t.Expression,\n): t.ConditionalExpression {\n  return validateNode<t.ConditionalExpression>({\n    type: \"ConditionalExpression\",\n    test,\n    consequent,\n    alternate,\n  });\n}\nexport function continueStatement(\n  label: t.Identifier | null = null,\n): t.ContinueStatement {\n  return validateNode<t.ContinueStatement>({\n    type: \"ContinueStatement\",\n    label,\n  });\n}\nexport function debuggerStatement(): t.DebuggerStatement {\n  return {\n    type: \"DebuggerStatement\",\n  };\n}\nexport function doWhileStatement(\n  test: t.Expression,\n  body: t.Statement,\n): t.DoWhileStatement {\n  return validateNode<t.DoWhileStatement>({\n    type: \"DoWhileStatement\",\n    test,\n    body,\n  });\n}\nexport function emptyStatement(): t.EmptyStatement {\n  return {\n    type: \"EmptyStatement\",\n  };\n}\nexport function expressionStatement(\n  expression: t.Expression,\n): t.ExpressionStatement {\n  return validateNode<t.ExpressionStatement>({\n    type: \"ExpressionStatement\",\n    expression,\n  });\n}\nexport function file(\n  program: t.Program,\n  comments: Array<t.CommentBlock | t.CommentLine> | null = null,\n  tokens: Array<any> | null = null,\n): t.File {\n  return validateNode<t.File>({\n    type: \"File\",\n    program,\n    comments,\n    tokens,\n  });\n}\nexport function forInStatement(\n  left: t.VariableDeclaration | t.LVal,\n  right: t.Expression,\n  body: t.Statement,\n): t.ForInStatement {\n  return validateNode<t.ForInStatement>({\n    type: \"ForInStatement\",\n    left,\n    right,\n    body,\n  });\n}\nexport function forStatement(\n  init: t.VariableDeclaration | t.Expression | null | undefined = null,\n  test: t.Expression | null | undefined = null,\n  update: t.Expression | null | undefined = null,\n  body: t.Statement,\n): t.ForStatement {\n  return validateNode<t.ForStatement>({\n    type: \"ForStatement\",\n    init,\n    test,\n    update,\n    body,\n  });\n}\nexport function functionDeclaration(\n  id: t.Identifier | null | undefined = null,\n  params: Array<t.Identifier | t.Pattern | t.RestElement>,\n  body: t.BlockStatement,\n  generator: boolean = false,\n  async: boolean = false,\n): t.FunctionDeclaration {\n  return validateNode<t.FunctionDeclaration>({\n    type: \"FunctionDeclaration\",\n    id,\n    params,\n    body,\n    generator,\n    async,\n  });\n}\nexport function functionExpression(\n  id: t.Identifier | null | undefined = null,\n  params: Array<t.Identifier | t.Pattern | t.RestElement>,\n  body: t.BlockStatement,\n  generator: boolean = false,\n  async: boolean = false,\n): t.FunctionExpression {\n  return validateNode<t.FunctionExpression>({\n    type: \"FunctionExpression\",\n    id,\n    params,\n    body,\n    generator,\n    async,\n  });\n}\nexport function identifier(name: string): t.Identifier {\n  return validateNode<t.Identifier>({\n    type: \"Identifier\",\n    name,\n  });\n}\nexport function ifStatement(\n  test: t.Expression,\n  consequent: t.Statement,\n  alternate: t.Statement | null = null,\n): t.IfStatement {\n  return validateNode<t.IfStatement>({\n    type: \"IfStatement\",\n    test,\n    consequent,\n    alternate,\n  });\n}\nexport function labeledStatement(\n  label: t.Identifier,\n  body: t.Statement,\n): t.LabeledStatement {\n  return validateNode<t.LabeledStatement>({\n    type: \"LabeledStatement\",\n    label,\n    body,\n  });\n}\nexport function stringLiteral(value: string): t.StringLiteral {\n  return validateNode<t.StringLiteral>({\n    type: \"StringLiteral\",\n    value,\n  });\n}\nexport function numericLiteral(value: number): t.NumericLiteral {\n  return validateNode<t.NumericLiteral>({\n    type: \"NumericLiteral\",\n    value,\n  });\n}\nexport function nullLiteral(): t.NullLiteral {\n  return {\n    type: \"NullLiteral\",\n  };\n}\nexport function booleanLiteral(value: boolean): t.BooleanLiteral {\n  return validateNode<t.BooleanLiteral>({\n    type: \"BooleanLiteral\",\n    value,\n  });\n}\nexport function regExpLiteral(\n  pattern: string,\n  flags: string = \"\",\n): t.RegExpLiteral {\n  return validateNode<t.RegExpLiteral>({\n    type: \"RegExpLiteral\",\n    pattern,\n    flags,\n  });\n}\nexport function logicalExpression(\n  operator: \"||\" | \"&&\" | \"??\",\n  left: t.Expression,\n  right: t.Expression,\n): t.LogicalExpression {\n  return validateNode<t.LogicalExpression>({\n    type: \"LogicalExpression\",\n    operator,\n    left,\n    right,\n  });\n}\nexport function memberExpression(\n  object: t.Expression | t.Super,\n  property: t.Expression | t.Identifier | t.PrivateName,\n  computed: boolean = false,\n  optional: true | false | null = null,\n): t.MemberExpression {\n  return validateNode<t.MemberExpression>({\n    type: \"MemberExpression\",\n    object,\n    property,\n    computed,\n    optional,\n  });\n}\nexport function newExpression(\n  callee: t.Expression | t.Super | t.V8IntrinsicIdentifier,\n  _arguments: Array<\n    t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder\n  >,\n): t.NewExpression {\n  return validateNode<t.NewExpression>({\n    type: \"NewExpression\",\n    callee,\n    arguments: _arguments,\n  });\n}\nexport function program(\n  body: Array<t.Statement>,\n  directives: Array<t.Directive> = [],\n  sourceType: \"script\" | \"module\" = \"script\",\n  interpreter: t.InterpreterDirective | null = null,\n): t.Program {\n  return validateNode<t.Program>({\n    type: \"Program\",\n    body,\n    directives,\n    sourceType,\n    interpreter,\n    sourceFile: null,\n  });\n}\nexport function objectExpression(\n  properties: Array<t.ObjectMethod | t.ObjectProperty | t.SpreadElement>,\n): t.ObjectExpression {\n  return validateNode<t.ObjectExpression>({\n    type: \"ObjectExpression\",\n    properties,\n  });\n}\nexport function objectMethod(\n  kind: \"method\" | \"get\" | \"set\" | undefined = \"method\",\n  key:\n    | t.Expression\n    | t.Identifier\n    | t.StringLiteral\n    | t.NumericLiteral\n    | t.BigIntLiteral,\n  params: Array<t.Identifier | t.Pattern | t.RestElement>,\n  body: t.BlockStatement,\n  computed: boolean = false,\n  generator: boolean = false,\n  async: boolean = false,\n): t.ObjectMethod {\n  return validateNode<t.ObjectMethod>({\n    type: \"ObjectMethod\",\n    kind,\n    key,\n    params,\n    body,\n    computed,\n    generator,\n    async,\n  });\n}\nexport function objectProperty(\n  key:\n    | t.Expression\n    | t.Identifier\n    | t.StringLiteral\n    | t.NumericLiteral\n    | t.BigIntLiteral\n    | t.DecimalLiteral\n    | t.PrivateName,\n  value: t.Expression | t.PatternLike,\n  computed: boolean = false,\n  shorthand: boolean = false,\n  decorators: Array<t.Decorator> | null = null,\n): t.ObjectProperty {\n  return validateNode<t.ObjectProperty>({\n    type: \"ObjectProperty\",\n    key,\n    value,\n    computed,\n    shorthand,\n    decorators,\n  });\n}\nexport function restElement(argument: t.LVal): t.RestElement {\n  return validateNode<t.RestElement>({\n    type: \"RestElement\",\n    argument,\n  });\n}\nexport function returnStatement(\n  argument: t.Expression | null = null,\n): t.ReturnStatement {\n  return validateNode<t.ReturnStatement>({\n    type: \"ReturnStatement\",\n    argument,\n  });\n}\nexport function sequenceExpression(\n  expressions: Array<t.Expression>,\n): t.SequenceExpression {\n  return validateNode<t.SequenceExpression>({\n    type: \"SequenceExpression\",\n    expressions,\n  });\n}\nexport function parenthesizedExpression(\n  expression: t.Expression,\n): t.ParenthesizedExpression {\n  return validateNode<t.ParenthesizedExpression>({\n    type: \"ParenthesizedExpression\",\n    expression,\n  });\n}\nexport function switchCase(\n  test: t.Expression | null | undefined = null,\n  consequent: Array<t.Statement>,\n): t.SwitchCase {\n  return validateNode<t.SwitchCase>({\n    type: \"SwitchCase\",\n    test,\n    consequent,\n  });\n}\nexport function switchStatement(\n  discriminant: t.Expression,\n  cases: Array<t.SwitchCase>,\n): t.SwitchStatement {\n  return validateNode<t.SwitchStatement>({\n    type: \"SwitchStatement\",\n    discriminant,\n    cases,\n  });\n}\nexport function thisExpression(): t.ThisExpression {\n  return {\n    type: \"ThisExpression\",\n  };\n}\nexport function throwStatement(argument: t.Expression): t.ThrowStatement {\n  return validateNode<t.ThrowStatement>({\n    type: \"ThrowStatement\",\n    argument,\n  });\n}\nexport function tryStatement(\n  block: t.BlockStatement,\n  handler: t.CatchClause | null = null,\n  finalizer: t.BlockStatement | null = null,\n): t.TryStatement {\n  return validateNode<t.TryStatement>({\n    type: \"TryStatement\",\n    block,\n    handler,\n    finalizer,\n  });\n}\nexport function unaryExpression(\n  operator: \"void\" | \"throw\" | \"delete\" | \"!\" | \"+\" | \"-\" | \"~\" | \"typeof\",\n  argument: t.Expression,\n  prefix: boolean = true,\n): t.UnaryExpression {\n  return validateNode<t.UnaryExpression>({\n    type: \"UnaryExpression\",\n    operator,\n    argument,\n    prefix,\n  });\n}\nexport function updateExpression(\n  operator: \"++\" | \"--\",\n  argument: t.Expression,\n  prefix: boolean = false,\n): t.UpdateExpression {\n  return validateNode<t.UpdateExpression>({\n    type: \"UpdateExpression\",\n    operator,\n    argument,\n    prefix,\n  });\n}\nexport function variableDeclaration(\n  kind: \"var\" | \"let\" | \"const\" | \"using\",\n  declarations: Array<t.VariableDeclarator>,\n): t.VariableDeclaration {\n  return validateNode<t.VariableDeclaration>({\n    type: \"VariableDeclaration\",\n    kind,\n    declarations,\n  });\n}\nexport function variableDeclarator(\n  id: t.LVal,\n  init: t.Expression | null = null,\n): t.VariableDeclarator {\n  return validateNode<t.VariableDeclarator>({\n    type: \"VariableDeclarator\",\n    id,\n    init,\n  });\n}\nexport function whileStatement(\n  test: t.Expression,\n  body: t.Statement,\n): t.WhileStatement {\n  return validateNode<t.WhileStatement>({\n    type: \"WhileStatement\",\n    test,\n    body,\n  });\n}\nexport function withStatement(\n  object: t.Expression,\n  body: t.Statement,\n): t.WithStatement {\n  return validateNode<t.WithStatement>({\n    type: \"WithStatement\",\n    object,\n    body,\n  });\n}\nexport function assignmentPattern(\n  left:\n    | t.Identifier\n    | t.ObjectPattern\n    | t.ArrayPattern\n    | t.MemberExpression\n    | t.TSAsExpression\n    | t.TSSatisfiesExpression\n    | t.TSTypeAssertion\n    | t.TSNonNullExpression,\n  right: t.Expression,\n): t.AssignmentPattern {\n  return validateNode<t.AssignmentPattern>({\n    type: \"AssignmentPattern\",\n    left,\n    right,\n  });\n}\nexport function arrayPattern(\n  elements: Array<null | t.PatternLike | t.LVal>,\n): t.ArrayPattern {\n  return validateNode<t.ArrayPattern>({\n    type: \"ArrayPattern\",\n    elements,\n  });\n}\nexport function arrowFunctionExpression(\n  params: Array<t.Identifier | t.Pattern | t.RestElement>,\n  body: t.BlockStatement | t.Expression,\n  async: boolean = false,\n): t.ArrowFunctionExpression {\n  return validateNode<t.ArrowFunctionExpression>({\n    type: \"ArrowFunctionExpression\",\n    params,\n    body,\n    async,\n    expression: null,\n  });\n}\nexport function classBody(\n  body: Array<\n    | t.ClassMethod\n    | t.ClassPrivateMethod\n    | t.ClassProperty\n    | t.ClassPrivateProperty\n    | t.ClassAccessorProperty\n    | t.TSDeclareMethod\n    | t.TSIndexSignature\n    | t.StaticBlock\n  >,\n): t.ClassBody {\n  return validateNode<t.ClassBody>({\n    type: \"ClassBody\",\n    body,\n  });\n}\nexport function classExpression(\n  id: t.Identifier | null | undefined = null,\n  superClass: t.Expression | null | undefined = null,\n  body: t.ClassBody,\n  decorators: Array<t.Decorator> | null = null,\n): t.ClassExpression {\n  return validateNode<t.ClassExpression>({\n    type: \"ClassExpression\",\n    id,\n    superClass,\n    body,\n    decorators,\n  });\n}\nexport function classDeclaration(\n  id: t.Identifier,\n  superClass: t.Expression | null | undefined = null,\n  body: t.ClassBody,\n  decorators: Array<t.Decorator> | null = null,\n): t.ClassDeclaration {\n  return validateNode<t.ClassDeclaration>({\n    type: \"ClassDeclaration\",\n    id,\n    superClass,\n    body,\n    decorators,\n  });\n}\nexport function exportAllDeclaration(\n  source: t.StringLiteral,\n): t.ExportAllDeclaration {\n  return validateNode<t.ExportAllDeclaration>({\n    type: \"ExportAllDeclaration\",\n    source,\n  });\n}\nexport function exportDefaultDeclaration(\n  declaration:\n    | t.TSDeclareFunction\n    | t.FunctionDeclaration\n    | t.ClassDeclaration\n    | t.Expression,\n): t.ExportDefaultDeclaration {\n  return validateNode<t.ExportDefaultDeclaration>({\n    type: \"ExportDefaultDeclaration\",\n    declaration,\n  });\n}\nexport function exportNamedDeclaration(\n  declaration: t.Declaration | null = null,\n  specifiers: Array<\n    t.ExportSpecifier | t.ExportDefaultSpecifier | t.ExportNamespaceSpecifier\n  > = [],\n  source: t.StringLiteral | null = null,\n): t.ExportNamedDeclaration {\n  return validateNode<t.ExportNamedDeclaration>({\n    type: \"ExportNamedDeclaration\",\n    declaration,\n    specifiers,\n    source,\n  });\n}\nexport function exportSpecifier(\n  local: t.Identifier,\n  exported: t.Identifier | t.StringLiteral,\n): t.ExportSpecifier {\n  return validateNode<t.ExportSpecifier>({\n    type: \"ExportSpecifier\",\n    local,\n    exported,\n  });\n}\nexport function forOfStatement(\n  left: t.VariableDeclaration | t.LVal,\n  right: t.Expression,\n  body: t.Statement,\n  _await: boolean = false,\n): t.ForOfStatement {\n  return validateNode<t.ForOfStatement>({\n    type: \"ForOfStatement\",\n    left,\n    right,\n    body,\n    await: _await,\n  });\n}\nexport function importDeclaration(\n  specifiers: Array<\n    t.ImportSpecifier | t.ImportDefaultSpecifier | t.ImportNamespaceSpecifier\n  >,\n  source: t.StringLiteral,\n): t.ImportDeclaration {\n  return validateNode<t.ImportDeclaration>({\n    type: \"ImportDeclaration\",\n    specifiers,\n    source,\n  });\n}\nexport function importDefaultSpecifier(\n  local: t.Identifier,\n): t.ImportDefaultSpecifier {\n  return validateNode<t.ImportDefaultSpecifier>({\n    type: \"ImportDefaultSpecifier\",\n    local,\n  });\n}\nexport function importNamespaceSpecifier(\n  local: t.Identifier,\n): t.ImportNamespaceSpecifier {\n  return validateNode<t.ImportNamespaceSpecifier>({\n    type: \"ImportNamespaceSpecifier\",\n    local,\n  });\n}\nexport function importSpecifier(\n  local: t.Identifier,\n  imported: t.Identifier | t.StringLiteral,\n): t.ImportSpecifier {\n  return validateNode<t.ImportSpecifier>({\n    type: \"ImportSpecifier\",\n    local,\n    imported,\n  });\n}\nexport function metaProperty(\n  meta: t.Identifier,\n  property: t.Identifier,\n): t.MetaProperty {\n  return validateNode<t.MetaProperty>({\n    type: \"MetaProperty\",\n    meta,\n    property,\n  });\n}\nexport function classMethod(\n  kind: \"get\" | \"set\" | \"method\" | \"constructor\" | undefined = \"method\",\n  key:\n    | t.Identifier\n    | t.StringLiteral\n    | t.NumericLiteral\n    | t.BigIntLiteral\n    | t.Expression,\n  params: Array<\n    t.Identifier | t.Pattern | t.RestElement | t.TSParameterProperty\n  >,\n  body: t.BlockStatement,\n  computed: boolean = false,\n  _static: boolean = false,\n  generator: boolean = false,\n  async: boolean = false,\n): t.ClassMethod {\n  return validateNode<t.ClassMethod>({\n    type: \"ClassMethod\",\n    kind,\n    key,\n    params,\n    body,\n    computed,\n    static: _static,\n    generator,\n    async,\n  });\n}\nexport function objectPattern(\n  properties: Array<t.RestElement | t.ObjectProperty>,\n): t.ObjectPattern {\n  return validateNode<t.ObjectPattern>({\n    type: \"ObjectPattern\",\n    properties,\n  });\n}\nexport function spreadElement(argument: t.Expression): t.SpreadElement {\n  return validateNode<t.SpreadElement>({\n    type: \"SpreadElement\",\n    argument,\n  });\n}\nfunction _super(): t.Super {\n  return {\n    type: \"Super\",\n  };\n}\nexport { _super as super };\nexport function taggedTemplateExpression(\n  tag: t.Expression,\n  quasi: t.TemplateLiteral,\n): t.TaggedTemplateExpression {\n  return validateNode<t.TaggedTemplateExpression>({\n    type: \"TaggedTemplateExpression\",\n    tag,\n    quasi,\n  });\n}\nexport function templateElement(\n  value: { raw: string; cooked?: string },\n  tail: boolean = false,\n): t.TemplateElement {\n  return validateNode<t.TemplateElement>({\n    type: \"TemplateElement\",\n    value,\n    tail,\n  });\n}\nexport function templateLiteral(\n  quasis: Array<t.TemplateElement>,\n  expressions: Array<t.Expression | t.TSType>,\n): t.TemplateLiteral {\n  return validateNode<t.TemplateLiteral>({\n    type: \"TemplateLiteral\",\n    quasis,\n    expressions,\n  });\n}\nexport function yieldExpression(\n  argument: t.Expression | null = null,\n  delegate: boolean = false,\n): t.YieldExpression {\n  return validateNode<t.YieldExpression>({\n    type: \"YieldExpression\",\n    argument,\n    delegate,\n  });\n}\nexport function awaitExpression(argument: t.Expression): t.AwaitExpression {\n  return validateNode<t.AwaitExpression>({\n    type: \"AwaitExpression\",\n    argument,\n  });\n}\nfunction _import(): t.Import {\n  return {\n    type: \"Import\",\n  };\n}\nexport { _import as import };\nexport function bigIntLiteral(value: string): t.BigIntLiteral {\n  return validateNode<t.BigIntLiteral>({\n    type: \"BigIntLiteral\",\n    value,\n  });\n}\nexport function exportNamespaceSpecifier(\n  exported: t.Identifier,\n): t.ExportNamespaceSpecifier {\n  return validateNode<t.ExportNamespaceSpecifier>({\n    type: \"ExportNamespaceSpecifier\",\n    exported,\n  });\n}\nexport function optionalMemberExpression(\n  object: t.Expression,\n  property: t.Expression | t.Identifier,\n  computed: boolean | undefined = false,\n  optional: boolean,\n): t.OptionalMemberExpression {\n  return validateNode<t.OptionalMemberExpression>({\n    type: \"OptionalMemberExpression\",\n    object,\n    property,\n    computed,\n    optional,\n  });\n}\nexport function optionalCallExpression(\n  callee: t.Expression,\n  _arguments: Array<\n    t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder\n  >,\n  optional: boolean,\n): t.OptionalCallExpression {\n  return validateNode<t.OptionalCallExpression>({\n    type: \"OptionalCallExpression\",\n    callee,\n    arguments: _arguments,\n    optional,\n  });\n}\nexport function classProperty(\n  key:\n    | t.Identifier\n    | t.StringLiteral\n    | t.NumericLiteral\n    | t.BigIntLiteral\n    | t.Expression,\n  value: t.Expression | null = null,\n  typeAnnotation: t.TypeAnnotation | t.TSTypeAnnotation | t.Noop | null = null,\n  decorators: Array<t.Decorator> | null = null,\n  computed: boolean = false,\n  _static: boolean = false,\n): t.ClassProperty {\n  return validateNode<t.ClassProperty>({\n    type: \"ClassProperty\",\n    key,\n    value,\n    typeAnnotation,\n    decorators,\n    computed,\n    static: _static,\n  });\n}\nexport function classAccessorProperty(\n  key:\n    | t.Identifier\n    | t.StringLiteral\n    | t.NumericLiteral\n    | t.BigIntLiteral\n    | t.Expression\n    | t.PrivateName,\n  value: t.Expression | null = null,\n  typeAnnotation: t.TypeAnnotation | t.TSTypeAnnotation | t.Noop | null = null,\n  decorators: Array<t.Decorator> | null = null,\n  computed: boolean = false,\n  _static: boolean = false,\n): t.ClassAccessorProperty {\n  return validateNode<t.ClassAccessorProperty>({\n    type: \"ClassAccessorProperty\",\n    key,\n    value,\n    typeAnnotation,\n    decorators,\n    computed,\n    static: _static,\n  });\n}\nexport function classPrivateProperty(\n  key: t.PrivateName,\n  value: t.Expression | null = null,\n  decorators: Array<t.Decorator> | null = null,\n  _static: boolean = false,\n): t.ClassPrivateProperty {\n  return validateNode<t.ClassPrivateProperty>({\n    type: \"ClassPrivateProperty\",\n    key,\n    value,\n    decorators,\n    static: _static,\n  });\n}\nexport function classPrivateMethod(\n  kind: \"get\" | \"set\" | \"method\" | undefined = \"method\",\n  key: t.PrivateName,\n  params: Array<\n    t.Identifier | t.Pattern | t.RestElement | t.TSParameterProperty\n  >,\n  body: t.BlockStatement,\n  _static: boolean = false,\n): t.ClassPrivateMethod {\n  return validateNode<t.ClassPrivateMethod>({\n    type: \"ClassPrivateMethod\",\n    kind,\n    key,\n    params,\n    body,\n    static: _static,\n  });\n}\nexport function privateName(id: t.Identifier): t.PrivateName {\n  return validateNode<t.PrivateName>({\n    type: \"PrivateName\",\n    id,\n  });\n}\nexport function staticBlock(body: Array<t.Statement>): t.StaticBlock {\n  return validateNode<t.StaticBlock>({\n    type: \"StaticBlock\",\n    body,\n  });\n}\nexport function anyTypeAnnotation(): t.AnyTypeAnnotation {\n  return {\n    type: \"AnyTypeAnnotation\",\n  };\n}\nexport function arrayTypeAnnotation(\n  elementType: t.FlowType,\n): t.ArrayTypeAnnotation {\n  return validateNode<t.ArrayTypeAnnotation>({\n    type: \"ArrayTypeAnnotation\",\n    elementType,\n  });\n}\nexport function booleanTypeAnnotation(): t.BooleanTypeAnnotation {\n  return {\n    type: \"BooleanTypeAnnotation\",\n  };\n}\nexport function booleanLiteralTypeAnnotation(\n  value: boolean,\n): t.BooleanLiteralTypeAnnotation {\n  return validateNode<t.BooleanLiteralTypeAnnotation>({\n    type: \"BooleanLiteralTypeAnnotation\",\n    value,\n  });\n}\nexport function nullLiteralTypeAnnotation(): t.NullLiteralTypeAnnotation {\n  return {\n    type: \"NullLiteralTypeAnnotation\",\n  };\n}\nexport function classImplements(\n  id: t.Identifier,\n  typeParameters: t.TypeParameterInstantiation | null = null,\n): t.ClassImplements {\n  return validateNode<t.ClassImplements>({\n    type: \"ClassImplements\",\n    id,\n    typeParameters,\n  });\n}\nexport function declareClass(\n  id: t.Identifier,\n  typeParameters: t.TypeParameterDeclaration | null | undefined = null,\n  _extends: Array<t.InterfaceExtends> | null | undefined = null,\n  body: t.ObjectTypeAnnotation,\n): t.DeclareClass {\n  return validateNode<t.DeclareClass>({\n    type: \"DeclareClass\",\n    id,\n    typeParameters,\n    extends: _extends,\n    body,\n  });\n}\nexport function declareFunction(id: t.Identifier): t.DeclareFunction {\n  return validateNode<t.DeclareFunction>({\n    type: \"DeclareFunction\",\n    id,\n  });\n}\nexport function declareInterface(\n  id: t.Identifier,\n  typeParameters: t.TypeParameterDeclaration | null | undefined = null,\n  _extends: Array<t.InterfaceExtends> | null | undefined = null,\n  body: t.ObjectTypeAnnotation,\n): t.DeclareInterface {\n  return validateNode<t.DeclareInterface>({\n    type: \"DeclareInterface\",\n    id,\n    typeParameters,\n    extends: _extends,\n    body,\n  });\n}\nexport function declareModule(\n  id: t.Identifier | t.StringLiteral,\n  body: t.BlockStatement,\n  kind: \"CommonJS\" | \"ES\" | null = null,\n): t.DeclareModule {\n  return validateNode<t.DeclareModule>({\n    type: \"DeclareModule\",\n    id,\n    body,\n    kind,\n  });\n}\nexport function declareModuleExports(\n  typeAnnotation: t.TypeAnnotation,\n): t.DeclareModuleExports {\n  return validateNode<t.DeclareModuleExports>({\n    type: \"DeclareModuleExports\",\n    typeAnnotation,\n  });\n}\nexport function declareTypeAlias(\n  id: t.Identifier,\n  typeParameters: t.TypeParameterDeclaration | null | undefined = null,\n  right: t.FlowType,\n): t.DeclareTypeAlias {\n  return validateNode<t.DeclareTypeAlias>({\n    type: \"DeclareTypeAlias\",\n    id,\n    typeParameters,\n    right,\n  });\n}\nexport function declareOpaqueType(\n  id: t.Identifier,\n  typeParameters: t.TypeParameterDeclaration | null = null,\n  supertype: t.FlowType | null = null,\n): t.DeclareOpaqueType {\n  return validateNode<t.DeclareOpaqueType>({\n    type: \"DeclareOpaqueType\",\n    id,\n    typeParameters,\n    supertype,\n  });\n}\nexport function declareVariable(id: t.Identifier): t.DeclareVariable {\n  return validateNode<t.DeclareVariable>({\n    type: \"DeclareVariable\",\n    id,\n  });\n}\nexport function declareExportDeclaration(\n  declaration: t.Flow | null = null,\n  specifiers: Array<\n    t.ExportSpecifier | t.ExportNamespaceSpecifier\n  > | null = null,\n  source: t.StringLiteral | null = null,\n): t.DeclareExportDeclaration {\n  return validateNode<t.DeclareExportDeclaration>({\n    type: \"DeclareExportDeclaration\",\n    declaration,\n    specifiers,\n    source,\n  });\n}\nexport function declareExportAllDeclaration(\n  source: t.StringLiteral,\n): t.DeclareExportAllDeclaration {\n  return validateNode<t.DeclareExportAllDeclaration>({\n    type: \"DeclareExportAllDeclaration\",\n    source,\n  });\n}\nexport function declaredPredicate(value: t.Flow): t.DeclaredPredicate {\n  return validateNode<t.DeclaredPredicate>({\n    type: \"DeclaredPredicate\",\n    value,\n  });\n}\nexport function existsTypeAnnotation(): t.ExistsTypeAnnotation {\n  return {\n    type: \"ExistsTypeAnnotation\",\n  };\n}\nexport function functionTypeAnnotation(\n  typeParameters: t.TypeParameterDeclaration | null | undefined = null,\n  params: Array<t.FunctionTypeParam>,\n  rest: t.FunctionTypeParam | null | undefined = null,\n  returnType: t.FlowType,\n): t.FunctionTypeAnnotation {\n  return validateNode<t.FunctionTypeAnnotation>({\n    type: \"FunctionTypeAnnotation\",\n    typeParameters,\n    params,\n    rest,\n    returnType,\n  });\n}\nexport function functionTypeParam(\n  name: t.Identifier | null | undefined = null,\n  typeAnnotation: t.FlowType,\n): t.FunctionTypeParam {\n  return validateNode<t.FunctionTypeParam>({\n    type: \"FunctionTypeParam\",\n    name,\n    typeAnnotation,\n  });\n}\nexport function genericTypeAnnotation(\n  id: t.Identifier | t.QualifiedTypeIdentifier,\n  typeParameters: t.TypeParameterInstantiation | null = null,\n): t.GenericTypeAnnotation {\n  return validateNode<t.GenericTypeAnnotation>({\n    type: \"GenericTypeAnnotation\",\n    id,\n    typeParameters,\n  });\n}\nexport function inferredPredicate(): t.InferredPredicate {\n  return {\n    type: \"InferredPredicate\",\n  };\n}\nexport function interfaceExtends(\n  id: t.Identifier | t.QualifiedTypeIdentifier,\n  typeParameters: t.TypeParameterInstantiation | null = null,\n): t.InterfaceExtends {\n  return validateNode<t.InterfaceExtends>({\n    type: \"InterfaceExtends\",\n    id,\n    typeParameters,\n  });\n}\nexport function interfaceDeclaration(\n  id: t.Identifier,\n  typeParameters: t.TypeParameterDeclaration | null | undefined = null,\n  _extends: Array<t.InterfaceExtends> | null | undefined = null,\n  body: t.ObjectTypeAnnotation,\n): t.InterfaceDeclaration {\n  return validateNode<t.InterfaceDeclaration>({\n    type: \"InterfaceDeclaration\",\n    id,\n    typeParameters,\n    extends: _extends,\n    body,\n  });\n}\nexport function interfaceTypeAnnotation(\n  _extends: Array<t.InterfaceExtends> | null | undefined = null,\n  body: t.ObjectTypeAnnotation,\n): t.InterfaceTypeAnnotation {\n  return validateNode<t.InterfaceTypeAnnotation>({\n    type: \"InterfaceTypeAnnotation\",\n    extends: _extends,\n    body,\n  });\n}\nexport function intersectionTypeAnnotation(\n  types: Array<t.FlowType>,\n): t.IntersectionTypeAnnotation {\n  return validateNode<t.IntersectionTypeAnnotation>({\n    type: \"IntersectionTypeAnnotation\",\n    types,\n  });\n}\nexport function mixedTypeAnnotation(): t.MixedTypeAnnotation {\n  return {\n    type: \"MixedTypeAnnotation\",\n  };\n}\nexport function emptyTypeAnnotation(): t.EmptyTypeAnnotation {\n  return {\n    type: \"EmptyTypeAnnotation\",\n  };\n}\nexport function nullableTypeAnnotation(\n  typeAnnotation: t.FlowType,\n): t.NullableTypeAnnotation {\n  return validateNode<t.NullableTypeAnnotation>({\n    type: \"NullableTypeAnnotation\",\n    typeAnnotation,\n  });\n}\nexport function numberLiteralTypeAnnotation(\n  value: number,\n): t.NumberLiteralTypeAnnotation {\n  return validateNode<t.NumberLiteralTypeAnnotation>({\n    type: \"NumberLiteralTypeAnnotation\",\n    value,\n  });\n}\nexport function numberTypeAnnotation(): t.NumberTypeAnnotation {\n  return {\n    type: \"NumberTypeAnnotation\",\n  };\n}\nexport function objectTypeAnnotation(\n  properties: Array<t.ObjectTypeProperty | t.ObjectTypeSpreadProperty>,\n  indexers: Array<t.ObjectTypeIndexer> = [],\n  callProperties: Array<t.ObjectTypeCallProperty> = [],\n  internalSlots: Array<t.ObjectTypeInternalSlot> = [],\n  exact: boolean = false,\n): t.ObjectTypeAnnotation {\n  return validateNode<t.ObjectTypeAnnotation>({\n    type: \"ObjectTypeAnnotation\",\n    properties,\n    indexers,\n    callProperties,\n    internalSlots,\n    exact,\n  });\n}\nexport function objectTypeInternalSlot(\n  id: t.Identifier,\n  value: t.FlowType,\n  optional: boolean,\n  _static: boolean,\n  method: boolean,\n): t.ObjectTypeInternalSlot {\n  return validateNode<t.ObjectTypeInternalSlot>({\n    type: \"ObjectTypeInternalSlot\",\n    id,\n    value,\n    optional,\n    static: _static,\n    method,\n  });\n}\nexport function objectTypeCallProperty(\n  value: t.FlowType,\n): t.ObjectTypeCallProperty {\n  return validateNode<t.ObjectTypeCallProperty>({\n    type: \"ObjectTypeCallProperty\",\n    value,\n    static: null,\n  });\n}\nexport function objectTypeIndexer(\n  id: t.Identifier | null | undefined = null,\n  key: t.FlowType,\n  value: t.FlowType,\n  variance: t.Variance | null = null,\n): t.ObjectTypeIndexer {\n  return validateNode<t.ObjectTypeIndexer>({\n    type: \"ObjectTypeIndexer\",\n    id,\n    key,\n    value,\n    variance,\n    static: null,\n  });\n}\nexport function objectTypeProperty(\n  key: t.Identifier | t.StringLiteral,\n  value: t.FlowType,\n  variance: t.Variance | null = null,\n): t.ObjectTypeProperty {\n  return validateNode<t.ObjectTypeProperty>({\n    type: \"ObjectTypeProperty\",\n    key,\n    value,\n    variance,\n    kind: null,\n    method: null,\n    optional: null,\n    proto: null,\n    static: null,\n  });\n}\nexport function objectTypeSpreadProperty(\n  argument: t.FlowType,\n): t.ObjectTypeSpreadProperty {\n  return validateNode<t.ObjectTypeSpreadProperty>({\n    type: \"ObjectTypeSpreadProperty\",\n    argument,\n  });\n}\nexport function opaqueType(\n  id: t.Identifier,\n  typeParameters: t.TypeParameterDeclaration | null | undefined = null,\n  supertype: t.FlowType | null | undefined = null,\n  impltype: t.FlowType,\n): t.OpaqueType {\n  return validateNode<t.OpaqueType>({\n    type: \"OpaqueType\",\n    id,\n    typeParameters,\n    supertype,\n    impltype,\n  });\n}\nexport function qualifiedTypeIdentifier(\n  id: t.Identifier,\n  qualification: t.Identifier | t.QualifiedTypeIdentifier,\n): t.QualifiedTypeIdentifier {\n  return validateNode<t.QualifiedTypeIdentifier>({\n    type: \"QualifiedTypeIdentifier\",\n    id,\n    qualification,\n  });\n}\nexport function stringLiteralTypeAnnotation(\n  value: string,\n): t.StringLiteralTypeAnnotation {\n  return validateNode<t.StringLiteralTypeAnnotation>({\n    type: \"StringLiteralTypeAnnotation\",\n    value,\n  });\n}\nexport function stringTypeAnnotation(): t.StringTypeAnnotation {\n  return {\n    type: \"StringTypeAnnotation\",\n  };\n}\nexport function symbolTypeAnnotation(): t.SymbolTypeAnnotation {\n  return {\n    type: \"SymbolTypeAnnotation\",\n  };\n}\nexport function thisTypeAnnotation(): t.ThisTypeAnnotation {\n  return {\n    type: \"ThisTypeAnnotation\",\n  };\n}\nexport function tupleTypeAnnotation(\n  types: Array<t.FlowType>,\n): t.TupleTypeAnnotation {\n  return validateNode<t.TupleTypeAnnotation>({\n    type: \"TupleTypeAnnotation\",\n    types,\n  });\n}\nexport function typeofTypeAnnotation(\n  argument: t.FlowType,\n): t.TypeofTypeAnnotation {\n  return validateNode<t.TypeofTypeAnnotation>({\n    type: \"TypeofTypeAnnotation\",\n    argument,\n  });\n}\nexport function typeAlias(\n  id: t.Identifier,\n  typeParameters: t.TypeParameterDeclaration | null | undefined = null,\n  right: t.FlowType,\n): t.TypeAlias {\n  return validateNode<t.TypeAlias>({\n    type: \"TypeAlias\",\n    id,\n    typeParameters,\n    right,\n  });\n}\nexport function typeAnnotation(typeAnnotation: t.FlowType): t.TypeAnnotation {\n  return validateNode<t.TypeAnnotation>({\n    type: \"TypeAnnotation\",\n    typeAnnotation,\n  });\n}\nexport function typeCastExpression(\n  expression: t.Expression,\n  typeAnnotation: t.TypeAnnotation,\n): t.TypeCastExpression {\n  return validateNode<t.TypeCastExpression>({\n    type: \"TypeCastExpression\",\n    expression,\n    typeAnnotation,\n  });\n}\nexport function typeParameter(\n  bound: t.TypeAnnotation | null = null,\n  _default: t.FlowType | null = null,\n  variance: t.Variance | null = null,\n): t.TypeParameter {\n  return validateNode<t.TypeParameter>({\n    type: \"TypeParameter\",\n    bound,\n    default: _default,\n    variance,\n    name: null,\n  });\n}\nexport function typeParameterDeclaration(\n  params: Array<t.TypeParameter>,\n): t.TypeParameterDeclaration {\n  return validateNode<t.TypeParameterDeclaration>({\n    type: \"TypeParameterDeclaration\",\n    params,\n  });\n}\nexport function typeParameterInstantiation(\n  params: Array<t.FlowType>,\n): t.TypeParameterInstantiation {\n  return validateNode<t.TypeParameterInstantiation>({\n    type: \"TypeParameterInstantiation\",\n    params,\n  });\n}\nexport function unionTypeAnnotation(\n  types: Array<t.FlowType>,\n): t.UnionTypeAnnotation {\n  return validateNode<t.UnionTypeAnnotation>({\n    type: \"UnionTypeAnnotation\",\n    types,\n  });\n}\nexport function variance(kind: \"minus\" | \"plus\"): t.Variance {\n  return validateNode<t.Variance>({\n    type: \"Variance\",\n    kind,\n  });\n}\nexport function voidTypeAnnotation(): t.VoidTypeAnnotation {\n  return {\n    type: \"VoidTypeAnnotation\",\n  };\n}\nexport function enumDeclaration(\n  id: t.Identifier,\n  body:\n    | t.EnumBooleanBody\n    | t.EnumNumberBody\n    | t.EnumStringBody\n    | t.EnumSymbolBody,\n): t.EnumDeclaration {\n  return validateNode<t.EnumDeclaration>({\n    type: \"EnumDeclaration\",\n    id,\n    body,\n  });\n}\nexport function enumBooleanBody(\n  members: Array<t.EnumBooleanMember>,\n): t.EnumBooleanBody {\n  return validateNode<t.EnumBooleanBody>({\n    type: \"EnumBooleanBody\",\n    members,\n    explicitType: null,\n    hasUnknownMembers: null,\n  });\n}\nexport function enumNumberBody(\n  members: Array<t.EnumNumberMember>,\n): t.EnumNumberBody {\n  return validateNode<t.EnumNumberBody>({\n    type: \"EnumNumberBody\",\n    members,\n    explicitType: null,\n    hasUnknownMembers: null,\n  });\n}\nexport function enumStringBody(\n  members: Array<t.EnumStringMember | t.EnumDefaultedMember>,\n): t.EnumStringBody {\n  return validateNode<t.EnumStringBody>({\n    type: \"EnumStringBody\",\n    members,\n    explicitType: null,\n    hasUnknownMembers: null,\n  });\n}\nexport function enumSymbolBody(\n  members: Array<t.EnumDefaultedMember>,\n): t.EnumSymbolBody {\n  return validateNode<t.EnumSymbolBody>({\n    type: \"EnumSymbolBody\",\n    members,\n    hasUnknownMembers: null,\n  });\n}\nexport function enumBooleanMember(id: t.Identifier): t.EnumBooleanMember {\n  return validateNode<t.EnumBooleanMember>({\n    type: \"EnumBooleanMember\",\n    id,\n    init: null,\n  });\n}\nexport function enumNumberMember(\n  id: t.Identifier,\n  init: t.NumericLiteral,\n): t.EnumNumberMember {\n  return validateNode<t.EnumNumberMember>({\n    type: \"EnumNumberMember\",\n    id,\n    init,\n  });\n}\nexport function enumStringMember(\n  id: t.Identifier,\n  init: t.StringLiteral,\n): t.EnumStringMember {\n  return validateNode<t.EnumStringMember>({\n    type: \"EnumStringMember\",\n    id,\n    init,\n  });\n}\nexport function enumDefaultedMember(id: t.Identifier): t.EnumDefaultedMember {\n  return validateNode<t.EnumDefaultedMember>({\n    type: \"EnumDefaultedMember\",\n    id,\n  });\n}\nexport function indexedAccessType(\n  objectType: t.FlowType,\n  indexType: t.FlowType,\n): t.IndexedAccessType {\n  return validateNode<t.IndexedAccessType>({\n    type: \"IndexedAccessType\",\n    objectType,\n    indexType,\n  });\n}\nexport function optionalIndexedAccessType(\n  objectType: t.FlowType,\n  indexType: t.FlowType,\n): t.OptionalIndexedAccessType {\n  return validateNode<t.OptionalIndexedAccessType>({\n    type: \"OptionalIndexedAccessType\",\n    objectType,\n    indexType,\n    optional: null,\n  });\n}\nexport function jsxAttribute(\n  name: t.JSXIdentifier | t.JSXNamespacedName,\n  value:\n    | t.JSXElement\n    | t.JSXFragment\n    | t.StringLiteral\n    | t.JSXExpressionContainer\n    | null = null,\n): t.JSXAttribute {\n  return validateNode<t.JSXAttribute>({\n    type: \"JSXAttribute\",\n    name,\n    value,\n  });\n}\nexport { jsxAttribute as jSXAttribute };\nexport function jsxClosingElement(\n  name: t.JSXIdentifier | t.JSXMemberExpression | t.JSXNamespacedName,\n): t.JSXClosingElement {\n  return validateNode<t.JSXClosingElement>({\n    type: \"JSXClosingElement\",\n    name,\n  });\n}\nexport { jsxClosingElement as jSXClosingElement };\nexport function jsxElement(\n  openingElement: t.JSXOpeningElement,\n  closingElement: t.JSXClosingElement | null | undefined = null,\n  children: Array<\n    | t.JSXText\n    | t.JSXExpressionContainer\n    | t.JSXSpreadChild\n    | t.JSXElement\n    | t.JSXFragment\n  >,\n  selfClosing: boolean | null = null,\n): t.JSXElement {\n  return validateNode<t.JSXElement>({\n    type: \"JSXElement\",\n    openingElement,\n    closingElement,\n    children,\n    selfClosing,\n  });\n}\nexport { jsxElement as jSXElement };\nexport function jsxEmptyExpression(): t.JSXEmptyExpression {\n  return {\n    type: \"JSXEmptyExpression\",\n  };\n}\nexport { jsxEmptyExpression as jSXEmptyExpression };\nexport function jsxExpressionContainer(\n  expression: t.Expression | t.JSXEmptyExpression,\n): t.JSXExpressionContainer {\n  return validateNode<t.JSXExpressionContainer>({\n    type: \"JSXExpressionContainer\",\n    expression,\n  });\n}\nexport { jsxExpressionContainer as jSXExpressionContainer };\nexport function jsxSpreadChild(expression: t.Expression): t.JSXSpreadChild {\n  return validateNode<t.JSXSpreadChild>({\n    type: \"JSXSpreadChild\",\n    expression,\n  });\n}\nexport { jsxSpreadChild as jSXSpreadChild };\nexport function jsxIdentifier(name: string): t.JSXIdentifier {\n  return validateNode<t.JSXIdentifier>({\n    type: \"JSXIdentifier\",\n    name,\n  });\n}\nexport { jsxIdentifier as jSXIdentifier };\nexport function jsxMemberExpression(\n  object: t.JSXMemberExpression | t.JSXIdentifier,\n  property: t.JSXIdentifier,\n): t.JSXMemberExpression {\n  return validateNode<t.JSXMemberExpression>({\n    type: \"JSXMemberExpression\",\n    object,\n    property,\n  });\n}\nexport { jsxMemberExpression as jSXMemberExpression };\nexport function jsxNamespacedName(\n  namespace: t.JSXIdentifier,\n  name: t.JSXIdentifier,\n): t.JSXNamespacedName {\n  return validateNode<t.JSXNamespacedName>({\n    type: \"JSXNamespacedName\",\n    namespace,\n    name,\n  });\n}\nexport { jsxNamespacedName as jSXNamespacedName };\nexport function jsxOpeningElement(\n  name: t.JSXIdentifier | t.JSXMemberExpression | t.JSXNamespacedName,\n  attributes: Array<t.JSXAttribute | t.JSXSpreadAttribute>,\n  selfClosing: boolean = false,\n): t.JSXOpeningElement {\n  return validateNode<t.JSXOpeningElement>({\n    type: \"JSXOpeningElement\",\n    name,\n    attributes,\n    selfClosing,\n  });\n}\nexport { jsxOpeningElement as jSXOpeningElement };\nexport function jsxSpreadAttribute(\n  argument: t.Expression,\n): t.JSXSpreadAttribute {\n  return validateNode<t.JSXSpreadAttribute>({\n    type: \"JSXSpreadAttribute\",\n    argument,\n  });\n}\nexport { jsxSpreadAttribute as jSXSpreadAttribute };\nexport function jsxText(value: string): t.JSXText {\n  return validateNode<t.JSXText>({\n    type: \"JSXText\",\n    value,\n  });\n}\nexport { jsxText as jSXText };\nexport function jsxFragment(\n  openingFragment: t.JSXOpeningFragment,\n  closingFragment: t.JSXClosingFragment,\n  children: Array<\n    | t.JSXText\n    | t.JSXExpressionContainer\n    | t.JSXSpreadChild\n    | t.JSXElement\n    | t.JSXFragment\n  >,\n): t.JSXFragment {\n  return validateNode<t.JSXFragment>({\n    type: \"JSXFragment\",\n    openingFragment,\n    closingFragment,\n    children,\n  });\n}\nexport { jsxFragment as jSXFragment };\nexport function jsxOpeningFragment(): t.JSXOpeningFragment {\n  return {\n    type: \"JSXOpeningFragment\",\n  };\n}\nexport { jsxOpeningFragment as jSXOpeningFragment };\nexport function jsxClosingFragment(): t.JSXClosingFragment {\n  return {\n    type: \"JSXClosingFragment\",\n  };\n}\nexport { jsxClosingFragment as jSXClosingFragment };\nexport function noop(): t.Noop {\n  return {\n    type: \"Noop\",\n  };\n}\nexport function placeholder(\n  expectedNode:\n    | \"Identifier\"\n    | \"StringLiteral\"\n    | \"Expression\"\n    | \"Statement\"\n    | \"Declaration\"\n    | \"BlockStatement\"\n    | \"ClassBody\"\n    | \"Pattern\",\n  name: t.Identifier,\n): t.Placeholder {\n  return validateNode<t.Placeholder>({\n    type: \"Placeholder\",\n    expectedNode,\n    name,\n  });\n}\nexport function v8IntrinsicIdentifier(name: string): t.V8IntrinsicIdentifier {\n  return validateNode<t.V8IntrinsicIdentifier>({\n    type: \"V8IntrinsicIdentifier\",\n    name,\n  });\n}\nexport function argumentPlaceholder(): t.ArgumentPlaceholder {\n  return {\n    type: \"ArgumentPlaceholder\",\n  };\n}\nexport function bindExpression(\n  object: t.Expression,\n  callee: t.Expression,\n): t.BindExpression {\n  return validateNode<t.BindExpression>({\n    type: \"BindExpression\",\n    object,\n    callee,\n  });\n}\nexport function importAttribute(\n  key: t.Identifier | t.StringLiteral,\n  value: t.StringLiteral,\n): t.ImportAttribute {\n  return validateNode<t.ImportAttribute>({\n    type: \"ImportAttribute\",\n    key,\n    value,\n  });\n}\nexport function decorator(expression: t.Expression): t.Decorator {\n  return validateNode<t.Decorator>({\n    type: \"Decorator\",\n    expression,\n  });\n}\nexport function doExpression(\n  body: t.BlockStatement,\n  async: boolean = false,\n): t.DoExpression {\n  return validateNode<t.DoExpression>({\n    type: \"DoExpression\",\n    body,\n    async,\n  });\n}\nexport function exportDefaultSpecifier(\n  exported: t.Identifier,\n): t.ExportDefaultSpecifier {\n  return validateNode<t.ExportDefaultSpecifier>({\n    type: \"ExportDefaultSpecifier\",\n    exported,\n  });\n}\nexport function recordExpression(\n  properties: Array<t.ObjectProperty | t.SpreadElement>,\n): t.RecordExpression {\n  return validateNode<t.RecordExpression>({\n    type: \"RecordExpression\",\n    properties,\n  });\n}\nexport function tupleExpression(\n  elements: Array<t.Expression | t.SpreadElement> = [],\n): t.TupleExpression {\n  return validateNode<t.TupleExpression>({\n    type: \"TupleExpression\",\n    elements,\n  });\n}\nexport function decimalLiteral(value: string): t.DecimalLiteral {\n  return validateNode<t.DecimalLiteral>({\n    type: \"DecimalLiteral\",\n    value,\n  });\n}\nexport function moduleExpression(body: t.Program): t.ModuleExpression {\n  return validateNode<t.ModuleExpression>({\n    type: \"ModuleExpression\",\n    body,\n  });\n}\nexport function topicReference(): t.TopicReference {\n  return {\n    type: \"TopicReference\",\n  };\n}\nexport function pipelineTopicExpression(\n  expression: t.Expression,\n): t.PipelineTopicExpression {\n  return validateNode<t.PipelineTopicExpression>({\n    type: \"PipelineTopicExpression\",\n    expression,\n  });\n}\nexport function pipelineBareFunction(\n  callee: t.Expression,\n): t.PipelineBareFunction {\n  return validateNode<t.PipelineBareFunction>({\n    type: \"PipelineBareFunction\",\n    callee,\n  });\n}\nexport function pipelinePrimaryTopicReference(): t.PipelinePrimaryTopicReference {\n  return {\n    type: \"PipelinePrimaryTopicReference\",\n  };\n}\nexport function tsParameterProperty(\n  parameter: t.Identifier | t.AssignmentPattern,\n): t.TSParameterProperty {\n  return validateNode<t.TSParameterProperty>({\n    type: \"TSParameterProperty\",\n    parameter,\n  });\n}\nexport { tsParameterProperty as tSParameterProperty };\nexport function tsDeclareFunction(\n  id: t.Identifier | null | undefined = null,\n  typeParameters:\n    | t.TSTypeParameterDeclaration\n    | t.Noop\n    | null\n    | undefined = null,\n  params: Array<t.Identifier | t.Pattern | t.RestElement>,\n  returnType: t.TSTypeAnnotation | t.Noop | null = null,\n): t.TSDeclareFunction {\n  return validateNode<t.TSDeclareFunction>({\n    type: \"TSDeclareFunction\",\n    id,\n    typeParameters,\n    params,\n    returnType,\n  });\n}\nexport { tsDeclareFunction as tSDeclareFunction };\nexport function tsDeclareMethod(\n  decorators: Array<t.Decorator> | null | undefined = null,\n  key:\n    | t.Identifier\n    | t.StringLiteral\n    | t.NumericLiteral\n    | t.BigIntLiteral\n    | t.Expression,\n  typeParameters:\n    | t.TSTypeParameterDeclaration\n    | t.Noop\n    | null\n    | undefined = null,\n  params: Array<\n    t.Identifier | t.Pattern | t.RestElement | t.TSParameterProperty\n  >,\n  returnType: t.TSTypeAnnotation | t.Noop | null = null,\n): t.TSDeclareMethod {\n  return validateNode<t.TSDeclareMethod>({\n    type: \"TSDeclareMethod\",\n    decorators,\n    key,\n    typeParameters,\n    params,\n    returnType,\n  });\n}\nexport { tsDeclareMethod as tSDeclareMethod };\nexport function tsQualifiedName(\n  left: t.TSEntityName,\n  right: t.Identifier,\n): t.TSQualifiedName {\n  return validateNode<t.TSQualifiedName>({\n    type: \"TSQualifiedName\",\n    left,\n    right,\n  });\n}\nexport { tsQualifiedName as tSQualifiedName };\nexport function tsCallSignatureDeclaration(\n  typeParameters: t.TSTypeParameterDeclaration | null | undefined = null,\n  parameters: Array<t.Identifier | t.RestElement>,\n  typeAnnotation: t.TSTypeAnnotation | null = null,\n): t.TSCallSignatureDeclaration {\n  return validateNode<t.TSCallSignatureDeclaration>({\n    type: \"TSCallSignatureDeclaration\",\n    typeParameters,\n    parameters,\n    typeAnnotation,\n  });\n}\nexport { tsCallSignatureDeclaration as tSCallSignatureDeclaration };\nexport function tsConstructSignatureDeclaration(\n  typeParameters: t.TSTypeParameterDeclaration | null | undefined = null,\n  parameters: Array<t.Identifier | t.RestElement>,\n  typeAnnotation: t.TSTypeAnnotation | null = null,\n): t.TSConstructSignatureDeclaration {\n  return validateNode<t.TSConstructSignatureDeclaration>({\n    type: \"TSConstructSignatureDeclaration\",\n    typeParameters,\n    parameters,\n    typeAnnotation,\n  });\n}\nexport { tsConstructSignatureDeclaration as tSConstructSignatureDeclaration };\nexport function tsPropertySignature(\n  key: t.Expression,\n  typeAnnotation: t.TSTypeAnnotation | null = null,\n  initializer: t.Expression | null = null,\n): t.TSPropertySignature {\n  return validateNode<t.TSPropertySignature>({\n    type: \"TSPropertySignature\",\n    key,\n    typeAnnotation,\n    initializer,\n    kind: null,\n  });\n}\nexport { tsPropertySignature as tSPropertySignature };\nexport function tsMethodSignature(\n  key: t.Expression,\n  typeParameters: t.TSTypeParameterDeclaration | null | undefined = null,\n  parameters: Array<t.Identifier | t.RestElement>,\n  typeAnnotation: t.TSTypeAnnotation | null = null,\n): t.TSMethodSignature {\n  return validateNode<t.TSMethodSignature>({\n    type: \"TSMethodSignature\",\n    key,\n    typeParameters,\n    parameters,\n    typeAnnotation,\n    kind: null,\n  });\n}\nexport { tsMethodSignature as tSMethodSignature };\nexport function tsIndexSignature(\n  parameters: Array<t.Identifier>,\n  typeAnnotation: t.TSTypeAnnotation | null = null,\n): t.TSIndexSignature {\n  return validateNode<t.TSIndexSignature>({\n    type: \"TSIndexSignature\",\n    parameters,\n    typeAnnotation,\n  });\n}\nexport { tsIndexSignature as tSIndexSignature };\nexport function tsAnyKeyword(): t.TSAnyKeyword {\n  return {\n    type: \"TSAnyKeyword\",\n  };\n}\nexport { tsAnyKeyword as tSAnyKeyword };\nexport function tsBooleanKeyword(): t.TSBooleanKeyword {\n  return {\n    type: \"TSBooleanKeyword\",\n  };\n}\nexport { tsBooleanKeyword as tSBooleanKeyword };\nexport function tsBigIntKeyword(): t.TSBigIntKeyword {\n  return {\n    type: \"TSBigIntKeyword\",\n  };\n}\nexport { tsBigIntKeyword as tSBigIntKeyword };\nexport function tsIntrinsicKeyword(): t.TSIntrinsicKeyword {\n  return {\n    type: \"TSIntrinsicKeyword\",\n  };\n}\nexport { tsIntrinsicKeyword as tSIntrinsicKeyword };\nexport function tsNeverKeyword(): t.TSNeverKeyword {\n  return {\n    type: \"TSNeverKeyword\",\n  };\n}\nexport { tsNeverKeyword as tSNeverKeyword };\nexport function tsNullKeyword(): t.TSNullKeyword {\n  return {\n    type: \"TSNullKeyword\",\n  };\n}\nexport { tsNullKeyword as tSNullKeyword };\nexport function tsNumberKeyword(): t.TSNumberKeyword {\n  return {\n    type: \"TSNumberKeyword\",\n  };\n}\nexport { tsNumberKeyword as tSNumberKeyword };\nexport function tsObjectKeyword(): t.TSObjectKeyword {\n  return {\n    type: \"TSObjectKeyword\",\n  };\n}\nexport { tsObjectKeyword as tSObjectKeyword };\nexport function tsStringKeyword(): t.TSStringKeyword {\n  return {\n    type: \"TSStringKeyword\",\n  };\n}\nexport { tsStringKeyword as tSStringKeyword };\nexport function tsSymbolKeyword(): t.TSSymbolKeyword {\n  return {\n    type: \"TSSymbolKeyword\",\n  };\n}\nexport { tsSymbolKeyword as tSSymbolKeyword };\nexport function tsUndefinedKeyword(): t.TSUndefinedKeyword {\n  return {\n    type: \"TSUndefinedKeyword\",\n  };\n}\nexport { tsUndefinedKeyword as tSUndefinedKeyword };\nexport function tsUnknownKeyword(): t.TSUnknownKeyword {\n  return {\n    type: \"TSUnknownKeyword\",\n  };\n}\nexport { tsUnknownKeyword as tSUnknownKeyword };\nexport function tsVoidKeyword(): t.TSVoidKeyword {\n  return {\n    type: \"TSVoidKeyword\",\n  };\n}\nexport { tsVoidKeyword as tSVoidKeyword };\nexport function tsThisType(): t.TSThisType {\n  return {\n    type: \"TSThisType\",\n  };\n}\nexport { tsThisType as tSThisType };\nexport function tsFunctionType(\n  typeParameters: t.TSTypeParameterDeclaration | null | undefined = null,\n  parameters: Array<t.Identifier | t.RestElement>,\n  typeAnnotation: t.TSTypeAnnotation | null = null,\n): t.TSFunctionType {\n  return validateNode<t.TSFunctionType>({\n    type: \"TSFunctionType\",\n    typeParameters,\n    parameters,\n    typeAnnotation,\n  });\n}\nexport { tsFunctionType as tSFunctionType };\nexport function tsConstructorType(\n  typeParameters: t.TSTypeParameterDeclaration | null | undefined = null,\n  parameters: Array<t.Identifier | t.RestElement>,\n  typeAnnotation: t.TSTypeAnnotation | null = null,\n): t.TSConstructorType {\n  return validateNode<t.TSConstructorType>({\n    type: \"TSConstructorType\",\n    typeParameters,\n    parameters,\n    typeAnnotation,\n  });\n}\nexport { tsConstructorType as tSConstructorType };\nexport function tsTypeReference(\n  typeName: t.TSEntityName,\n  typeParameters: t.TSTypeParameterInstantiation | null = null,\n): t.TSTypeReference {\n  return validateNode<t.TSTypeReference>({\n    type: \"TSTypeReference\",\n    typeName,\n    typeParameters,\n  });\n}\nexport { tsTypeReference as tSTypeReference };\nexport function tsTypePredicate(\n  parameterName: t.Identifier | t.TSThisType,\n  typeAnnotation: t.TSTypeAnnotation | null = null,\n  asserts: boolean | null = null,\n): t.TSTypePredicate {\n  return validateNode<t.TSTypePredicate>({\n    type: \"TSTypePredicate\",\n    parameterName,\n    typeAnnotation,\n    asserts,\n  });\n}\nexport { tsTypePredicate as tSTypePredicate };\nexport function tsTypeQuery(\n  exprName: t.TSEntityName | t.TSImportType,\n  typeParameters: t.TSTypeParameterInstantiation | null = null,\n): t.TSTypeQuery {\n  return validateNode<t.TSTypeQuery>({\n    type: \"TSTypeQuery\",\n    exprName,\n    typeParameters,\n  });\n}\nexport { tsTypeQuery as tSTypeQuery };\nexport function tsTypeLiteral(\n  members: Array<t.TSTypeElement>,\n): t.TSTypeLiteral {\n  return validateNode<t.TSTypeLiteral>({\n    type: \"TSTypeLiteral\",\n    members,\n  });\n}\nexport { tsTypeLiteral as tSTypeLiteral };\nexport function tsArrayType(elementType: t.TSType): t.TSArrayType {\n  return validateNode<t.TSArrayType>({\n    type: \"TSArrayType\",\n    elementType,\n  });\n}\nexport { tsArrayType as tSArrayType };\nexport function tsTupleType(\n  elementTypes: Array<t.TSType | t.TSNamedTupleMember>,\n): t.TSTupleType {\n  return validateNode<t.TSTupleType>({\n    type: \"TSTupleType\",\n    elementTypes,\n  });\n}\nexport { tsTupleType as tSTupleType };\nexport function tsOptionalType(typeAnnotation: t.TSType): t.TSOptionalType {\n  return validateNode<t.TSOptionalType>({\n    type: \"TSOptionalType\",\n    typeAnnotation,\n  });\n}\nexport { tsOptionalType as tSOptionalType };\nexport function tsRestType(typeAnnotation: t.TSType): t.TSRestType {\n  return validateNode<t.TSRestType>({\n    type: \"TSRestType\",\n    typeAnnotation,\n  });\n}\nexport { tsRestType as tSRestType };\nexport function tsNamedTupleMember(\n  label: t.Identifier,\n  elementType: t.TSType,\n  optional: boolean = false,\n): t.TSNamedTupleMember {\n  return validateNode<t.TSNamedTupleMember>({\n    type: \"TSNamedTupleMember\",\n    label,\n    elementType,\n    optional,\n  });\n}\nexport { tsNamedTupleMember as tSNamedTupleMember };\nexport function tsUnionType(types: Array<t.TSType>): t.TSUnionType {\n  return validateNode<t.TSUnionType>({\n    type: \"TSUnionType\",\n    types,\n  });\n}\nexport { tsUnionType as tSUnionType };\nexport function tsIntersectionType(\n  types: Array<t.TSType>,\n): t.TSIntersectionType {\n  return validateNode<t.TSIntersectionType>({\n    type: \"TSIntersectionType\",\n    types,\n  });\n}\nexport { tsIntersectionType as tSIntersectionType };\nexport function tsConditionalType(\n  checkType: t.TSType,\n  extendsType: t.TSType,\n  trueType: t.TSType,\n  falseType: t.TSType,\n): t.TSConditionalType {\n  return validateNode<t.TSConditionalType>({\n    type: \"TSConditionalType\",\n    checkType,\n    extendsType,\n    trueType,\n    falseType,\n  });\n}\nexport { tsConditionalType as tSConditionalType };\nexport function tsInferType(typeParameter: t.TSTypeParameter): t.TSInferType {\n  return validateNode<t.TSInferType>({\n    type: \"TSInferType\",\n    typeParameter,\n  });\n}\nexport { tsInferType as tSInferType };\nexport function tsParenthesizedType(\n  typeAnnotation: t.TSType,\n): t.TSParenthesizedType {\n  return validateNode<t.TSParenthesizedType>({\n    type: \"TSParenthesizedType\",\n    typeAnnotation,\n  });\n}\nexport { tsParenthesizedType as tSParenthesizedType };\nexport function tsTypeOperator(typeAnnotation: t.TSType): t.TSTypeOperator {\n  return validateNode<t.TSTypeOperator>({\n    type: \"TSTypeOperator\",\n    typeAnnotation,\n    operator: null,\n  });\n}\nexport { tsTypeOperator as tSTypeOperator };\nexport function tsIndexedAccessType(\n  objectType: t.TSType,\n  indexType: t.TSType,\n): t.TSIndexedAccessType {\n  return validateNode<t.TSIndexedAccessType>({\n    type: \"TSIndexedAccessType\",\n    objectType,\n    indexType,\n  });\n}\nexport { tsIndexedAccessType as tSIndexedAccessType };\nexport function tsMappedType(\n  typeParameter: t.TSTypeParameter,\n  typeAnnotation: t.TSType | null = null,\n  nameType: t.TSType | null = null,\n): t.TSMappedType {\n  return validateNode<t.TSMappedType>({\n    type: \"TSMappedType\",\n    typeParameter,\n    typeAnnotation,\n    nameType,\n  });\n}\nexport { tsMappedType as tSMappedType };\nexport function tsLiteralType(\n  literal:\n    | t.NumericLiteral\n    | t.StringLiteral\n    | t.BooleanLiteral\n    | t.BigIntLiteral\n    | t.TemplateLiteral\n    | t.UnaryExpression,\n): t.TSLiteralType {\n  return validateNode<t.TSLiteralType>({\n    type: \"TSLiteralType\",\n    literal,\n  });\n}\nexport { tsLiteralType as tSLiteralType };\nexport function tsExpressionWithTypeArguments(\n  expression: t.TSEntityName,\n  typeParameters: t.TSTypeParameterInstantiation | null = null,\n): t.TSExpressionWithTypeArguments {\n  return validateNode<t.TSExpressionWithTypeArguments>({\n    type: \"TSExpressionWithTypeArguments\",\n    expression,\n    typeParameters,\n  });\n}\nexport { tsExpressionWithTypeArguments as tSExpressionWithTypeArguments };\nexport function tsInterfaceDeclaration(\n  id: t.Identifier,\n  typeParameters: t.TSTypeParameterDeclaration | null | undefined = null,\n  _extends: Array<t.TSExpressionWithTypeArguments> | null | undefined = null,\n  body: t.TSInterfaceBody,\n): t.TSInterfaceDeclaration {\n  return validateNode<t.TSInterfaceDeclaration>({\n    type: \"TSInterfaceDeclaration\",\n    id,\n    typeParameters,\n    extends: _extends,\n    body,\n  });\n}\nexport { tsInterfaceDeclaration as tSInterfaceDeclaration };\nexport function tsInterfaceBody(\n  body: Array<t.TSTypeElement>,\n): t.TSInterfaceBody {\n  return validateNode<t.TSInterfaceBody>({\n    type: \"TSInterfaceBody\",\n    body,\n  });\n}\nexport { tsInterfaceBody as tSInterfaceBody };\nexport function tsTypeAliasDeclaration(\n  id: t.Identifier,\n  typeParameters: t.TSTypeParameterDeclaration | null | undefined = null,\n  typeAnnotation: t.TSType,\n): t.TSTypeAliasDeclaration {\n  return validateNode<t.TSTypeAliasDeclaration>({\n    type: \"TSTypeAliasDeclaration\",\n    id,\n    typeParameters,\n    typeAnnotation,\n  });\n}\nexport { tsTypeAliasDeclaration as tSTypeAliasDeclaration };\nexport function tsInstantiationExpression(\n  expression: t.Expression,\n  typeParameters: t.TSTypeParameterInstantiation | null = null,\n): t.TSInstantiationExpression {\n  return validateNode<t.TSInstantiationExpression>({\n    type: \"TSInstantiationExpression\",\n    expression,\n    typeParameters,\n  });\n}\nexport { tsInstantiationExpression as tSInstantiationExpression };\nexport function tsAsExpression(\n  expression: t.Expression,\n  typeAnnotation: t.TSType,\n): t.TSAsExpression {\n  return validateNode<t.TSAsExpression>({\n    type: \"TSAsExpression\",\n    expression,\n    typeAnnotation,\n  });\n}\nexport { tsAsExpression as tSAsExpression };\nexport function tsSatisfiesExpression(\n  expression: t.Expression,\n  typeAnnotation: t.TSType,\n): t.TSSatisfiesExpression {\n  return validateNode<t.TSSatisfiesExpression>({\n    type: \"TSSatisfiesExpression\",\n    expression,\n    typeAnnotation,\n  });\n}\nexport { tsSatisfiesExpression as tSSatisfiesExpression };\nexport function tsTypeAssertion(\n  typeAnnotation: t.TSType,\n  expression: t.Expression,\n): t.TSTypeAssertion {\n  return validateNode<t.TSTypeAssertion>({\n    type: \"TSTypeAssertion\",\n    typeAnnotation,\n    expression,\n  });\n}\nexport { tsTypeAssertion as tSTypeAssertion };\nexport function tsEnumDeclaration(\n  id: t.Identifier,\n  members: Array<t.TSEnumMember>,\n): t.TSEnumDeclaration {\n  return validateNode<t.TSEnumDeclaration>({\n    type: \"TSEnumDeclaration\",\n    id,\n    members,\n  });\n}\nexport { tsEnumDeclaration as tSEnumDeclaration };\nexport function tsEnumMember(\n  id: t.Identifier | t.StringLiteral,\n  initializer: t.Expression | null = null,\n): t.TSEnumMember {\n  return validateNode<t.TSEnumMember>({\n    type: \"TSEnumMember\",\n    id,\n    initializer,\n  });\n}\nexport { tsEnumMember as tSEnumMember };\nexport function tsModuleDeclaration(\n  id: t.Identifier | t.StringLiteral,\n  body: t.TSModuleBlock | t.TSModuleDeclaration,\n): t.TSModuleDeclaration {\n  return validateNode<t.TSModuleDeclaration>({\n    type: \"TSModuleDeclaration\",\n    id,\n    body,\n  });\n}\nexport { tsModuleDeclaration as tSModuleDeclaration };\nexport function tsModuleBlock(body: Array<t.Statement>): t.TSModuleBlock {\n  return validateNode<t.TSModuleBlock>({\n    type: \"TSModuleBlock\",\n    body,\n  });\n}\nexport { tsModuleBlock as tSModuleBlock };\nexport function tsImportType(\n  argument: t.StringLiteral,\n  qualifier: t.TSEntityName | null = null,\n  typeParameters: t.TSTypeParameterInstantiation | null = null,\n): t.TSImportType {\n  return validateNode<t.TSImportType>({\n    type: \"TSImportType\",\n    argument,\n    qualifier,\n    typeParameters,\n  });\n}\nexport { tsImportType as tSImportType };\nexport function tsImportEqualsDeclaration(\n  id: t.Identifier,\n  moduleReference: t.TSEntityName | t.TSExternalModuleReference,\n): t.TSImportEqualsDeclaration {\n  return validateNode<t.TSImportEqualsDeclaration>({\n    type: \"TSImportEqualsDeclaration\",\n    id,\n    moduleReference,\n    isExport: null,\n  });\n}\nexport { tsImportEqualsDeclaration as tSImportEqualsDeclaration };\nexport function tsExternalModuleReference(\n  expression: t.StringLiteral,\n): t.TSExternalModuleReference {\n  return validateNode<t.TSExternalModuleReference>({\n    type: \"TSExternalModuleReference\",\n    expression,\n  });\n}\nexport { tsExternalModuleReference as tSExternalModuleReference };\nexport function tsNonNullExpression(\n  expression: t.Expression,\n): t.TSNonNullExpression {\n  return validateNode<t.TSNonNullExpression>({\n    type: \"TSNonNullExpression\",\n    expression,\n  });\n}\nexport { tsNonNullExpression as tSNonNullExpression };\nexport function tsExportAssignment(\n  expression: t.Expression,\n): t.TSExportAssignment {\n  return validateNode<t.TSExportAssignment>({\n    type: \"TSExportAssignment\",\n    expression,\n  });\n}\nexport { tsExportAssignment as tSExportAssignment };\nexport function tsNamespaceExportDeclaration(\n  id: t.Identifier,\n): t.TSNamespaceExportDeclaration {\n  return validateNode<t.TSNamespaceExportDeclaration>({\n    type: \"TSNamespaceExportDeclaration\",\n    id,\n  });\n}\nexport { tsNamespaceExportDeclaration as tSNamespaceExportDeclaration };\nexport function tsTypeAnnotation(typeAnnotation: t.TSType): t.TSTypeAnnotation {\n  return validateNode<t.TSTypeAnnotation>({\n    type: \"TSTypeAnnotation\",\n    typeAnnotation,\n  });\n}\nexport { tsTypeAnnotation as tSTypeAnnotation };\nexport function tsTypeParameterInstantiation(\n  params: Array<t.TSType>,\n): t.TSTypeParameterInstantiation {\n  return validateNode<t.TSTypeParameterInstantiation>({\n    type: \"TSTypeParameterInstantiation\",\n    params,\n  });\n}\nexport { tsTypeParameterInstantiation as tSTypeParameterInstantiation };\nexport function tsTypeParameterDeclaration(\n  params: Array<t.TSTypeParameter>,\n): t.TSTypeParameterDeclaration {\n  return validateNode<t.TSTypeParameterDeclaration>({\n    type: \"TSTypeParameterDeclaration\",\n    params,\n  });\n}\nexport { tsTypeParameterDeclaration as tSTypeParameterDeclaration };\nexport function tsTypeParameter(\n  constraint: t.TSType | null | undefined = null,\n  _default: t.TSType | null | undefined = null,\n  name: string,\n): t.TSTypeParameter {\n  return validateNode<t.TSTypeParameter>({\n    type: \"TSTypeParameter\",\n    constraint,\n    default: _default,\n    name,\n  });\n}\nexport { tsTypeParameter as tSTypeParameter };\n/** @deprecated */\nfunction NumberLiteral(value: number) {\n  console.trace(\n    \"The node type NumberLiteral has been renamed to NumericLiteral\",\n  );\n  return numericLiteral(value);\n}\nexport { NumberLiteral as numberLiteral };\n/** @deprecated */\nfunction RegexLiteral(pattern: string, flags: string = \"\") {\n  console.trace(\"The node type RegexLiteral has been renamed to RegExpLiteral\");\n  return regExpLiteral(pattern, flags);\n}\nexport { RegexLiteral as regexLiteral };\n/** @deprecated */\nfunction RestProperty(argument: t.LVal) {\n  console.trace(\"The node type RestProperty has been renamed to RestElement\");\n  return restElement(argument);\n}\nexport { RestProperty as restProperty };\n/** @deprecated */\nfunction SpreadProperty(argument: t.Expression) {\n  console.trace(\n    \"The node type SpreadProperty has been renamed to SpreadElement\",\n  );\n  return spreadElement(argument);\n}\nexport { SpreadProperty as spreadProperty };\n","var unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) {\n  var it;\n\n  if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) {\n    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n\n      var F = function F() {};\n\n      return {\n        s: F,\n        n: function n() {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function e(_e) {\n          throw _e;\n        },\n        f: F\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  var normalCompletion = true,\n      didErr = false,\n      err;\n  return {\n    s: function s() {\n      it = o[Symbol.iterator]();\n    },\n    n: function n() {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function e(_e2) {\n      didErr = true;\n      err = _e2;\n    },\n    f: function f() {\n      try {\n        if (!normalCompletion && it[\"return\"] != null) it[\"return\"]();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}\n\nmodule.exports = _createForOfIteratorHelper;","import toFastProperties from \"to-fast-properties\";\nimport \"./core\";\nimport \"./flow\";\nimport \"./jsx\";\nimport \"./misc\";\nimport \"./experimental\";\nimport \"./typescript\";\nimport {\n  VISITOR_KEYS,\n  ALIAS_KEYS,\n  FLIPPED_ALIAS_KEYS,\n  NODE_FIELDS,\n  BUILDER_KEYS,\n  DEPRECATED_KEYS,\n  NODE_PARENT_VALIDATIONS,\n} from \"./utils\";\nimport {\n  PLACEHOLDERS,\n  PLACEHOLDERS_ALIAS,\n  PLACEHOLDERS_FLIPPED_ALIAS,\n} from \"./placeholders\";\n\n// We do this here, because at this point the visitor keys should be ready and setup\ntoFastProperties(VISITOR_KEYS);\ntoFastProperties(ALIAS_KEYS);\ntoFastProperties(FLIPPED_ALIAS_KEYS);\ntoFastProperties(NODE_FIELDS);\ntoFastProperties(BUILDER_KEYS);\ntoFastProperties(DEPRECATED_KEYS);\n\ntoFastProperties(PLACEHOLDERS_ALIAS);\ntoFastProperties(PLACEHOLDERS_FLIPPED_ALIAS);\n\nconst TYPES: Array<string> = [].concat(\n  Object.keys(VISITOR_KEYS),\n  Object.keys(FLIPPED_ALIAS_KEYS),\n  Object.keys(DEPRECATED_KEYS),\n);\n\nexport {\n  VISITOR_KEYS,\n  ALIAS_KEYS,\n  FLIPPED_ALIAS_KEYS,\n  NODE_FIELDS,\n  BUILDER_KEYS,\n  DEPRECATED_KEYS,\n  NODE_PARENT_VALIDATIONS,\n  PLACEHOLDERS,\n  PLACEHOLDERS_ALIAS,\n  PLACEHOLDERS_FLIPPED_ALIAS,\n  TYPES,\n};\n\nexport type { FieldOptions } from \"./utils\";\n","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","import is from \"../validators/is\";\nimport { validateField, validateChild } from \"../validators/validate\";\nimport type * as t from \"..\";\n\nexport const VISITOR_KEYS: Record<string, string[]> = {};\nexport const ALIAS_KEYS: Partial<Record<NodeTypesWithoutComment, string[]>> =\n  {};\nexport const FLIPPED_ALIAS_KEYS: Record<string, NodeTypesWithoutComment[]> = {};\nexport const NODE_FIELDS: Record<string, FieldDefinitions> = {};\nexport const BUILDER_KEYS: Record<string, string[]> = {};\nexport const DEPRECATED_KEYS: Record<string, NodeTypesWithoutComment> = {};\nexport const NODE_PARENT_VALIDATIONS: Record<string, Validator> = {};\n\nfunction getType(val: any) {\n  if (Array.isArray(val)) {\n    return \"array\";\n  } else if (val === null) {\n    return \"null\";\n  } else {\n    return typeof val;\n  }\n}\n\ntype NodeTypesWithoutComment = t.Node[\"type\"] | keyof t.Aliases;\n\ntype NodeTypes = NodeTypesWithoutComment | t.Comment[\"type\"];\n\ntype PrimitiveTypes = ReturnType<typeof getType>;\n\ntype FieldDefinitions = {\n  [x: string]: FieldOptions;\n};\n\ntype DefineTypeOpts = {\n  fields?: FieldDefinitions;\n  visitor?: Array<string>;\n  aliases?: Array<string>;\n  builder?: Array<string>;\n  inherits?: NodeTypes;\n  deprecatedAlias?: string;\n  validate?: Validator;\n};\n\nexport type Validator = (\n  | { type: PrimitiveTypes }\n  | { each: Validator }\n  | { chainOf: Validator[] }\n  | { oneOf: any[] }\n  | { oneOfNodeTypes: NodeTypes[] }\n  | { oneOfNodeOrValueTypes: (NodeTypes | PrimitiveTypes)[] }\n  | { shapeOf: { [x: string]: FieldOptions } }\n  | {}\n) &\n  ((node: t.Node, key: string, val: any) => void);\n\nexport type FieldOptions = {\n  default?: string | number | boolean | [];\n  optional?: boolean;\n  validate?: Validator;\n};\n\nexport function validate(validate: Validator): FieldOptions {\n  return { validate };\n}\n\nexport function typeIs(typeName: NodeTypes | NodeTypes[]) {\n  return typeof typeName === \"string\"\n    ? assertNodeType(typeName)\n    : assertNodeType(...typeName);\n}\n\nexport function validateType(typeName: NodeTypes | NodeTypes[]) {\n  return validate(typeIs(typeName));\n}\n\nexport function validateOptional(validate: Validator): FieldOptions {\n  return { validate, optional: true };\n}\n\nexport function validateOptionalType(\n  typeName: NodeTypes | NodeTypes[],\n): FieldOptions {\n  return { validate: typeIs(typeName), optional: true };\n}\n\nexport function arrayOf(elementType: Validator): Validator {\n  return chain(assertValueType(\"array\"), assertEach(elementType));\n}\n\nexport function arrayOfType(typeName: NodeTypes | NodeTypes[]) {\n  return arrayOf(typeIs(typeName));\n}\n\nexport function validateArrayOfType(typeName: NodeTypes | NodeTypes[]) {\n  return validate(arrayOfType(typeName));\n}\n\nexport function assertEach(callback: Validator): Validator {\n  function validator(node: t.Node, key: string, val: any) {\n    if (!Array.isArray(val)) return;\n\n    for (let i = 0; i < val.length; i++) {\n      const subkey = `${key}[${i}]`;\n      const v = val[i];\n      callback(node, subkey, v);\n      if (process.env.BABEL_TYPES_8_BREAKING) validateChild(node, subkey, v);\n    }\n  }\n  validator.each = callback;\n  return validator;\n}\n\nexport function assertOneOf(...values: Array<any>): Validator {\n  function validate(node: any, key: string, val: any) {\n    if (values.indexOf(val) < 0) {\n      throw new TypeError(\n        `Property ${key} expected value to be one of ${JSON.stringify(\n          values,\n        )} but got ${JSON.stringify(val)}`,\n      );\n    }\n  }\n\n  validate.oneOf = values;\n\n  return validate;\n}\n\nexport function assertNodeType(...types: NodeTypes[]): Validator {\n  function validate(node: t.Node, key: string, val: any) {\n    for (const type of types) {\n      if (is(type, val)) {\n        validateChild(node, key, val);\n        return;\n      }\n    }\n\n    throw new TypeError(\n      `Property ${key} of ${\n        node.type\n      } expected node to be of a type ${JSON.stringify(\n        types,\n      )} but instead got ${JSON.stringify(val?.type)}`,\n    );\n  }\n\n  validate.oneOfNodeTypes = types;\n\n  return validate;\n}\n\nexport function assertNodeOrValueType(\n  ...types: (NodeTypes | PrimitiveTypes)[]\n): Validator {\n  function validate(node: t.Node, key: string, val: any) {\n    for (const type of types) {\n      if (getType(val) === type || is(type, val)) {\n        validateChild(node, key, val);\n        return;\n      }\n    }\n\n    throw new TypeError(\n      `Property ${key} of ${\n        node.type\n      } expected node to be of a type ${JSON.stringify(\n        types,\n      )} but instead got ${JSON.stringify(val?.type)}`,\n    );\n  }\n\n  validate.oneOfNodeOrValueTypes = types;\n\n  return validate;\n}\n\nexport function assertValueType(type: PrimitiveTypes): Validator {\n  function validate(node: t.Node, key: string, val: any) {\n    const valid = getType(val) === type;\n\n    if (!valid) {\n      throw new TypeError(\n        `Property ${key} expected type of ${type} but got ${getType(val)}`,\n      );\n    }\n  }\n\n  validate.type = type;\n\n  return validate;\n}\n\nexport function assertShape(shape: { [x: string]: FieldOptions }): Validator {\n  function validate(node: t.Node, key: string, val: any) {\n    const errors = [];\n    for (const property of Object.keys(shape)) {\n      try {\n        validateField(node, property, val[property], shape[property]);\n      } catch (error) {\n        if (error instanceof TypeError) {\n          errors.push(error.message);\n          continue;\n        }\n        throw error;\n      }\n    }\n    if (errors.length) {\n      throw new TypeError(\n        `Property ${key} of ${\n          node.type\n        } expected to have the following:\\n${errors.join(\"\\n\")}`,\n      );\n    }\n  }\n\n  validate.shapeOf = shape;\n\n  return validate;\n}\n\nexport function assertOptionalChainStart(): Validator {\n  function validate(node: t.Node) {\n    let current = node;\n    while (node) {\n      const { type } = current;\n      if (type === \"OptionalCallExpression\") {\n        if (current.optional) return;\n        current = current.callee;\n        continue;\n      }\n\n      if (type === \"OptionalMemberExpression\") {\n        if (current.optional) return;\n        current = current.object;\n        continue;\n      }\n\n      break;\n    }\n\n    throw new TypeError(\n      `Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${current?.type}`,\n    );\n  }\n\n  return validate;\n}\n\nexport function chain(...fns: Array<Validator>): Validator {\n  function validate(...args: Parameters<Validator>) {\n    for (const fn of fns) {\n      fn(...args);\n    }\n  }\n  validate.chainOf = fns;\n\n  if (\n    fns.length >= 2 &&\n    \"type\" in fns[0] &&\n    fns[0].type === \"array\" &&\n    !(\"each\" in fns[1])\n  ) {\n    throw new Error(\n      `An assertValueType(\"array\") validator can only be followed by an assertEach(...) validator.`,\n    );\n  }\n\n  return validate;\n}\n\nconst validTypeOpts = [\n  \"aliases\",\n  \"builder\",\n  \"deprecatedAlias\",\n  \"fields\",\n  \"inherits\",\n  \"visitor\",\n  \"validate\",\n];\nconst validFieldKeys = [\"default\", \"optional\", \"validate\"];\n\nconst store = {} as Record<string, DefineTypeOpts>;\n\n// Wraps defineType to ensure these aliases are included.\nexport function defineAliasedType(...aliases: string[]) {\n  return (type: string, opts: DefineTypeOpts = {}) => {\n    let defined = opts.aliases;\n    if (!defined) {\n      if (opts.inherits) defined = store[opts.inherits].aliases?.slice();\n      defined ??= [];\n      opts.aliases = defined;\n    }\n    const additional = aliases.filter(a => !defined.includes(a));\n    defined.unshift(...additional);\n    return defineType(type, opts);\n  };\n}\n\nexport default function defineType(type: string, opts: DefineTypeOpts = {}) {\n  const inherits = (opts.inherits && store[opts.inherits]) || {};\n\n  let fields = opts.fields;\n  if (!fields) {\n    fields = {};\n    if (inherits.fields) {\n      const keys = Object.getOwnPropertyNames(inherits.fields);\n      for (const key of keys) {\n        const field = inherits.fields[key];\n        const def = field.default;\n        if (\n          Array.isArray(def) ? def.length > 0 : def && typeof def === \"object\"\n        ) {\n          throw new Error(\n            \"field defaults can only be primitives or empty arrays currently\",\n          );\n        }\n        fields[key] = {\n          default: Array.isArray(def) ? [] : def,\n          optional: field.optional,\n          validate: field.validate,\n        };\n      }\n    }\n  }\n\n  const visitor: Array<string> = opts.visitor || inherits.visitor || [];\n  const aliases: Array<string> = opts.aliases || inherits.aliases || [];\n  const builder: Array<string> =\n    opts.builder || inherits.builder || opts.visitor || [];\n\n  for (const k of Object.keys(opts)) {\n    if (validTypeOpts.indexOf(k) === -1) {\n      throw new Error(`Unknown type option \"${k}\" on ${type}`);\n    }\n  }\n\n  if (opts.deprecatedAlias) {\n    DEPRECATED_KEYS[opts.deprecatedAlias] = type as NodeTypesWithoutComment;\n  }\n\n  // ensure all field keys are represented in `fields`\n  for (const key of visitor.concat(builder)) {\n    fields[key] = fields[key] || {};\n  }\n\n  for (const key of Object.keys(fields)) {\n    const field = fields[key];\n\n    if (field.default !== undefined && builder.indexOf(key) === -1) {\n      field.optional = true;\n    }\n    if (field.default === undefined) {\n      field.default = null;\n    } else if (!field.validate && field.default != null) {\n      field.validate = assertValueType(getType(field.default));\n    }\n\n    for (const k of Object.keys(field)) {\n      if (validFieldKeys.indexOf(k) === -1) {\n        throw new Error(`Unknown field key \"${k}\" on ${type}.${key}`);\n      }\n    }\n  }\n\n  VISITOR_KEYS[type] = opts.visitor = visitor;\n  BUILDER_KEYS[type] = opts.builder = builder;\n  NODE_FIELDS[type] = opts.fields = fields;\n  ALIAS_KEYS[type as NodeTypesWithoutComment] = opts.aliases = aliases;\n  aliases.forEach(alias => {\n    FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];\n    FLIPPED_ALIAS_KEYS[alias].push(type as NodeTypesWithoutComment);\n  });\n\n  if (opts.validate) {\n    NODE_PARENT_VALIDATIONS[type] = opts.validate;\n  }\n\n  store[type] = opts;\n}\n","export const STATEMENT_OR_BLOCK_KEYS = [\"consequent\", \"body\", \"alternate\"];\nexport const FLATTENABLE_KEYS = [\"body\", \"expressions\"];\nexport const FOR_INIT_KEYS = [\"left\", \"init\"];\nexport const COMMENT_KEYS = [\n  \"leadingComments\",\n  \"trailingComments\",\n  \"innerComments\",\n] as const;\n\nexport const LOGICAL_OPERATORS = [\"||\", \"&&\", \"??\"];\nexport const UPDATE_OPERATORS = [\"++\", \"--\"];\n\nexport const BOOLEAN_NUMBER_BINARY_OPERATORS = [\">\", \"<\", \">=\", \"<=\"];\nexport const EQUALITY_BINARY_OPERATORS = [\"==\", \"===\", \"!=\", \"!==\"];\nexport const COMPARISON_BINARY_OPERATORS = [\n  ...EQUALITY_BINARY_OPERATORS,\n  \"in\",\n  \"instanceof\",\n];\nexport const BOOLEAN_BINARY_OPERATORS = [\n  ...COMPARISON_BINARY_OPERATORS,\n  ...BOOLEAN_NUMBER_BINARY_OPERATORS,\n];\nexport const NUMBER_BINARY_OPERATORS = [\n  \"-\",\n  \"/\",\n  \"%\",\n  \"*\",\n  \"**\",\n  \"&\",\n  \"|\",\n  \">>\",\n  \">>>\",\n  \"<<\",\n  \"^\",\n];\nexport const BINARY_OPERATORS = [\n  \"+\",\n  ...NUMBER_BINARY_OPERATORS,\n  ...BOOLEAN_BINARY_OPERATORS,\n  \"|>\",\n];\n\nexport const ASSIGNMENT_OPERATORS = [\n  \"=\",\n  \"+=\",\n  ...NUMBER_BINARY_OPERATORS.map(op => op + \"=\"),\n  ...LOGICAL_OPERATORS.map(op => op + \"=\"),\n];\n\nexport const BOOLEAN_UNARY_OPERATORS = [\"delete\", \"!\"];\nexport const NUMBER_UNARY_OPERATORS = [\"+\", \"-\", \"~\"];\nexport const STRING_UNARY_OPERATORS = [\"typeof\"];\nexport const UNARY_OPERATORS = [\n  \"void\",\n  \"throw\",\n  ...BOOLEAN_UNARY_OPERATORS,\n  ...NUMBER_UNARY_OPERATORS,\n  ...STRING_UNARY_OPERATORS,\n];\n\nexport const INHERIT_KEYS = {\n  optional: [\"typeAnnotation\", \"typeParameters\", \"returnType\"],\n  force: [\"start\", \"loc\", \"end\"],\n} as const;\n\nexport const BLOCK_SCOPED_SYMBOL = Symbol.for(\"var used to be block scoped\");\nexport const NOT_LOCAL_BINDING = Symbol.for(\n  \"should not be considered a local binding\",\n);\n","import { NODE_FIELDS } from \"../definitions\";\nimport type * as t from \"..\";\nimport { isFile, isIdentifier } from \"../validators/generated\";\n\nconst has = Function.call.bind(Object.prototype.hasOwnProperty);\n\ntype CommentCache = Map<t.Comment, t.Comment>;\n\n// This function will never be called for comments, only for real nodes.\nfunction cloneIfNode(\n  obj: t.Node | undefined | null,\n  deep: boolean,\n  withoutLoc: boolean,\n  commentsCache: CommentCache,\n) {\n  if (obj && typeof obj.type === \"string\") {\n    return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);\n  }\n\n  return obj;\n}\n\nfunction cloneIfNodeOrArray(\n  obj: t.Node | undefined | null | (t.Node | undefined | null)[],\n  deep: boolean,\n  withoutLoc: boolean,\n  commentsCache: CommentCache,\n) {\n  if (Array.isArray(obj)) {\n    return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache));\n  }\n  return cloneIfNode(obj, deep, withoutLoc, commentsCache);\n}\n\n/**\n * Create a clone of a `node` including only properties belonging to the node.\n * If the second parameter is `false`, cloneNode performs a shallow clone.\n * If the third parameter is true, the cloned nodes exclude location properties.\n */\nexport default function cloneNode<T extends t.Node>(\n  node: T,\n  deep: boolean = true,\n  withoutLoc: boolean = false,\n): T {\n  return cloneNodeInternal(node, deep, withoutLoc, new Map());\n}\n\nfunction cloneNodeInternal<T extends t.Node>(\n  node: T,\n  deep: boolean = true,\n  withoutLoc: boolean = false,\n  commentsCache: CommentCache,\n): T {\n  if (!node) return node;\n\n  const { type } = node;\n  const newNode: any = { type: node.type };\n\n  // Special-case identifiers since they are the most cloned nodes.\n  if (isIdentifier(node)) {\n    newNode.name = node.name;\n\n    if (has(node, \"optional\") && typeof node.optional === \"boolean\") {\n      newNode.optional = node.optional;\n    }\n\n    if (has(node, \"typeAnnotation\")) {\n      newNode.typeAnnotation = deep\n        ? cloneIfNodeOrArray(\n            node.typeAnnotation,\n            true,\n            withoutLoc,\n            commentsCache,\n          )\n        : node.typeAnnotation;\n    }\n  } else if (!has(NODE_FIELDS, type)) {\n    throw new Error(`Unknown node type: \"${type}\"`);\n  } else {\n    for (const field of Object.keys(NODE_FIELDS[type])) {\n      if (has(node, field)) {\n        if (deep) {\n          newNode[field] =\n            isFile(node) && field === \"comments\"\n              ? maybeCloneComments(\n                  node.comments,\n                  deep,\n                  withoutLoc,\n                  commentsCache,\n                )\n              : cloneIfNodeOrArray(\n                  // @ts-expect-error node[field] has been guarded by has check\n                  node[field],\n                  true,\n                  withoutLoc,\n                  commentsCache,\n                );\n        } else {\n          newNode[field] =\n            // @ts-expect-error node[field] has been guarded by has check\n            node[field];\n        }\n      }\n    }\n  }\n\n  if (has(node, \"loc\")) {\n    if (withoutLoc) {\n      newNode.loc = null;\n    } else {\n      newNode.loc = node.loc;\n    }\n  }\n  if (has(node, \"leadingComments\")) {\n    newNode.leadingComments = maybeCloneComments(\n      node.leadingComments,\n      deep,\n      withoutLoc,\n      commentsCache,\n    );\n  }\n  if (has(node, \"innerComments\")) {\n    newNode.innerComments = maybeCloneComments(\n      node.innerComments,\n      deep,\n      withoutLoc,\n      commentsCache,\n    );\n  }\n  if (has(node, \"trailingComments\")) {\n    newNode.trailingComments = maybeCloneComments(\n      node.trailingComments,\n      deep,\n      withoutLoc,\n      commentsCache,\n    );\n  }\n  if (has(node, \"extra\")) {\n    newNode.extra = {\n      ...node.extra,\n    };\n  }\n\n  return newNode;\n}\n\nfunction maybeCloneComments<T extends t.Comment>(\n  comments: ReadonlyArray<T> | null,\n  deep: boolean,\n  withoutLoc: boolean,\n  commentsCache: Map<T, T>,\n): ReadonlyArray<T> | null {\n  if (!comments || !deep) {\n    return comments;\n  }\n  return comments.map(comment => {\n    const cache = commentsCache.get(comment);\n    if (cache) return cache;\n\n    const { type, value, loc } = comment;\n\n    const ret = { type, value, loc } as T;\n    if (withoutLoc) {\n      ret.loc = null;\n    }\n\n    commentsCache.set(comment, ret);\n\n    return ret;\n  });\n}\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","import shallowEqual from \"../utils/shallowEqual\";\nimport isType from \"./isType\";\nimport isPlaceholderType from \"./isPlaceholderType\";\nimport { FLIPPED_ALIAS_KEYS } from \"../definitions\";\nimport type * as t from \"..\";\n\nexport default function is<T extends t.Node[\"type\"]>(\n  type: T,\n  node: t.Node | null | undefined,\n  opts?: undefined,\n): node is Extract<t.Node, { type: T }>;\n\nexport default function is<\n  T extends t.Node[\"type\"],\n  P extends Extract<t.Node, { type: T }>,\n>(type: T, n: t.Node | null | undefined, required: Partial<P>): n is P;\n\nexport default function is<P extends t.Node>(\n  type: string,\n  node: t.Node | null | undefined,\n  opts: Partial<P>,\n): node is P;\n\nexport default function is(\n  type: string,\n  node: t.Node | null | undefined,\n  opts?: Partial<t.Node>,\n): node is t.Node;\n/**\n * Returns whether `node` is of given `type`.\n *\n * For better performance, use this instead of `is[Type]` when `type` is unknown.\n */\nexport default function is(\n  type: string,\n  node: t.Node | null | undefined,\n  opts?: Partial<t.Node>,\n): node is t.Node {\n  if (!node) return false;\n\n  const matches = isType(node.type, type);\n  if (!matches) {\n    if (!opts && node.type === \"Placeholder\" && type in FLIPPED_ALIAS_KEYS) {\n      // We can only return true if the placeholder doesn't replace a real node,\n      // but it replaces a category of nodes (an alias).\n      //\n      // t.is(\"Identifier\", node) gives some guarantees about node's shape, so we\n      // can't say that Placeholder(expectedNode: \"Identifier\") is an identifier\n      // because it doesn't have the same properties.\n      // On the other hand, t.is(\"Expression\", node) doesn't say anything about\n      // the shape of node because Expression can be many different nodes: we can,\n      // and should, safely report expression placeholders as Expressions.\n      return isPlaceholderType(node.expectedNode, type);\n    }\n    return false;\n  }\n\n  if (typeof opts === \"undefined\") {\n    return true;\n  } else {\n    return shallowEqual(node, opts);\n  }\n}\n","import {\n  isIdentifierName,\n  isStrictReservedWord,\n  isKeyword,\n} from \"@babel/helper-validator-identifier\";\n\n/**\n * Check if the input `name` is a valid identifier name\n * and isn't a reserved word.\n */\nexport default function isValidIdentifier(\n  name: string,\n  reserved: boolean = true,\n): boolean {\n  if (typeof name !== \"string\") return false;\n\n  if (reserved) {\n    // \"await\" is invalid in module, valid in script; better be safe (see #4952)\n    if (isKeyword(name) || isStrictReservedWord(name, true)) {\n      return false;\n    }\n  }\n\n  return isIdentifierName(name);\n}\n","import * 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 {\n    pos,\n    str: out,\n    firstInvalidLoc,\n    lineStart,\n    curLine,\n\n    // TODO(Babel 8): This is only needed for backwards compatibility,\n    // we can remove it.\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 = input.slice(startPos, pos + 2).match(/^[0-7]+/)!;\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","import {\n  isExportDeclaration,\n  isIdentifier,\n  isDeclaration,\n  isFunctionDeclaration,\n  isFunctionExpression,\n  isExportAllDeclaration,\n} from \"../validators/generated\";\nimport type * as t from \"..\";\n\nexport { getBindingIdentifiers as default };\n\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates: true,\n  outerOnly?: boolean,\n): Record<string, Array<t.Identifier>>;\n\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates?: false,\n  outerOnly?: boolean,\n): Record<string, t.Identifier>;\n\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates?: boolean,\n  outerOnly?: boolean,\n): Record<string, t.Identifier> | Record<string, Array<t.Identifier>>;\n\n/**\n * Return a list of binding identifiers associated with the input `node`.\n */\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates?: boolean,\n  outerOnly?: boolean,\n): Record<string, t.Identifier> | Record<string, Array<t.Identifier>> {\n  const search: t.Node[] = [].concat(node);\n  const ids = Object.create(null);\n\n  while (search.length) {\n    const id = search.shift();\n    if (!id) continue;\n\n    const keys =\n      // @ts-expect-error getBindingIdentifiers.keys do not cover all AST types\n      getBindingIdentifiers.keys[id.type];\n\n    if (isIdentifier(id)) {\n      if (duplicates) {\n        const _ids = (ids[id.name] = ids[id.name] || []);\n        _ids.push(id);\n      } else {\n        ids[id.name] = id;\n      }\n      continue;\n    }\n\n    if (isExportDeclaration(id) && !isExportAllDeclaration(id)) {\n      if (isDeclaration(id.declaration)) {\n        search.push(id.declaration);\n      }\n      continue;\n    }\n\n    if (outerOnly) {\n      if (isFunctionDeclaration(id)) {\n        search.push(id.id);\n        continue;\n      }\n\n      if (isFunctionExpression(id)) {\n        continue;\n      }\n    }\n\n    if (keys) {\n      for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        const nodes =\n          // @ts-expect-error key must present in id\n          id[key] as t.Node[] | t.Node | undefined | null;\n        if (nodes) {\n          Array.isArray(nodes) ? search.push(...nodes) : search.push(nodes);\n        }\n      }\n    }\n  }\n\n  // $FlowIssue Object.create() seems broken\n  return ids;\n}\n\n/**\n * Mapping of types to their identifier keys.\n */\ngetBindingIdentifiers.keys = {\n  DeclareClass: [\"id\"],\n  DeclareFunction: [\"id\"],\n  DeclareModule: [\"id\"],\n  DeclareVariable: [\"id\"],\n  DeclareInterface: [\"id\"],\n  DeclareTypeAlias: [\"id\"],\n  DeclareOpaqueType: [\"id\"],\n  InterfaceDeclaration: [\"id\"],\n  TypeAlias: [\"id\"],\n  OpaqueType: [\"id\"],\n\n  CatchClause: [\"param\"],\n  LabeledStatement: [\"label\"],\n  UnaryExpression: [\"argument\"],\n  AssignmentExpression: [\"left\"],\n\n  ImportSpecifier: [\"local\"],\n  ImportNamespaceSpecifier: [\"local\"],\n  ImportDefaultSpecifier: [\"local\"],\n  ImportDeclaration: [\"specifiers\"],\n\n  ExportSpecifier: [\"exported\"],\n  ExportNamespaceSpecifier: [\"exported\"],\n  ExportDefaultSpecifier: [\"exported\"],\n\n  FunctionDeclaration: [\"id\", \"params\"],\n  FunctionExpression: [\"id\", \"params\"],\n  ArrowFunctionExpression: [\"params\"],\n  ObjectMethod: [\"params\"],\n  ClassMethod: [\"params\"],\n  ClassPrivateMethod: [\"params\"],\n\n  ForInStatement: [\"left\"],\n  ForOfStatement: [\"left\"],\n\n  ClassDeclaration: [\"id\"],\n  ClassExpression: [\"id\"],\n\n  RestElement: [\"argument\"],\n  UpdateExpression: [\"argument\"],\n\n  ObjectProperty: [\"value\"],\n\n  AssignmentPattern: [\"left\"],\n  ArrayPattern: [\"elements\"],\n  ObjectPattern: [\"properties\"],\n\n  VariableDeclaration: [\"declarations\"],\n  VariableDeclarator: [\"id\"],\n};\n","module.exports = require(\"regenerator-runtime\");\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}","export default function shallowEqual<T extends object>(\n  actual: object,\n  expected: T,\n): actual is T {\n  const keys = Object.keys(expected) as (keyof T)[];\n\n  for (const key of keys) {\n    if (\n      // @ts-expect-error maybe we should check whether key exists first\n      actual[key] !== expected[key]\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\n\nmodule.exports = _unsupportedIterableToArray;","import {\n  NODE_FIELDS,\n  NODE_PARENT_VALIDATIONS,\n  type FieldOptions,\n} from \"../definitions\";\nimport type * as t from \"..\";\n\nexport default function validate(\n  node: t.Node | undefined | null,\n  key: string,\n  val: any,\n): void {\n  if (!node) return;\n\n  const fields = NODE_FIELDS[node.type];\n  if (!fields) return;\n\n  const field = fields[key];\n  validateField(node, key, val, field);\n  validateChild(node, key, val);\n}\n\nexport function validateField(\n  node: t.Node | undefined | null,\n  key: string,\n  val: any,\n  field: FieldOptions | undefined | null,\n): void {\n  if (!field?.validate) return;\n  if (field.optional && val == null) return;\n\n  field.validate(node, key, val);\n}\n\nexport function validateChild(\n  node: t.Node | undefined | null,\n  key: string,\n  val?: t.Node | undefined | null,\n) {\n  if (val == null) return;\n  const validate = NODE_PARENT_VALIDATIONS[val.type];\n  if (!validate) return;\n  validate(node, key, val);\n}\n","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","import { FLIPPED_ALIAS_KEYS, ALIAS_KEYS } from \"../definitions\";\nimport type * as t from \"..\";\n\nexport default function isType<T extends t.Node[\"type\"]>(\n  nodeType: string,\n  targetType: T,\n): nodeType is T;\n\nexport default function isType(\n  nodeType: string | null | undefined,\n  targetType: string,\n): boolean;\n\n/**\n * Test if a `nodeType` is a `targetType` or if `targetType` is an alias of `nodeType`.\n */\nexport default function isType(nodeType: string, targetType: string): boolean {\n  if (nodeType === targetType) return true;\n\n  // This is a fast-path. If the test above failed, but an alias key is found, then the\n  // targetType was a primary node type, so there's no need to check the aliases.\n  // @ts-expect-error targetType may not index ALIAS_KEYS\n  if (ALIAS_KEYS[targetType]) return false;\n\n  const aliases: Array<string> | undefined = FLIPPED_ALIAS_KEYS[targetType];\n  if (aliases) {\n    if (aliases[0] === nodeType) return true;\n\n    for (const alias of aliases) {\n      if (nodeType === alias) return true;\n    }\n  }\n\n  return false;\n}\n","import type * as t from \"..\";\n\nexport default function inherit<\n  C extends t.Node | undefined,\n  P extends t.Node | undefined,\n>(key: keyof C & keyof P, child: C, parent: P): void {\n  if (child && parent) {\n    // @ts-expect-error Could further refine key definitions\n    child[key] = Array.from(\n      new Set([].concat(child[key], parent[key]).filter(Boolean)),\n    );\n  }\n}\n","import matchesPattern from \"./matchesPattern\";\nimport type * as t from \"..\";\n\n/**\n * Build a function that when called will return whether or not the\n * input `node` `MemberExpression` matches the input `match`.\n *\n * For example, given the match `React.createClass` it would match the\n * parsed nodes of `React.createClass` and `React[\"createClass\"]`.\n */\nexport default function buildMatchMemberExpression(\n  match: string,\n  allowPartial?: boolean,\n) {\n  const parts = match.split(\".\");\n\n  return (member: t.Node) => matchesPattern(member, parts, allowPartial);\n}\n","import {\n  isIdentifier,\n  isMemberExpression,\n  isStringLiteral,\n  isThisExpression,\n} from \"./generated\";\nimport type * as t from \"..\";\n\n/**\n * Determines whether or not the input node `member` matches the\n * input `match`.\n *\n * For example, given the match `React.createClass` it would match the\n * parsed nodes of `React.createClass` and `React[\"createClass\"]`.\n */\nexport default function matchesPattern(\n  member: t.Node | null | undefined,\n  match: string | string[],\n  allowPartial?: boolean,\n): boolean {\n  // not a member expression\n  if (!isMemberExpression(member)) return false;\n\n  const parts = Array.isArray(match) ? match : match.split(\".\");\n  const nodes = [];\n\n  let node;\n  for (node = member; isMemberExpression(node); node = node.object) {\n    nodes.push(node.property);\n  }\n  nodes.push(node);\n\n  if (nodes.length < parts.length) return false;\n  if (!allowPartial && nodes.length > parts.length) return false;\n\n  for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {\n    const node = nodes[j];\n    let value;\n    if (isIdentifier(node)) {\n      value = node.name;\n    } else if (isStringLiteral(node)) {\n      value = node.value;\n    } else if (isThisExpression(node)) {\n      value = \"this\";\n    } else {\n      return false;\n    }\n\n    if (parts[i] !== value) return false;\n  }\n\n  return true;\n}\n","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nmodule.exports = _arrayLikeToArray;","import is from \"../validators/is\";\nimport isValidIdentifier from \"../validators/isValidIdentifier\";\nimport { isKeyword, isReservedWord } from \"@babel/helper-validator-identifier\";\nimport type * as t from \"..\";\nimport { readStringContents } from \"@babel/helper-string-parser\";\n\nimport {\n  BINARY_OPERATORS,\n  LOGICAL_OPERATORS,\n  ASSIGNMENT_OPERATORS,\n  UNARY_OPERATORS,\n  UPDATE_OPERATORS,\n} from \"../constants\";\n\nimport {\n  defineAliasedType,\n  assertShape,\n  assertOptionalChainStart,\n  assertValueType,\n  assertNodeType,\n  assertNodeOrValueType,\n  assertEach,\n  chain,\n  assertOneOf,\n  validateOptional,\n  type Validator,\n} from \"./utils\";\n\nconst defineType = defineAliasedType(\"Standardized\");\n\ndefineType(\"ArrayExpression\", {\n  fields: {\n    elements: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeOrValueType(\"null\", \"Expression\", \"SpreadElement\"),\n        ),\n      ),\n      default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined,\n    },\n  },\n  visitor: [\"elements\"],\n  aliases: [\"Expression\"],\n});\n\ndefineType(\"AssignmentExpression\", {\n  fields: {\n    operator: {\n      validate: (function () {\n        if (!process.env.BABEL_TYPES_8_BREAKING) {\n          return assertValueType(\"string\");\n        }\n\n        const identifier = assertOneOf(...ASSIGNMENT_OPERATORS);\n        const pattern = assertOneOf(\"=\");\n\n        return function (node: t.AssignmentExpression, key, val) {\n          const validator = is(\"Pattern\", node.left) ? pattern : identifier;\n          validator(node, key, val);\n        };\n      })(),\n    },\n    left: {\n      validate: !process.env.BABEL_TYPES_8_BREAKING\n        ? assertNodeType(\"LVal\")\n        : assertNodeType(\n            \"Identifier\",\n            \"MemberExpression\",\n            \"ArrayPattern\",\n            \"ObjectPattern\",\n            \"TSAsExpression\",\n            \"TSSatisfiesExpression\",\n            \"TSTypeAssertion\",\n            \"TSNonNullExpression\",\n          ),\n    },\n    right: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n  builder: [\"operator\", \"left\", \"right\"],\n  visitor: [\"left\", \"right\"],\n  aliases: [\"Expression\"],\n});\n\ndefineType(\"BinaryExpression\", {\n  builder: [\"operator\", \"left\", \"right\"],\n  fields: {\n    operator: {\n      validate: assertOneOf(...BINARY_OPERATORS),\n    },\n    left: {\n      validate: (function () {\n        const expression = assertNodeType(\"Expression\");\n        const inOp = assertNodeType(\"Expression\", \"PrivateName\");\n\n        const validator: Validator = Object.assign(\n          function (node: t.BinaryExpression, key, val) {\n            const validator = node.operator === \"in\" ? inOp : expression;\n            validator(node, key, val);\n          } as Validator,\n          // todo(ts): can be discriminated union by `operator` property\n          { oneOfNodeTypes: [\"Expression\", \"PrivateName\"] },\n        );\n        return validator;\n      })(),\n    },\n    right: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n  visitor: [\"left\", \"right\"],\n  aliases: [\"Binary\", \"Expression\"],\n});\n\ndefineType(\"InterpreterDirective\", {\n  builder: [\"value\"],\n  fields: {\n    value: {\n      validate: assertValueType(\"string\"),\n    },\n  },\n});\n\ndefineType(\"Directive\", {\n  visitor: [\"value\"],\n  fields: {\n    value: {\n      validate: assertNodeType(\"DirectiveLiteral\"),\n    },\n  },\n});\n\ndefineType(\"DirectiveLiteral\", {\n  builder: [\"value\"],\n  fields: {\n    value: {\n      validate: assertValueType(\"string\"),\n    },\n  },\n});\n\ndefineType(\"BlockStatement\", {\n  builder: [\"body\", \"directives\"],\n  visitor: [\"directives\", \"body\"],\n  fields: {\n    directives: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Directive\")),\n      ),\n      default: [],\n    },\n    body: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Statement\")),\n      ),\n    },\n  },\n  aliases: [\"Scopable\", \"BlockParent\", \"Block\", \"Statement\"],\n});\n\ndefineType(\"BreakStatement\", {\n  visitor: [\"label\"],\n  fields: {\n    label: {\n      validate: assertNodeType(\"Identifier\"),\n      optional: true,\n    },\n  },\n  aliases: [\"Statement\", \"Terminatorless\", \"CompletionStatement\"],\n});\n\ndefineType(\"CallExpression\", {\n  visitor: [\"callee\", \"arguments\", \"typeParameters\", \"typeArguments\"],\n  builder: [\"callee\", \"arguments\"],\n  aliases: [\"Expression\"],\n  fields: {\n    callee: {\n      validate: assertNodeType(\"Expression\", \"Super\", \"V8IntrinsicIdentifier\"),\n    },\n    arguments: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeType(\n            \"Expression\",\n            \"SpreadElement\",\n            \"JSXNamespacedName\",\n            \"ArgumentPlaceholder\",\n          ),\n        ),\n      ),\n    },\n    ...(!process.env.BABEL_TYPES_8_BREAKING\n      ? {\n          optional: {\n            validate: assertOneOf(true, false),\n            optional: true,\n          },\n        }\n      : {}),\n    typeArguments: {\n      validate: assertNodeType(\"TypeParameterInstantiation\"),\n      optional: true,\n    },\n    typeParameters: {\n      validate: assertNodeType(\"TSTypeParameterInstantiation\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"CatchClause\", {\n  visitor: [\"param\", \"body\"],\n  fields: {\n    param: {\n      validate: assertNodeType(\"Identifier\", \"ArrayPattern\", \"ObjectPattern\"),\n      optional: true,\n    },\n    body: {\n      validate: assertNodeType(\"BlockStatement\"),\n    },\n  },\n  aliases: [\"Scopable\", \"BlockParent\"],\n});\n\ndefineType(\"ConditionalExpression\", {\n  visitor: [\"test\", \"consequent\", \"alternate\"],\n  fields: {\n    test: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    consequent: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    alternate: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n  aliases: [\"Expression\", \"Conditional\"],\n});\n\ndefineType(\"ContinueStatement\", {\n  visitor: [\"label\"],\n  fields: {\n    label: {\n      validate: assertNodeType(\"Identifier\"),\n      optional: true,\n    },\n  },\n  aliases: [\"Statement\", \"Terminatorless\", \"CompletionStatement\"],\n});\n\ndefineType(\"DebuggerStatement\", {\n  aliases: [\"Statement\"],\n});\n\ndefineType(\"DoWhileStatement\", {\n  visitor: [\"test\", \"body\"],\n  fields: {\n    test: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    body: {\n      validate: assertNodeType(\"Statement\"),\n    },\n  },\n  aliases: [\"Statement\", \"BlockParent\", \"Loop\", \"While\", \"Scopable\"],\n});\n\ndefineType(\"EmptyStatement\", {\n  aliases: [\"Statement\"],\n});\n\ndefineType(\"ExpressionStatement\", {\n  visitor: [\"expression\"],\n  fields: {\n    expression: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n  aliases: [\"Statement\", \"ExpressionWrapper\"],\n});\n\ndefineType(\"File\", {\n  builder: [\"program\", \"comments\", \"tokens\"],\n  visitor: [\"program\"],\n  fields: {\n    program: {\n      validate: assertNodeType(\"Program\"),\n    },\n    comments: {\n      validate: !process.env.BABEL_TYPES_8_BREAKING\n        ? Object.assign(() => {}, {\n            each: { oneOfNodeTypes: [\"CommentBlock\", \"CommentLine\"] },\n          })\n        : assertEach(assertNodeType(\"CommentBlock\", \"CommentLine\")),\n      optional: true,\n    },\n    tokens: {\n      // todo(ts): add Token type\n      validate: assertEach(Object.assign(() => {}, { type: \"any\" })),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"ForInStatement\", {\n  visitor: [\"left\", \"right\", \"body\"],\n  aliases: [\n    \"Scopable\",\n    \"Statement\",\n    \"For\",\n    \"BlockParent\",\n    \"Loop\",\n    \"ForXStatement\",\n  ],\n  fields: {\n    left: {\n      validate: !process.env.BABEL_TYPES_8_BREAKING\n        ? assertNodeType(\"VariableDeclaration\", \"LVal\")\n        : assertNodeType(\n            \"VariableDeclaration\",\n            \"Identifier\",\n            \"MemberExpression\",\n            \"ArrayPattern\",\n            \"ObjectPattern\",\n            \"TSAsExpression\",\n            \"TSSatisfiesExpression\",\n            \"TSTypeAssertion\",\n            \"TSNonNullExpression\",\n          ),\n    },\n    right: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    body: {\n      validate: assertNodeType(\"Statement\"),\n    },\n  },\n});\n\ndefineType(\"ForStatement\", {\n  visitor: [\"init\", \"test\", \"update\", \"body\"],\n  aliases: [\"Scopable\", \"Statement\", \"For\", \"BlockParent\", \"Loop\"],\n  fields: {\n    init: {\n      validate: assertNodeType(\"VariableDeclaration\", \"Expression\"),\n      optional: true,\n    },\n    test: {\n      validate: assertNodeType(\"Expression\"),\n      optional: true,\n    },\n    update: {\n      validate: assertNodeType(\"Expression\"),\n      optional: true,\n    },\n    body: {\n      validate: assertNodeType(\"Statement\"),\n    },\n  },\n});\n\nexport const functionCommon = () => ({\n  params: {\n    validate: chain(\n      assertValueType(\"array\"),\n      assertEach(assertNodeType(\"Identifier\", \"Pattern\", \"RestElement\")),\n    ),\n  },\n  generator: {\n    default: false,\n  },\n  async: {\n    default: false,\n  },\n});\n\nexport const functionTypeAnnotationCommon = () => ({\n  returnType: {\n    validate: process.env.BABEL_8_BREAKING\n      ? assertNodeType(\"TypeAnnotation\", \"TSTypeAnnotation\")\n      : assertNodeType(\n          \"TypeAnnotation\",\n          \"TSTypeAnnotation\",\n          // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n          \"Noop\",\n        ),\n    optional: true,\n  },\n  typeParameters: {\n    validate: process.env.BABEL_8_BREAKING\n      ? assertNodeType(\"TypeParameterDeclaration\", \"TSTypeParameterDeclaration\")\n      : assertNodeType(\n          \"TypeParameterDeclaration\",\n          \"TSTypeParameterDeclaration\",\n          // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n          \"Noop\",\n        ),\n    optional: true,\n  },\n});\n\nexport const functionDeclarationCommon = () => ({\n  ...functionCommon(),\n  declare: {\n    validate: assertValueType(\"boolean\"),\n    optional: true,\n  },\n  id: {\n    validate: assertNodeType(\"Identifier\"),\n    optional: true, // May be null for `export default function`\n  },\n});\n\ndefineType(\"FunctionDeclaration\", {\n  builder: [\"id\", \"params\", \"body\", \"generator\", \"async\"],\n  visitor: [\"id\", \"params\", \"body\", \"returnType\", \"typeParameters\"],\n  fields: {\n    ...functionDeclarationCommon(),\n    ...functionTypeAnnotationCommon(),\n    body: {\n      validate: assertNodeType(\"BlockStatement\"),\n    },\n    predicate: {\n      validate: assertNodeType(\"DeclaredPredicate\", \"InferredPredicate\"),\n      optional: true,\n    },\n  },\n  aliases: [\n    \"Scopable\",\n    \"Function\",\n    \"BlockParent\",\n    \"FunctionParent\",\n    \"Statement\",\n    \"Pureish\",\n    \"Declaration\",\n  ],\n  validate: (function () {\n    if (!process.env.BABEL_TYPES_8_BREAKING) return () => {};\n\n    const identifier = assertNodeType(\"Identifier\");\n\n    return function (parent, key, node) {\n      if (!is(\"ExportDefaultDeclaration\", parent)) {\n        identifier(node, \"id\", node.id);\n      }\n    };\n  })(),\n});\n\ndefineType(\"FunctionExpression\", {\n  inherits: \"FunctionDeclaration\",\n  aliases: [\n    \"Scopable\",\n    \"Function\",\n    \"BlockParent\",\n    \"FunctionParent\",\n    \"Expression\",\n    \"Pureish\",\n  ],\n  fields: {\n    ...functionCommon(),\n    ...functionTypeAnnotationCommon(),\n    id: {\n      validate: assertNodeType(\"Identifier\"),\n      optional: true,\n    },\n    body: {\n      validate: assertNodeType(\"BlockStatement\"),\n    },\n    predicate: {\n      validate: assertNodeType(\"DeclaredPredicate\", \"InferredPredicate\"),\n      optional: true,\n    },\n  },\n});\n\nexport const patternLikeCommon = () => ({\n  typeAnnotation: {\n    validate: process.env.BABEL_8_BREAKING\n      ? assertNodeType(\"TypeAnnotation\", \"TSTypeAnnotation\")\n      : assertNodeType(\n          \"TypeAnnotation\",\n          \"TSTypeAnnotation\",\n          // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n          \"Noop\",\n        ),\n    optional: true,\n  },\n  decorators: {\n    validate: chain(\n      assertValueType(\"array\"),\n      assertEach(assertNodeType(\"Decorator\")),\n    ),\n    optional: true,\n  },\n});\n\ndefineType(\"Identifier\", {\n  builder: [\"name\"],\n  visitor: [\"typeAnnotation\", \"decorators\" /* for legacy param decorators */],\n  aliases: [\"Expression\", \"PatternLike\", \"LVal\", \"TSEntityName\"],\n  fields: {\n    ...patternLikeCommon(),\n    name: {\n      validate: chain(\n        assertValueType(\"string\"),\n        Object.assign(\n          function (node, key, val) {\n            if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n            if (!isValidIdentifier(val, false)) {\n              throw new TypeError(`\"${val}\" is not a valid identifier name`);\n            }\n          } as Validator,\n          { type: \"string\" },\n        ),\n      ),\n    },\n    optional: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n  },\n  validate(parent, key, node) {\n    if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n    const match = /\\.(\\w+)$/.exec(key);\n    if (!match) return;\n\n    const [, parentKey] = match;\n    const nonComp = { computed: false };\n\n    // We can't check if `parent.property === node`, because nodes are validated\n    // before replacing them in the AST.\n    if (parentKey === \"property\") {\n      if (is(\"MemberExpression\", parent, nonComp)) return;\n      if (is(\"OptionalMemberExpression\", parent, nonComp)) return;\n    } else if (parentKey === \"key\") {\n      if (is(\"Property\", parent, nonComp)) return;\n      if (is(\"Method\", parent, nonComp)) return;\n    } else if (parentKey === \"exported\") {\n      if (is(\"ExportSpecifier\", parent)) return;\n    } else if (parentKey === \"imported\") {\n      if (is(\"ImportSpecifier\", parent, { imported: node })) return;\n    } else if (parentKey === \"meta\") {\n      if (is(\"MetaProperty\", parent, { meta: node })) return;\n    }\n\n    if (\n      // Ideally we should call isStrictReservedWord if this node is a descendant\n      // of a block in strict mode. Also, we should pass the inModule option so\n      // we can disable \"await\" in module.\n      (isKeyword(node.name) || isReservedWord(node.name, false)) &&\n      // Even if \"this\" is a keyword, we are using the Identifier\n      // node to represent it.\n      node.name !== \"this\"\n    ) {\n      throw new TypeError(`\"${node.name}\" is not a valid identifier`);\n    }\n  },\n});\n\ndefineType(\"IfStatement\", {\n  visitor: [\"test\", \"consequent\", \"alternate\"],\n  aliases: [\"Statement\", \"Conditional\"],\n  fields: {\n    test: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    consequent: {\n      validate: assertNodeType(\"Statement\"),\n    },\n    alternate: {\n      optional: true,\n      validate: assertNodeType(\"Statement\"),\n    },\n  },\n});\n\ndefineType(\"LabeledStatement\", {\n  visitor: [\"label\", \"body\"],\n  aliases: [\"Statement\"],\n  fields: {\n    label: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n    body: {\n      validate: assertNodeType(\"Statement\"),\n    },\n  },\n});\n\ndefineType(\"StringLiteral\", {\n  builder: [\"value\"],\n  fields: {\n    value: {\n      validate: assertValueType(\"string\"),\n    },\n  },\n  aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"],\n});\n\ndefineType(\"NumericLiteral\", {\n  builder: [\"value\"],\n  deprecatedAlias: \"NumberLiteral\",\n  fields: {\n    value: {\n      validate: assertValueType(\"number\"),\n    },\n  },\n  aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"],\n});\n\ndefineType(\"NullLiteral\", {\n  aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"],\n});\n\ndefineType(\"BooleanLiteral\", {\n  builder: [\"value\"],\n  fields: {\n    value: {\n      validate: assertValueType(\"boolean\"),\n    },\n  },\n  aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"],\n});\n\ndefineType(\"RegExpLiteral\", {\n  builder: [\"pattern\", \"flags\"],\n  deprecatedAlias: \"RegexLiteral\",\n  aliases: [\"Expression\", \"Pureish\", \"Literal\"],\n  fields: {\n    pattern: {\n      validate: assertValueType(\"string\"),\n    },\n    flags: {\n      validate: chain(\n        assertValueType(\"string\"),\n        Object.assign(\n          function (node, key, val) {\n            if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n            const invalid = /[^gimsuy]/.exec(val);\n            if (invalid) {\n              throw new TypeError(`\"${invalid[0]}\" is not a valid RegExp flag`);\n            }\n          } as Validator,\n          { type: \"string\" },\n        ),\n      ),\n      default: \"\",\n    },\n  },\n});\n\ndefineType(\"LogicalExpression\", {\n  builder: [\"operator\", \"left\", \"right\"],\n  visitor: [\"left\", \"right\"],\n  aliases: [\"Binary\", \"Expression\"],\n  fields: {\n    operator: {\n      validate: assertOneOf(...LOGICAL_OPERATORS),\n    },\n    left: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    right: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n});\n\ndefineType(\"MemberExpression\", {\n  builder: [\n    \"object\",\n    \"property\",\n    \"computed\",\n    ...(!process.env.BABEL_TYPES_8_BREAKING ? [\"optional\"] : []),\n  ],\n  visitor: [\"object\", \"property\"],\n  aliases: [\"Expression\", \"LVal\"],\n  fields: {\n    object: {\n      validate: assertNodeType(\"Expression\", \"Super\"),\n    },\n    property: {\n      validate: (function () {\n        const normal = assertNodeType(\"Identifier\", \"PrivateName\");\n        const computed = assertNodeType(\"Expression\");\n\n        const validator: Validator = function (\n          node: t.MemberExpression,\n          key,\n          val,\n        ) {\n          const validator: Validator = node.computed ? computed : normal;\n          validator(node, key, val);\n        };\n        // @ts-expect-error todo(ts): can be discriminated union by `computed` property\n        validator.oneOfNodeTypes = [\"Expression\", \"Identifier\", \"PrivateName\"];\n        return validator;\n      })(),\n    },\n    computed: {\n      default: false,\n    },\n    ...(!process.env.BABEL_TYPES_8_BREAKING\n      ? {\n          optional: {\n            validate: assertOneOf(true, false),\n            optional: true,\n          },\n        }\n      : {}),\n  },\n});\n\ndefineType(\"NewExpression\", { inherits: \"CallExpression\" });\n\ndefineType(\"Program\", {\n  // Note: We explicitly leave 'interpreter' out here because it is\n  // conceptually comment-like, and Babel does not traverse comments either.\n  visitor: [\"directives\", \"body\"],\n  builder: [\"body\", \"directives\", \"sourceType\", \"interpreter\"],\n  fields: {\n    sourceFile: {\n      validate: assertValueType(\"string\"),\n    },\n    sourceType: {\n      validate: assertOneOf(\"script\", \"module\"),\n      default: \"script\",\n    },\n    interpreter: {\n      validate: assertNodeType(\"InterpreterDirective\"),\n      default: null,\n      optional: true,\n    },\n    directives: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Directive\")),\n      ),\n      default: [],\n    },\n    body: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Statement\")),\n      ),\n    },\n  },\n  aliases: [\"Scopable\", \"BlockParent\", \"Block\"],\n});\n\ndefineType(\"ObjectExpression\", {\n  visitor: [\"properties\"],\n  aliases: [\"Expression\"],\n  fields: {\n    properties: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeType(\"ObjectMethod\", \"ObjectProperty\", \"SpreadElement\"),\n        ),\n      ),\n    },\n  },\n});\n\ndefineType(\"ObjectMethod\", {\n  builder: [\"kind\", \"key\", \"params\", \"body\", \"computed\", \"generator\", \"async\"],\n  fields: {\n    ...functionCommon(),\n    ...functionTypeAnnotationCommon(),\n    kind: {\n      validate: assertOneOf(\"method\", \"get\", \"set\"),\n      ...(!process.env.BABEL_TYPES_8_BREAKING ? { default: \"method\" } : {}),\n    },\n    computed: {\n      default: false,\n    },\n    key: {\n      validate: (function () {\n        const normal = assertNodeType(\n          \"Identifier\",\n          \"StringLiteral\",\n          \"NumericLiteral\",\n          \"BigIntLiteral\",\n        );\n        const computed = assertNodeType(\"Expression\");\n\n        const validator: Validator = function (node: t.ObjectMethod, key, val) {\n          const validator = node.computed ? computed : normal;\n          validator(node, key, val);\n        };\n        // @ts-expect-error todo(ts): can be discriminated union by `computed` property\n        validator.oneOfNodeTypes = [\n          \"Expression\",\n          \"Identifier\",\n          \"StringLiteral\",\n          \"NumericLiteral\",\n          \"BigIntLiteral\",\n        ];\n        return validator;\n      })(),\n    },\n    decorators: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Decorator\")),\n      ),\n      optional: true,\n    },\n    body: {\n      validate: assertNodeType(\"BlockStatement\"),\n    },\n  },\n  visitor: [\n    \"key\",\n    \"params\",\n    \"body\",\n    \"decorators\",\n    \"returnType\",\n    \"typeParameters\",\n  ],\n  aliases: [\n    \"UserWhitespacable\",\n    \"Function\",\n    \"Scopable\",\n    \"BlockParent\",\n    \"FunctionParent\",\n    \"Method\",\n    \"ObjectMember\",\n  ],\n});\n\ndefineType(\"ObjectProperty\", {\n  builder: [\n    \"key\",\n    \"value\",\n    \"computed\",\n    \"shorthand\",\n    ...(!process.env.BABEL_TYPES_8_BREAKING ? [\"decorators\"] : []),\n  ],\n  fields: {\n    computed: {\n      default: false,\n    },\n    key: {\n      validate: (function () {\n        const normal = assertNodeType(\n          \"Identifier\",\n          \"StringLiteral\",\n          \"NumericLiteral\",\n          \"BigIntLiteral\",\n          \"DecimalLiteral\",\n          \"PrivateName\",\n        );\n        const computed = assertNodeType(\"Expression\");\n\n        const validator: Validator = Object.assign(\n          function (node: t.ObjectProperty, key, val) {\n            const validator = node.computed ? computed : normal;\n            validator(node, key, val);\n          } as Validator,\n          {\n            // todo(ts): can be discriminated union by `computed` property\n            oneOfNodeTypes: [\n              \"Expression\",\n              \"Identifier\",\n              \"StringLiteral\",\n              \"NumericLiteral\",\n              \"BigIntLiteral\",\n              \"DecimalLiteral\",\n              \"PrivateName\",\n            ],\n          },\n        );\n        return validator;\n      })(),\n    },\n    value: {\n      // Value may be PatternLike if this is an AssignmentProperty\n      // https://github.com/babel/babylon/issues/434\n      validate: assertNodeType(\"Expression\", \"PatternLike\"),\n    },\n    shorthand: {\n      validate: chain(\n        assertValueType(\"boolean\"),\n        Object.assign(\n          function (node: t.ObjectProperty, key, val) {\n            if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n            if (val && node.computed) {\n              throw new TypeError(\n                \"Property shorthand of ObjectProperty cannot be true if computed is true\",\n              );\n            }\n          } as Validator,\n          { type: \"boolean\" },\n        ),\n        function (node: t.ObjectProperty, key, val) {\n          if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n          if (val && !is(\"Identifier\", node.key)) {\n            throw new TypeError(\n              \"Property shorthand of ObjectProperty cannot be true if key is not an Identifier\",\n            );\n          }\n        } as Validator,\n      ),\n      default: false,\n    },\n    decorators: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Decorator\")),\n      ),\n      optional: true,\n    },\n  },\n  visitor: [\"key\", \"value\", \"decorators\"],\n  aliases: [\"UserWhitespacable\", \"Property\", \"ObjectMember\"],\n  validate: (function () {\n    const pattern = assertNodeType(\n      \"Identifier\",\n      \"Pattern\",\n      \"TSAsExpression\",\n      \"TSSatisfiesExpression\",\n      \"TSNonNullExpression\",\n      \"TSTypeAssertion\",\n    );\n    const expression = assertNodeType(\"Expression\");\n\n    return function (parent, key, node) {\n      if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n      const validator = is(\"ObjectPattern\", parent) ? pattern : expression;\n      validator(node, \"value\", node.value);\n    };\n  })(),\n});\n\ndefineType(\"RestElement\", {\n  visitor: [\"argument\", \"typeAnnotation\"],\n  builder: [\"argument\"],\n  aliases: [\"LVal\", \"PatternLike\"],\n  deprecatedAlias: \"RestProperty\",\n  fields: {\n    ...patternLikeCommon(),\n    argument: {\n      validate: !process.env.BABEL_TYPES_8_BREAKING\n        ? assertNodeType(\"LVal\")\n        : assertNodeType(\n            \"Identifier\",\n            \"ArrayPattern\",\n            \"ObjectPattern\",\n            \"MemberExpression\",\n            \"TSAsExpression\",\n            \"TSSatisfiesExpression\",\n            \"TSTypeAssertion\",\n            \"TSNonNullExpression\",\n          ),\n    },\n    // For Flow\n    optional: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n  },\n  validate(parent: t.ArrayPattern | t.ObjectPattern, key) {\n    if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n    const match = /(\\w+)\\[(\\d+)\\]/.exec(key);\n    if (!match) throw new Error(\"Internal Babel error: malformed key.\");\n\n    const [, listKey, index] = match as unknown as [\n      string,\n      keyof typeof parent,\n      string,\n    ];\n    if ((parent[listKey] as t.Node[]).length > +index + 1) {\n      throw new TypeError(`RestElement must be last element of ${listKey}`);\n    }\n  },\n});\n\ndefineType(\"ReturnStatement\", {\n  visitor: [\"argument\"],\n  aliases: [\"Statement\", \"Terminatorless\", \"CompletionStatement\"],\n  fields: {\n    argument: {\n      validate: assertNodeType(\"Expression\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"SequenceExpression\", {\n  visitor: [\"expressions\"],\n  fields: {\n    expressions: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Expression\")),\n      ),\n    },\n  },\n  aliases: [\"Expression\"],\n});\n\ndefineType(\"ParenthesizedExpression\", {\n  visitor: [\"expression\"],\n  aliases: [\"Expression\", \"ExpressionWrapper\"],\n  fields: {\n    expression: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n});\n\ndefineType(\"SwitchCase\", {\n  visitor: [\"test\", \"consequent\"],\n  fields: {\n    test: {\n      validate: assertNodeType(\"Expression\"),\n      optional: true,\n    },\n    consequent: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Statement\")),\n      ),\n    },\n  },\n});\n\ndefineType(\"SwitchStatement\", {\n  visitor: [\"discriminant\", \"cases\"],\n  aliases: [\"Statement\", \"BlockParent\", \"Scopable\"],\n  fields: {\n    discriminant: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    cases: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"SwitchCase\")),\n      ),\n    },\n  },\n});\n\ndefineType(\"ThisExpression\", {\n  aliases: [\"Expression\"],\n});\n\ndefineType(\"ThrowStatement\", {\n  visitor: [\"argument\"],\n  aliases: [\"Statement\", \"Terminatorless\", \"CompletionStatement\"],\n  fields: {\n    argument: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n});\n\ndefineType(\"TryStatement\", {\n  visitor: [\"block\", \"handler\", \"finalizer\"],\n  aliases: [\"Statement\"],\n  fields: {\n    block: {\n      validate: chain(\n        assertNodeType(\"BlockStatement\"),\n        Object.assign(\n          function (node: t.TryStatement) {\n            if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n            // This validator isn't put at the top level because we can run it\n            // even if this node doesn't have a parent.\n\n            if (!node.handler && !node.finalizer) {\n              throw new TypeError(\n                \"TryStatement expects either a handler or finalizer, or both\",\n              );\n            }\n          } as Validator,\n          {\n            oneOfNodeTypes: [\"BlockStatement\"],\n          },\n        ),\n      ),\n    },\n    handler: {\n      optional: true,\n      validate: assertNodeType(\"CatchClause\"),\n    },\n    finalizer: {\n      optional: true,\n      validate: assertNodeType(\"BlockStatement\"),\n    },\n  },\n});\n\ndefineType(\"UnaryExpression\", {\n  builder: [\"operator\", \"argument\", \"prefix\"],\n  fields: {\n    prefix: {\n      default: true,\n    },\n    argument: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    operator: {\n      validate: assertOneOf(...UNARY_OPERATORS),\n    },\n  },\n  visitor: [\"argument\"],\n  aliases: [\"UnaryLike\", \"Expression\"],\n});\n\ndefineType(\"UpdateExpression\", {\n  builder: [\"operator\", \"argument\", \"prefix\"],\n  fields: {\n    prefix: {\n      default: false,\n    },\n    argument: {\n      validate: !process.env.BABEL_TYPES_8_BREAKING\n        ? assertNodeType(\"Expression\")\n        : assertNodeType(\"Identifier\", \"MemberExpression\"),\n    },\n    operator: {\n      validate: assertOneOf(...UPDATE_OPERATORS),\n    },\n  },\n  visitor: [\"argument\"],\n  aliases: [\"Expression\"],\n});\n\ndefineType(\"VariableDeclaration\", {\n  builder: [\"kind\", \"declarations\"],\n  visitor: [\"declarations\"],\n  aliases: [\"Statement\", \"Declaration\"],\n  fields: {\n    declare: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    kind: {\n      validate: assertOneOf(\n        \"var\",\n        \"let\",\n        \"const\",\n        // https://github.com/tc39/proposal-explicit-resource-management\n        \"using\",\n      ),\n    },\n    declarations: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"VariableDeclarator\")),\n      ),\n    },\n  },\n  validate(parent, key, node) {\n    if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n    if (!is(\"ForXStatement\", parent, { left: node })) return;\n    if (node.declarations.length !== 1) {\n      throw new TypeError(\n        `Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`,\n      );\n    }\n  },\n});\n\ndefineType(\"VariableDeclarator\", {\n  visitor: [\"id\", \"init\"],\n  fields: {\n    id: {\n      validate: (function () {\n        if (!process.env.BABEL_TYPES_8_BREAKING) {\n          return assertNodeType(\"LVal\");\n        }\n\n        const normal = assertNodeType(\n          \"Identifier\",\n          \"ArrayPattern\",\n          \"ObjectPattern\",\n        );\n        const without = assertNodeType(\"Identifier\");\n\n        return function (node: t.VariableDeclarator, key, val) {\n          const validator = node.init ? normal : without;\n          validator(node, key, val);\n        };\n      })(),\n    },\n    definite: {\n      optional: true,\n      validate: assertValueType(\"boolean\"),\n    },\n    init: {\n      optional: true,\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n});\n\ndefineType(\"WhileStatement\", {\n  visitor: [\"test\", \"body\"],\n  aliases: [\"Statement\", \"BlockParent\", \"Loop\", \"While\", \"Scopable\"],\n  fields: {\n    test: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    body: {\n      validate: assertNodeType(\"Statement\"),\n    },\n  },\n});\n\ndefineType(\"WithStatement\", {\n  visitor: [\"object\", \"body\"],\n  aliases: [\"Statement\"],\n  fields: {\n    object: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    body: {\n      validate: assertNodeType(\"Statement\"),\n    },\n  },\n});\n\n// --- ES2015 ---\ndefineType(\"AssignmentPattern\", {\n  visitor: [\"left\", \"right\", \"decorators\" /* for legacy param decorators */],\n  builder: [\"left\", \"right\"],\n  aliases: [\"Pattern\", \"PatternLike\", \"LVal\"],\n  fields: {\n    ...patternLikeCommon(),\n    left: {\n      validate: assertNodeType(\n        \"Identifier\",\n        \"ObjectPattern\",\n        \"ArrayPattern\",\n        \"MemberExpression\",\n        \"TSAsExpression\",\n        \"TSSatisfiesExpression\",\n        \"TSTypeAssertion\",\n        \"TSNonNullExpression\",\n      ),\n    },\n    right: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    // For TypeScript\n    decorators: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Decorator\")),\n      ),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"ArrayPattern\", {\n  visitor: [\"elements\", \"typeAnnotation\"],\n  builder: [\"elements\"],\n  aliases: [\"Pattern\", \"PatternLike\", \"LVal\"],\n  fields: {\n    ...patternLikeCommon(),\n    elements: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeOrValueType(\"null\", \"PatternLike\", \"LVal\")),\n      ),\n    },\n    // For TypeScript\n    decorators: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Decorator\")),\n      ),\n      optional: true,\n    },\n    optional: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"ArrowFunctionExpression\", {\n  builder: [\"params\", \"body\", \"async\"],\n  visitor: [\"params\", \"body\", \"returnType\", \"typeParameters\"],\n  aliases: [\n    \"Scopable\",\n    \"Function\",\n    \"BlockParent\",\n    \"FunctionParent\",\n    \"Expression\",\n    \"Pureish\",\n  ],\n  fields: {\n    ...functionCommon(),\n    ...functionTypeAnnotationCommon(),\n    expression: {\n      // https://github.com/babel/babylon/issues/505\n      validate: assertValueType(\"boolean\"),\n    },\n    body: {\n      validate: assertNodeType(\"BlockStatement\", \"Expression\"),\n    },\n    predicate: {\n      validate: assertNodeType(\"DeclaredPredicate\", \"InferredPredicate\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"ClassBody\", {\n  visitor: [\"body\"],\n  fields: {\n    body: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeType(\n            \"ClassMethod\",\n            \"ClassPrivateMethod\",\n            \"ClassProperty\",\n            \"ClassPrivateProperty\",\n            \"ClassAccessorProperty\",\n            \"TSDeclareMethod\",\n            \"TSIndexSignature\",\n            \"StaticBlock\",\n          ),\n        ),\n      ),\n    },\n  },\n});\n\ndefineType(\"ClassExpression\", {\n  builder: [\"id\", \"superClass\", \"body\", \"decorators\"],\n  visitor: [\n    \"id\",\n    \"body\",\n    \"superClass\",\n    \"mixins\",\n    \"typeParameters\",\n    \"superTypeParameters\",\n    \"implements\",\n    \"decorators\",\n  ],\n  aliases: [\"Scopable\", \"Class\", \"Expression\"],\n  fields: {\n    id: {\n      validate: assertNodeType(\"Identifier\"),\n      // In declarations, this is missing if this is the\n      // child of an ExportDefaultDeclaration.\n      optional: true,\n    },\n    typeParameters: {\n      validate: process.env.BABEL_8_BREAKING\n        ? assertNodeType(\n            \"TypeParameterDeclaration\",\n            \"TSTypeParameterDeclaration\",\n          )\n        : assertNodeType(\n            \"TypeParameterDeclaration\",\n            \"TSTypeParameterDeclaration\",\n            // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n            \"Noop\",\n          ),\n      optional: true,\n    },\n    body: {\n      validate: assertNodeType(\"ClassBody\"),\n    },\n    superClass: {\n      optional: true,\n      validate: assertNodeType(\"Expression\"),\n    },\n    superTypeParameters: {\n      validate: assertNodeType(\n        \"TypeParameterInstantiation\",\n        \"TSTypeParameterInstantiation\",\n      ),\n      optional: true,\n    },\n    implements: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeType(\"TSExpressionWithTypeArguments\", \"ClassImplements\"),\n        ),\n      ),\n      optional: true,\n    },\n    decorators: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Decorator\")),\n      ),\n      optional: true,\n    },\n    mixins: {\n      validate: assertNodeType(\"InterfaceExtends\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"ClassDeclaration\", {\n  inherits: \"ClassExpression\",\n  aliases: [\"Scopable\", \"Class\", \"Statement\", \"Declaration\"],\n  fields: {\n    id: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n    typeParameters: {\n      validate: process.env.BABEL_8_BREAKING\n        ? assertNodeType(\n            \"TypeParameterDeclaration\",\n            \"TSTypeParameterDeclaration\",\n          )\n        : assertNodeType(\n            \"TypeParameterDeclaration\",\n            \"TSTypeParameterDeclaration\",\n            // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n            \"Noop\",\n          ),\n      optional: true,\n    },\n    body: {\n      validate: assertNodeType(\"ClassBody\"),\n    },\n    superClass: {\n      optional: true,\n      validate: assertNodeType(\"Expression\"),\n    },\n    superTypeParameters: {\n      validate: assertNodeType(\n        \"TypeParameterInstantiation\",\n        \"TSTypeParameterInstantiation\",\n      ),\n      optional: true,\n    },\n    implements: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeType(\"TSExpressionWithTypeArguments\", \"ClassImplements\"),\n        ),\n      ),\n      optional: true,\n    },\n    decorators: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Decorator\")),\n      ),\n      optional: true,\n    },\n    mixins: {\n      validate: assertNodeType(\"InterfaceExtends\"),\n      optional: true,\n    },\n    declare: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    abstract: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n  },\n  validate: (function () {\n    const identifier = assertNodeType(\"Identifier\");\n\n    return function (parent, key, node) {\n      if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n      if (!is(\"ExportDefaultDeclaration\", parent)) {\n        identifier(node, \"id\", node.id);\n      }\n    };\n  })(),\n});\n\ndefineType(\"ExportAllDeclaration\", {\n  visitor: [\"source\"],\n  aliases: [\n    \"Statement\",\n    \"Declaration\",\n    \"ModuleDeclaration\",\n    \"ExportDeclaration\",\n  ],\n  fields: {\n    source: {\n      validate: assertNodeType(\"StringLiteral\"),\n    },\n    exportKind: validateOptional(assertOneOf(\"type\", \"value\")),\n    assertions: {\n      optional: true,\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"ImportAttribute\")),\n      ),\n    },\n  },\n});\n\ndefineType(\"ExportDefaultDeclaration\", {\n  visitor: [\"declaration\"],\n  aliases: [\n    \"Statement\",\n    \"Declaration\",\n    \"ModuleDeclaration\",\n    \"ExportDeclaration\",\n  ],\n  fields: {\n    declaration: {\n      validate: assertNodeType(\n        \"TSDeclareFunction\",\n        \"FunctionDeclaration\",\n        \"ClassDeclaration\",\n        \"Expression\",\n      ),\n    },\n    exportKind: validateOptional(assertOneOf(\"value\")),\n  },\n});\n\ndefineType(\"ExportNamedDeclaration\", {\n  visitor: [\"declaration\", \"specifiers\", \"source\"],\n  aliases: [\n    \"Statement\",\n    \"Declaration\",\n    \"ModuleDeclaration\",\n    \"ExportDeclaration\",\n  ],\n  fields: {\n    declaration: {\n      optional: true,\n      validate: chain(\n        assertNodeType(\"Declaration\"),\n        Object.assign(\n          function (node: t.ExportNamedDeclaration, key, val) {\n            if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n            // This validator isn't put at the top level because we can run it\n            // even if this node doesn't have a parent.\n\n            if (val && node.specifiers.length) {\n              throw new TypeError(\n                \"Only declaration or specifiers is allowed on ExportNamedDeclaration\",\n              );\n            }\n          } as Validator,\n          { oneOfNodeTypes: [\"Declaration\"] },\n        ),\n        function (node: t.ExportNamedDeclaration, key, val) {\n          if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n          // This validator isn't put at the top level because we can run it\n          // even if this node doesn't have a parent.\n\n          if (val && node.source) {\n            throw new TypeError(\"Cannot export a declaration from a source\");\n          }\n        },\n      ),\n    },\n    assertions: {\n      optional: true,\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"ImportAttribute\")),\n      ),\n    },\n    specifiers: {\n      default: [],\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          (function () {\n            const sourced = assertNodeType(\n              \"ExportSpecifier\",\n              \"ExportDefaultSpecifier\",\n              \"ExportNamespaceSpecifier\",\n            );\n            const sourceless = assertNodeType(\"ExportSpecifier\");\n\n            if (!process.env.BABEL_TYPES_8_BREAKING) return sourced;\n\n            return function (node: t.ExportNamedDeclaration, key, val) {\n              const validator = node.source ? sourced : sourceless;\n              validator(node, key, val);\n            } as Validator;\n          })(),\n        ),\n      ),\n    },\n    source: {\n      validate: assertNodeType(\"StringLiteral\"),\n      optional: true,\n    },\n    exportKind: validateOptional(assertOneOf(\"type\", \"value\")),\n  },\n});\n\ndefineType(\"ExportSpecifier\", {\n  visitor: [\"local\", \"exported\"],\n  aliases: [\"ModuleSpecifier\"],\n  fields: {\n    local: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n    exported: {\n      validate: assertNodeType(\"Identifier\", \"StringLiteral\"),\n    },\n    exportKind: {\n      // And TypeScript's \"export { type foo } from\"\n      validate: assertOneOf(\"type\", \"value\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"ForOfStatement\", {\n  visitor: [\"left\", \"right\", \"body\"],\n  builder: [\"left\", \"right\", \"body\", \"await\"],\n  aliases: [\n    \"Scopable\",\n    \"Statement\",\n    \"For\",\n    \"BlockParent\",\n    \"Loop\",\n    \"ForXStatement\",\n  ],\n  fields: {\n    left: {\n      validate: (function () {\n        if (!process.env.BABEL_TYPES_8_BREAKING) {\n          return assertNodeType(\"VariableDeclaration\", \"LVal\");\n        }\n\n        const declaration = assertNodeType(\"VariableDeclaration\");\n        const lval = assertNodeType(\n          \"Identifier\",\n          \"MemberExpression\",\n          \"ArrayPattern\",\n          \"ObjectPattern\",\n          \"TSAsExpression\",\n          \"TSSatisfiesExpression\",\n          \"TSTypeAssertion\",\n          \"TSNonNullExpression\",\n        );\n\n        return function (node, key, val) {\n          if (is(\"VariableDeclaration\", val)) {\n            declaration(node, key, val);\n          } else {\n            lval(node, key, val);\n          }\n        };\n      })(),\n    },\n    right: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    body: {\n      validate: assertNodeType(\"Statement\"),\n    },\n    await: {\n      default: false,\n    },\n  },\n});\n\ndefineType(\"ImportDeclaration\", {\n  visitor: [\"specifiers\", \"source\"],\n  aliases: [\"Statement\", \"Declaration\", \"ModuleDeclaration\"],\n  fields: {\n    assertions: {\n      optional: true,\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"ImportAttribute\")),\n      ),\n    },\n    module: {\n      optional: true,\n      validate: assertValueType(\"boolean\"),\n    },\n    specifiers: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeType(\n            \"ImportSpecifier\",\n            \"ImportDefaultSpecifier\",\n            \"ImportNamespaceSpecifier\",\n          ),\n        ),\n      ),\n    },\n    source: {\n      validate: assertNodeType(\"StringLiteral\"),\n    },\n    importKind: {\n      // Handle TypeScript/Flowtype's extension \"import type foo from\"\n      // TypeScript doesn't support typeof\n      validate: assertOneOf(\"type\", \"typeof\", \"value\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"ImportDefaultSpecifier\", {\n  visitor: [\"local\"],\n  aliases: [\"ModuleSpecifier\"],\n  fields: {\n    local: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n  },\n});\n\ndefineType(\"ImportNamespaceSpecifier\", {\n  visitor: [\"local\"],\n  aliases: [\"ModuleSpecifier\"],\n  fields: {\n    local: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n  },\n});\n\ndefineType(\"ImportSpecifier\", {\n  visitor: [\"local\", \"imported\"],\n  aliases: [\"ModuleSpecifier\"],\n  fields: {\n    local: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n    imported: {\n      validate: assertNodeType(\"Identifier\", \"StringLiteral\"),\n    },\n    importKind: {\n      // Handle Flowtype's extension \"import {typeof foo} from\"\n      // And TypeScript's \"import { type foo } from\"\n      validate: assertOneOf(\"type\", \"typeof\", \"value\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"MetaProperty\", {\n  visitor: [\"meta\", \"property\"],\n  aliases: [\"Expression\"],\n  fields: {\n    meta: {\n      validate: chain(\n        assertNodeType(\"Identifier\"),\n        Object.assign(\n          function (node: t.MetaProperty, key, val) {\n            if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n            let property;\n            switch (val.name) {\n              case \"function\":\n                property = \"sent\";\n                break;\n              case \"new\":\n                property = \"target\";\n                break;\n              case \"import\":\n                property = \"meta\";\n                break;\n            }\n            if (!is(\"Identifier\", node.property, { name: property })) {\n              throw new TypeError(\"Unrecognised MetaProperty\");\n            }\n          } as Validator,\n          { oneOfNodeTypes: [\"Identifier\"] },\n        ),\n      ),\n    },\n    property: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n  },\n});\n\nexport const classMethodOrPropertyCommon = () => ({\n  abstract: {\n    validate: assertValueType(\"boolean\"),\n    optional: true,\n  },\n  accessibility: {\n    validate: assertOneOf(\"public\", \"private\", \"protected\"),\n    optional: true,\n  },\n  static: {\n    default: false,\n  },\n  override: {\n    default: false,\n  },\n  computed: {\n    default: false,\n  },\n  optional: {\n    validate: assertValueType(\"boolean\"),\n    optional: true,\n  },\n  key: {\n    validate: chain(\n      (function () {\n        const normal = assertNodeType(\n          \"Identifier\",\n          \"StringLiteral\",\n          \"NumericLiteral\",\n        );\n        const computed = assertNodeType(\"Expression\");\n\n        return function (node: any, key: string, val: any) {\n          const validator = node.computed ? computed : normal;\n          validator(node, key, val);\n        };\n      })(),\n      assertNodeType(\n        \"Identifier\",\n        \"StringLiteral\",\n        \"NumericLiteral\",\n        \"BigIntLiteral\",\n        \"Expression\",\n      ),\n    ),\n  },\n});\n\nexport const classMethodOrDeclareMethodCommon = () => ({\n  ...functionCommon(),\n  ...classMethodOrPropertyCommon(),\n  params: {\n    validate: chain(\n      assertValueType(\"array\"),\n      assertEach(\n        assertNodeType(\n          \"Identifier\",\n          \"Pattern\",\n          \"RestElement\",\n          \"TSParameterProperty\",\n        ),\n      ),\n    ),\n  },\n  kind: {\n    validate: assertOneOf(\"get\", \"set\", \"method\", \"constructor\"),\n    default: \"method\",\n  },\n  access: {\n    validate: chain(\n      assertValueType(\"string\"),\n      assertOneOf(\"public\", \"private\", \"protected\"),\n    ),\n    optional: true,\n  },\n  decorators: {\n    validate: chain(\n      assertValueType(\"array\"),\n      assertEach(assertNodeType(\"Decorator\")),\n    ),\n    optional: true,\n  },\n});\n\ndefineType(\"ClassMethod\", {\n  aliases: [\"Function\", \"Scopable\", \"BlockParent\", \"FunctionParent\", \"Method\"],\n  builder: [\n    \"kind\",\n    \"key\",\n    \"params\",\n    \"body\",\n    \"computed\",\n    \"static\",\n    \"generator\",\n    \"async\",\n  ],\n  visitor: [\n    \"key\",\n    \"params\",\n    \"body\",\n    \"decorators\",\n    \"returnType\",\n    \"typeParameters\",\n  ],\n  fields: {\n    ...classMethodOrDeclareMethodCommon(),\n    ...functionTypeAnnotationCommon(),\n    body: {\n      validate: assertNodeType(\"BlockStatement\"),\n    },\n  },\n});\n\ndefineType(\"ObjectPattern\", {\n  visitor: [\n    \"properties\",\n    \"typeAnnotation\",\n    \"decorators\" /* for legacy param decorators */,\n  ],\n  builder: [\"properties\"],\n  aliases: [\"Pattern\", \"PatternLike\", \"LVal\"],\n  fields: {\n    ...patternLikeCommon(),\n    properties: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"RestElement\", \"ObjectProperty\")),\n      ),\n    },\n  },\n});\n\ndefineType(\"SpreadElement\", {\n  visitor: [\"argument\"],\n  aliases: [\"UnaryLike\"],\n  deprecatedAlias: \"SpreadProperty\",\n  fields: {\n    argument: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n});\n\ndefineType(\n  \"Super\",\n  process.env.BABEL_8_BREAKING\n    ? undefined\n    : {\n        aliases: [\"Expression\"],\n      },\n);\n\ndefineType(\"TaggedTemplateExpression\", {\n  visitor: [\"tag\", \"quasi\", \"typeParameters\"],\n  builder: [\"tag\", \"quasi\"],\n  aliases: [\"Expression\"],\n  fields: {\n    tag: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    quasi: {\n      validate: assertNodeType(\"TemplateLiteral\"),\n    },\n    typeParameters: {\n      validate: assertNodeType(\n        \"TypeParameterInstantiation\",\n        \"TSTypeParameterInstantiation\",\n      ),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"TemplateElement\", {\n  builder: [\"value\", \"tail\"],\n  fields: {\n    value: {\n      validate: chain(\n        assertShape({\n          raw: {\n            validate: assertValueType(\"string\"),\n          },\n          cooked: {\n            validate: assertValueType(\"string\"),\n            optional: true,\n          },\n        }),\n        function templateElementCookedValidator(node: t.TemplateElement) {\n          const raw = node.value.raw;\n\n          let unterminatedCalled = false;\n\n          const error = () => {\n            // unreachable\n            throw new Error(\"Internal @babel/types error.\");\n          };\n          const { str, firstInvalidLoc } = readStringContents(\n            \"template\",\n            raw,\n            0,\n            0,\n            0,\n            {\n              unterminated() {\n                unterminatedCalled = true;\n              },\n              strictNumericEscape: error,\n              invalidEscapeSequence: error,\n              numericSeparatorInEscapeSequence: error,\n              unexpectedNumericSeparator: error,\n              invalidDigit: error,\n              invalidCodePoint: error,\n            },\n          );\n          if (!unterminatedCalled) throw new Error(\"Invalid raw\");\n\n          node.value.cooked = firstInvalidLoc ? null : str;\n        },\n      ),\n    },\n    tail: {\n      default: false,\n    },\n  },\n});\n\ndefineType(\"TemplateLiteral\", {\n  visitor: [\"quasis\", \"expressions\"],\n  aliases: [\"Expression\", \"Literal\"],\n  fields: {\n    quasis: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"TemplateElement\")),\n      ),\n    },\n    expressions: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeType(\n            \"Expression\",\n            // For TypeScript template literal types\n            \"TSType\",\n          ),\n        ),\n        function (node: t.TemplateLiteral, key, val) {\n          if (node.quasis.length !== val.length + 1) {\n            throw new TypeError(\n              `Number of ${\n                node.type\n              } quasis should be exactly one more than the number of expressions.\\nExpected ${\n                val.length + 1\n              } quasis but got ${node.quasis.length}`,\n            );\n          }\n        } as Validator,\n      ),\n    },\n  },\n});\n\ndefineType(\"YieldExpression\", {\n  builder: [\"argument\", \"delegate\"],\n  visitor: [\"argument\"],\n  aliases: [\"Expression\", \"Terminatorless\"],\n  fields: {\n    delegate: {\n      validate: chain(\n        assertValueType(\"boolean\"),\n        Object.assign(\n          function (node: t.YieldExpression, key, val) {\n            if (!process.env.BABEL_TYPES_8_BREAKING) return;\n\n            if (val && !node.argument) {\n              throw new TypeError(\n                \"Property delegate of YieldExpression cannot be true if there is no argument\",\n              );\n            }\n          } as Validator,\n          { type: \"boolean\" },\n        ),\n      ),\n      default: false,\n    },\n    argument: {\n      optional: true,\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n});\n\n// --- ES2017 ---\ndefineType(\"AwaitExpression\", {\n  builder: [\"argument\"],\n  visitor: [\"argument\"],\n  aliases: [\"Expression\", \"Terminatorless\"],\n  fields: {\n    argument: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n});\n\n// --- ES2019 ---\ndefineType(\"Import\", {\n  aliases: [\"Expression\"],\n});\n\n// --- ES2020 ---\ndefineType(\"BigIntLiteral\", {\n  builder: [\"value\"],\n  fields: {\n    value: {\n      validate: assertValueType(\"string\"),\n    },\n  },\n  aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"],\n});\n\ndefineType(\"ExportNamespaceSpecifier\", {\n  visitor: [\"exported\"],\n  aliases: [\"ModuleSpecifier\"],\n  fields: {\n    exported: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n  },\n});\n\ndefineType(\"OptionalMemberExpression\", {\n  builder: [\"object\", \"property\", \"computed\", \"optional\"],\n  visitor: [\"object\", \"property\"],\n  aliases: [\"Expression\"],\n  fields: {\n    object: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    property: {\n      validate: (function () {\n        const normal = assertNodeType(\"Identifier\");\n        const computed = assertNodeType(\"Expression\");\n\n        const validator: Validator = Object.assign(\n          function (node: t.OptionalMemberExpression, key, val) {\n            const validator = node.computed ? computed : normal;\n            validator(node, key, val);\n          } as Validator,\n          // todo(ts): can be discriminated union by `computed` property\n          { oneOfNodeTypes: [\"Expression\", \"Identifier\"] },\n        );\n        return validator;\n      })(),\n    },\n    computed: {\n      default: false,\n    },\n    optional: {\n      validate: !process.env.BABEL_TYPES_8_BREAKING\n        ? assertValueType(\"boolean\")\n        : chain(assertValueType(\"boolean\"), assertOptionalChainStart()),\n    },\n  },\n});\n\ndefineType(\"OptionalCallExpression\", {\n  visitor: [\"callee\", \"arguments\", \"typeParameters\", \"typeArguments\"],\n  builder: [\"callee\", \"arguments\", \"optional\"],\n  aliases: [\"Expression\"],\n  fields: {\n    callee: {\n      validate: assertNodeType(\"Expression\"),\n    },\n    arguments: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeType(\n            \"Expression\",\n            \"SpreadElement\",\n            \"JSXNamespacedName\",\n            \"ArgumentPlaceholder\",\n          ),\n        ),\n      ),\n    },\n    optional: {\n      validate: !process.env.BABEL_TYPES_8_BREAKING\n        ? assertValueType(\"boolean\")\n        : chain(assertValueType(\"boolean\"), assertOptionalChainStart()),\n    },\n    typeArguments: {\n      validate: assertNodeType(\"TypeParameterInstantiation\"),\n      optional: true,\n    },\n    typeParameters: {\n      validate: assertNodeType(\"TSTypeParameterInstantiation\"),\n      optional: true,\n    },\n  },\n});\n\n// --- ES2022 ---\ndefineType(\"ClassProperty\", {\n  visitor: [\"key\", \"value\", \"typeAnnotation\", \"decorators\"],\n  builder: [\n    \"key\",\n    \"value\",\n    \"typeAnnotation\",\n    \"decorators\",\n    \"computed\",\n    \"static\",\n  ],\n  aliases: [\"Property\"],\n  fields: {\n    ...classMethodOrPropertyCommon(),\n    value: {\n      validate: assertNodeType(\"Expression\"),\n      optional: true,\n    },\n    definite: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    typeAnnotation: {\n      validate: process.env.BABEL_8_BREAKING\n        ? assertNodeType(\"TypeAnnotation\", \"TSTypeAnnotation\")\n        : assertNodeType(\n            \"TypeAnnotation\",\n            \"TSTypeAnnotation\",\n            // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n            \"Noop\",\n          ),\n      optional: true,\n    },\n    decorators: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Decorator\")),\n      ),\n      optional: true,\n    },\n    readonly: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    declare: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    variance: {\n      validate: assertNodeType(\"Variance\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"ClassAccessorProperty\", {\n  visitor: [\"key\", \"value\", \"typeAnnotation\", \"decorators\"],\n  builder: [\n    \"key\",\n    \"value\",\n    \"typeAnnotation\",\n    \"decorators\",\n    \"computed\",\n    \"static\",\n  ],\n  aliases: [\"Property\", \"Accessor\"],\n  fields: {\n    ...classMethodOrPropertyCommon(),\n    key: {\n      validate: chain(\n        (function () {\n          const normal = assertNodeType(\n            \"Identifier\",\n            \"StringLiteral\",\n            \"NumericLiteral\",\n            \"BigIntLiteral\",\n            \"PrivateName\",\n          );\n          const computed = assertNodeType(\"Expression\");\n\n          return function (node: any, key: string, val: any) {\n            const validator = node.computed ? computed : normal;\n            validator(node, key, val);\n          };\n        })(),\n        assertNodeType(\n          \"Identifier\",\n          \"StringLiteral\",\n          \"NumericLiteral\",\n          \"BigIntLiteral\",\n          \"Expression\",\n          \"PrivateName\",\n        ),\n      ),\n    },\n    value: {\n      validate: assertNodeType(\"Expression\"),\n      optional: true,\n    },\n    definite: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    typeAnnotation: {\n      validate: process.env.BABEL_8_BREAKING\n        ? assertNodeType(\"TypeAnnotation\", \"TSTypeAnnotation\")\n        : assertNodeType(\n            \"TypeAnnotation\",\n            \"TSTypeAnnotation\",\n            // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n            \"Noop\",\n          ),\n      optional: true,\n    },\n    decorators: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Decorator\")),\n      ),\n      optional: true,\n    },\n    readonly: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    declare: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    variance: {\n      validate: assertNodeType(\"Variance\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"ClassPrivateProperty\", {\n  visitor: [\"key\", \"value\", \"decorators\", \"typeAnnotation\"],\n  builder: [\"key\", \"value\", \"decorators\", \"static\"],\n  aliases: [\"Property\", \"Private\"],\n  fields: {\n    key: {\n      validate: assertNodeType(\"PrivateName\"),\n    },\n    value: {\n      validate: assertNodeType(\"Expression\"),\n      optional: true,\n    },\n    typeAnnotation: {\n      validate: process.env.BABEL_8_BREAKING\n        ? assertNodeType(\"TypeAnnotation\", \"TSTypeAnnotation\")\n        : assertNodeType(\n            \"TypeAnnotation\",\n            \"TSTypeAnnotation\",\n            // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n            \"Noop\",\n          ),\n      optional: true,\n    },\n    decorators: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Decorator\")),\n      ),\n      optional: true,\n    },\n    static: {\n      validate: assertValueType(\"boolean\"),\n      default: false,\n    },\n    readonly: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    definite: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    variance: {\n      validate: assertNodeType(\"Variance\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"ClassPrivateMethod\", {\n  builder: [\"kind\", \"key\", \"params\", \"body\", \"static\"],\n  visitor: [\n    \"key\",\n    \"params\",\n    \"body\",\n    \"decorators\",\n    \"returnType\",\n    \"typeParameters\",\n  ],\n  aliases: [\n    \"Function\",\n    \"Scopable\",\n    \"BlockParent\",\n    \"FunctionParent\",\n    \"Method\",\n    \"Private\",\n  ],\n  fields: {\n    ...classMethodOrDeclareMethodCommon(),\n    ...functionTypeAnnotationCommon(),\n    kind: {\n      validate: assertOneOf(\"get\", \"set\", \"method\"),\n      default: \"method\",\n    },\n    key: {\n      validate: assertNodeType(\"PrivateName\"),\n    },\n    body: {\n      validate: assertNodeType(\"BlockStatement\"),\n    },\n  },\n});\n\ndefineType(\"PrivateName\", {\n  visitor: [\"id\"],\n  aliases: [\"Private\"],\n  fields: {\n    id: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n  },\n});\n\ndefineType(\"StaticBlock\", {\n  visitor: [\"body\"],\n  fields: {\n    body: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Statement\")),\n      ),\n    },\n  },\n  aliases: [\"Scopable\", \"BlockParent\", \"FunctionParent\"],\n});\n","import { PLACEHOLDERS_ALIAS } from \"../definitions\";\n\n/**\n * Test if a `placeholderType` is a `targetType` or if `targetType` is an alias of `placeholderType`.\n */\nexport default function isPlaceholderType(\n  placeholderType: string,\n  targetType: string,\n): boolean {\n  if (placeholderType === targetType) return true;\n\n  const aliases: Array<string> | undefined =\n    PLACEHOLDERS_ALIAS[placeholderType];\n  if (aliases) {\n    for (const alias of aliases) {\n      if (targetType === alias) return true;\n    }\n  }\n\n  return false;\n}\n","import { ALIAS_KEYS } from \"./utils\";\n\nexport const PLACEHOLDERS = [\n  \"Identifier\",\n  \"StringLiteral\",\n  \"Expression\",\n  \"Statement\",\n  \"Declaration\",\n  \"BlockStatement\",\n  \"ClassBody\",\n  \"Pattern\",\n] as const;\n\nexport const PLACEHOLDERS_ALIAS: Record<string, string[]> = {\n  Declaration: [\"Statement\"],\n  Pattern: [\"PatternLike\", \"LVal\"],\n};\n\nfor (const type of PLACEHOLDERS) {\n  const alias = ALIAS_KEYS[type];\n  if (alias?.length) PLACEHOLDERS_ALIAS[type] = alias;\n}\n\nexport const PLACEHOLDERS_FLIPPED_ALIAS: Record<string, string[]> = {};\n\nObject.keys(PLACEHOLDERS_ALIAS).forEach(type => {\n  PLACEHOLDERS_ALIAS[type].forEach(alias => {\n    if (!Object.hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) {\n      PLACEHOLDERS_FLIPPED_ALIAS[alias] = [];\n    }\n    PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type);\n  });\n});\n","import { VISITOR_KEYS } from \"../definitions\";\nimport type * as t from \"..\";\n\nexport default function isNode(node: any): node is t.Node {\n  return !!(node && VISITOR_KEYS[node.type]);\n}\n","import {\n  isAnyTypeAnnotation,\n  isGenericTypeAnnotation,\n  isUnionTypeAnnotation,\n  isFlowBaseAnnotation,\n  isIdentifier,\n} from \"../../validators/generated\";\nimport type * as t from \"../..\";\n\nfunction getQualifiedName(node: t.GenericTypeAnnotation[\"id\"]): string {\n  return isIdentifier(node)\n    ? node.name\n    : `${node.id.name}.${getQualifiedName(node.qualification)}`;\n}\n\n/**\n * Dedupe type annotations.\n */\nexport default function removeTypeDuplicates(\n  // todo(babel-8): change type to Array<...>\n  nodes: ReadonlyArray<t.FlowType | false | null | undefined>,\n): t.FlowType[] {\n  const generics = new Map<string, t.GenericTypeAnnotation>();\n  const bases = new Map<t.FlowBaseAnnotation[\"type\"], t.FlowBaseAnnotation>();\n\n  // store union type groups to circular references\n  const typeGroups = new Set<t.FlowType[]>();\n\n  const types: t.FlowType[] = [];\n\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i];\n    if (!node) continue;\n\n    // detect duplicates\n    if (types.indexOf(node) >= 0) {\n      continue;\n    }\n\n    // this type matches anything\n    if (isAnyTypeAnnotation(node)) {\n      return [node];\n    }\n\n    if (isFlowBaseAnnotation(node)) {\n      bases.set(node.type, node);\n      continue;\n    }\n\n    if (isUnionTypeAnnotation(node)) {\n      if (!typeGroups.has(node.types)) {\n        // todo(babel-8): use .push when nodes is mutable\n        nodes = nodes.concat(node.types);\n        typeGroups.add(node.types);\n      }\n      continue;\n    }\n\n    // find a matching generic type and merge and deduplicate the type parameters\n    if (isGenericTypeAnnotation(node)) {\n      const name = getQualifiedName(node.id);\n\n      if (generics.has(name)) {\n        let existing: t.Flow = generics.get(name);\n        if (existing.typeParameters) {\n          if (node.typeParameters) {\n            existing.typeParameters.params = removeTypeDuplicates(\n              existing.typeParameters.params.concat(node.typeParameters.params),\n            );\n          }\n        } else {\n          existing = node.typeParameters;\n        }\n      } else {\n        generics.set(name, node);\n      }\n\n      continue;\n    }\n\n    types.push(node);\n  }\n\n  // add back in bases\n  for (const [, baseType] of bases) {\n    types.push(baseType);\n  }\n\n  // add back in generics\n  for (const [, genericName] of generics) {\n    types.push(genericName);\n  }\n\n  return types;\n}\n","import type * as t from \"..\";\n\n/**\n * Add comments of certain type to a node.\n */\nexport default function addComments<T extends t.Node>(\n  node: T,\n  type: t.CommentTypeShorthand,\n  comments: Array<t.Comment>,\n): T {\n  if (!comments || !node) return node;\n\n  const key = `${type}Comments` as const;\n\n  if (node[key]) {\n    if (type === \"leading\") {\n      node[key] = comments.concat(node[key]);\n    } else {\n      node[key].push(...comments);\n    }\n  } else {\n    node[key] = comments;\n  }\n\n  return node;\n}\n","import inherit from \"../utils/inherit\";\nimport type * as t from \"..\";\n\nexport default function inheritInnerComments(\n  child: t.Node,\n  parent: t.Node,\n): void {\n  inherit(\"innerComments\", child, parent);\n}\n","import inherit from \"../utils/inherit\";\nimport type * as t from \"..\";\n\nexport default function inheritLeadingComments(\n  child: t.Node,\n  parent: t.Node,\n): void {\n  inherit(\"leadingComments\", child, parent);\n}\n","import inheritTrailingComments from \"./inheritTrailingComments\";\nimport inheritLeadingComments from \"./inheritLeadingComments\";\nimport inheritInnerComments from \"./inheritInnerComments\";\nimport type * as t from \"..\";\n\n/**\n * Inherit all unique comments from `parent` node to `child` node.\n */\nexport default function inheritsComments<T extends t.Node>(\n  child: T,\n  parent: t.Node,\n): T {\n  inheritTrailingComments(child, parent);\n  inheritLeadingComments(child, parent);\n  inheritInnerComments(child, parent);\n\n  return child;\n}\n","import inherit from \"../utils/inherit\";\nimport type * as t from \"..\";\n\nexport default function inheritTrailingComments(\n  child: t.Node,\n  parent: t.Node,\n): void {\n  inherit(\"trailingComments\", child, parent);\n}\n","import {\n  isBlockStatement,\n  isFunction,\n  isEmptyStatement,\n  isStatement,\n} from \"../validators/generated\";\nimport {\n  returnStatement,\n  expressionStatement,\n  blockStatement,\n} from \"../builders/generated\";\nimport type * as t from \"..\";\n\nexport default function toBlock(\n  node: t.Statement | t.Expression,\n  parent?: t.Node,\n): t.BlockStatement {\n  if (isBlockStatement(node)) {\n    return node;\n  }\n\n  let blockNodes: t.Statement[] = [];\n\n  if (isEmptyStatement(node)) {\n    blockNodes = [];\n  } else {\n    if (!isStatement(node)) {\n      if (isFunction(parent)) {\n        node = returnStatement(node);\n      } else {\n        node = expressionStatement(node);\n      }\n    }\n\n    blockNodes = [node];\n  }\n\n  return blockStatement(blockNodes);\n}\n","import isValidIdentifier from \"../validators/isValidIdentifier\";\nimport { isIdentifierChar } from \"@babel/helper-validator-identifier\";\n\nexport default function toIdentifier(input: string): string {\n  input = input + \"\";\n\n  // replace all non-valid identifiers with dashes\n  let name = \"\";\n  for (const c of input) {\n    name += isIdentifierChar(c.codePointAt(0)) ? c : \"-\";\n  }\n\n  // remove all dashes and numbers from start of name\n  name = name.replace(/^[-0-9]+/, \"\");\n\n  // camel case\n  name = name.replace(/[-\\s]+(.)?/g, function (match, c) {\n    return c ? c.toUpperCase() : \"\";\n  });\n\n  if (!isValidIdentifier(name)) {\n    name = `_${name}`;\n  }\n\n  return name || \"_\";\n}\n","import traverseFast from \"../traverse/traverseFast\";\nimport removeProperties from \"./removeProperties\";\nimport type * as t from \"..\";\n\nexport default function removePropertiesDeep<T extends t.Node>(\n  tree: T,\n  opts?: { preserveComments: boolean } | null,\n): T {\n  traverseFast(tree, removeProperties, opts);\n\n  return tree;\n}\n","import { VISITOR_KEYS } from \"../definitions\";\nimport type * as t from \"..\";\n\n/**\n * A prefix AST traversal implementation meant for simple searching\n * and processing.\n */\nexport default function traverseFast<Options = {}>(\n  node: t.Node | null | undefined,\n  enter: (node: t.Node, opts?: Options) => void,\n  opts?: Options,\n): void {\n  if (!node) return;\n\n  const keys = VISITOR_KEYS[node.type];\n  if (!keys) return;\n\n  opts = opts || ({} as Options);\n  enter(node, opts);\n\n  for (const key of keys) {\n    const subNode: t.Node | undefined | null =\n      // @ts-expect-error key must present in node\n      node[key];\n\n    if (Array.isArray(subNode)) {\n      for (const node of subNode) {\n        traverseFast(node, enter, opts);\n      }\n    } else {\n      traverseFast(subNode, enter, opts);\n    }\n  }\n}\n","import { COMMENT_KEYS } from \"../constants\";\nimport type * as t from \"..\";\n\nconst CLEAR_KEYS = [\n  \"tokens\", // only exist in t.File\n  \"start\",\n  \"end\",\n  \"loc\",\n  // Fixme: should be extra.raw / extra.rawValue?\n  \"raw\",\n  \"rawValue\",\n] as const;\n\nconst CLEAR_KEYS_PLUS_COMMENTS = [\n  ...COMMENT_KEYS,\n  \"comments\",\n  ...CLEAR_KEYS,\n] as const;\n\nexport type Options = { preserveComments?: boolean };\n/**\n * Remove all of the _* properties from a node along with the additional metadata\n * properties like location data and raw token data.\n */\nexport default function removeProperties(\n  node: t.Node,\n  opts: Options = {},\n): void {\n  const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;\n  for (const key of map) {\n    // @ts-expect-error tokens only exist in t.File\n    if (node[key] != null) node[key] = undefined;\n  }\n\n  for (const key of Object.keys(node)) {\n    // @ts-expect-error string can not index node\n    if (key[0] === \"_\" && node[key] != null) node[key] = undefined;\n  }\n\n  const symbols: Array<symbol> = Object.getOwnPropertySymbols(node);\n  for (const sym of symbols) {\n    // @ts-expect-error Fixme: document symbol properties\n    node[sym] = null;\n  }\n}\n","import { isVariableDeclaration } from \"./generated\";\nimport { BLOCK_SCOPED_SYMBOL } from \"../constants\";\nimport type * as t from \"..\";\n\n/**\n * Check if the input `node` is a `let` variable declaration.\n */\nexport default function isLet(node: t.Node): boolean {\n  return (\n    isVariableDeclaration(node) &&\n    (node.kind !== \"var\" ||\n      // @ts-expect-error Fixme: document private properties\n      node[BLOCK_SCOPED_SYMBOL])\n  );\n}\n","import buildMatchMemberExpression from \"../buildMatchMemberExpression\";\n\nconst isReactComponent = buildMatchMemberExpression(\"React.Component\");\n\nexport default isReactComponent;\n","export default function isCompatTag(tagName?: string): boolean {\n  // Must start with a lowercase ASCII letter\n  return !!tagName && /^[a-z]/.test(tagName);\n}\n","import {\n  isJSXText,\n  isJSXExpressionContainer,\n  isJSXEmptyExpression,\n} from \"../../validators/generated\";\nimport cleanJSXElementLiteralChild from \"../../utils/react/cleanJSXElementLiteralChild\";\nimport type * as t from \"../..\";\n\ntype ReturnedChild =\n  | t.JSXSpreadChild\n  | t.JSXElement\n  | t.JSXFragment\n  | t.Expression;\n\nexport default function buildChildren(\n  node: t.JSXElement | t.JSXFragment,\n): ReturnedChild[] {\n  const elements = [];\n\n  for (let i = 0; i < node.children.length; i++) {\n    let child: any = node.children[i];\n\n    if (isJSXText(child)) {\n      cleanJSXElementLiteralChild(child, elements);\n      continue;\n    }\n\n    if (isJSXExpressionContainer(child)) child = child.expression;\n    if (isJSXEmptyExpression(child)) continue;\n\n    elements.push(child);\n  }\n\n  return elements;\n}\n","import { stringLiteral } from \"../../builders/generated\";\nimport type * as t from \"../..\";\nimport { inherits } from \"../..\";\n\nexport default function cleanJSXElementLiteralChild(\n  child: t.JSXText,\n  args: Array<t.Node>,\n) {\n  const lines = child.value.split(/\\r\\n|\\n|\\r/);\n\n  let lastNonEmptyLine = 0;\n\n  for (let i = 0; i < lines.length; i++) {\n    if (lines[i].match(/[^ \\t]/)) {\n      lastNonEmptyLine = i;\n    }\n  }\n\n  let str = \"\";\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n\n    const isFirstLine = i === 0;\n    const isLastLine = i === lines.length - 1;\n    const isLastNonEmptyLine = i === lastNonEmptyLine;\n\n    // replace rendered whitespace tabs with spaces\n    let trimmedLine = line.replace(/\\t/g, \" \");\n\n    // trim whitespace touching a newline\n    if (!isFirstLine) {\n      trimmedLine = trimmedLine.replace(/^[ ]+/, \"\");\n    }\n\n    // trim whitespace touching an endline\n    if (!isLastLine) {\n      trimmedLine = trimmedLine.replace(/[ ]+$/, \"\");\n    }\n\n    if (trimmedLine) {\n      if (!isLastNonEmptyLine) {\n        trimmedLine += \" \";\n      }\n\n      str += trimmedLine;\n    }\n  }\n\n  if (str) args.push(inherits(stringLiteral(str), child));\n}\n","import validate from \"../validators/validate\";\nimport type * as t from \"..\";\nimport { BUILDER_KEYS } from \"..\";\n\nexport default function validateNode<N extends t.Node>(node: N) {\n  // todo: because keys not in BUILDER_KEYS are not validated - this actually allows invalid nodes in some cases\n  const keys = BUILDER_KEYS[node.type] as (keyof N & string)[];\n  for (const key of keys) {\n    validate(node, key, node[key]);\n  }\n  return node;\n}\n","'use strict';\n\nlet fastProto = null;\n\n// Creates an object with permanently fast properties in V8. See Toon Verwaest's\n// post https://medium.com/@tverwaes/setting-up-prototypes-in-v8-ec9c9491dfe2#5f62\n// for more details. Use %HasFastProperties(object) and the Node.js flag\n// --allow-natives-syntax to check whether an object has fast properties.\nfunction FastObject(o) {\n\t// A prototype object will have \"fast properties\" enabled once it is checked\n\t// against the inline property cache of a function, e.g. fastProto.property:\n\t// https://github.com/v8/v8/blob/6.0.122/test/mjsunit/fast-prototype.js#L48-L63\n\tif (fastProto !== null && typeof fastProto.property) {\n\t\tconst result = fastProto;\n\t\tfastProto = FastObject.prototype = null;\n\t\treturn result;\n\t}\n\tfastProto = FastObject.prototype = o == null ? Object.create(null) : o;\n\treturn new FastObject;\n}\n\n// Initialize the inline property cache of FastObject\nFastObject();\n\nmodule.exports = function toFastproperties(o) {\n\treturn FastObject(o);\n};\n","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableRest;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableSpread;","import * 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.js`.\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-\\u1c88\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf3\\u1cf5\\u1cf6\\u1cfa\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2118-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309b-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u31a0-\\u31bf\\u31f0-\\u31ff\\u3400-\\u4dbf\\u4e00-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7ca\\ua7d0\\ua7d1\\ua7d3\\ua7d5-\\ua7d9\\ua7f2-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\ua9e0-\\ua9e4\\ua9e6-\\ua9ef\\ua9fa-\\ua9fe\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa7e-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uab30-\\uab5a\\uab5c-\\uab69\\uab70-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc\";\n/* prettier-ignore */\nlet nonASCIIidentifierChars = \"\\u200c\\u200d\\xb7\\u0300-\\u036f\\u0387\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u0669\\u0670\\u06d6-\\u06dc\\u06df-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u06f0-\\u06f9\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07c0-\\u07c9\\u07eb-\\u07f3\\u07fd\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0859-\\u085b\\u0898-\\u089f\\u08ca-\\u08e1\\u08e3-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09cd\\u09d7\\u09e2\\u09e3\\u09e6-\\u09ef\\u09fe\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2\\u0ae3\\u0ae6-\\u0aef\\u0afa-\\u0aff\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b55-\\u0b57\\u0b62\\u0b63\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c00-\\u0c04\\u0c3c\\u0c3e-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0c66-\\u0c6f\\u0c81-\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0ce6-\\u0cef\\u0cf3\\u0d00-\\u0d03\\u0d3b\\u0d3c\\u0d3e-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4d\\u0d57\\u0d62\\u0d63\\u0d66-\\u0d6f\\u0d81-\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0de6-\\u0def\\u0df2\\u0df3\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0e50-\\u0e59\\u0eb1\\u0eb4-\\u0ebc\\u0ec8-\\u0ece\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e\\u0f3f\\u0f71-\\u0f84\\u0f86\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102b-\\u103e\\u1040-\\u1049\\u1056-\\u1059\\u105e-\\u1060\\u1062-\\u1064\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u1369-\\u1371\\u1712-\\u1715\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b4-\\u17d3\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u180f-\\u1819\\u18a9\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u194f\\u19d0-\\u19da\\u1a17-\\u1a1b\\u1a55-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1ab0-\\u1abd\\u1abf-\\u1ace\\u1b00-\\u1b04\\u1b34-\\u1b44\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1b82\\u1ba1-\\u1bad\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c24-\\u1c37\\u1c40-\\u1c49\\u1c50-\\u1c59\\u1cd0-\\u1cd2\\u1cd4-\\u1ce8\\u1ced\\u1cf4\\u1cf7-\\u1cf9\\u1dc0-\\u1dff\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2cef-\\u2cf1\\u2d7f\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\ua620-\\ua629\\ua66f\\ua674-\\ua67d\\ua69e\\ua69f\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua823-\\ua827\\ua82c\\ua880\\ua881\\ua8b4-\\ua8c5\\ua8d0-\\ua8d9\\ua8e0-\\ua8f1\\ua8ff-\\ua909\\ua926-\\ua92d\\ua947-\\ua953\\ua980-\\ua983\\ua9b3-\\ua9c0\\ua9d0-\\ua9d9\\ua9e5\\ua9f0-\\ua9f9\\uaa29-\\uaa36\\uaa43\\uaa4c\\uaa4d\\uaa50-\\uaa59\\uaa7b-\\uaa7d\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uaaeb-\\uaaef\\uaaf5\\uaaf6\\uabe3-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe2f\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f\";\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.js`.\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,68,310,10,21,11,7,25,5,2,41,2,8,70,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,349,41,7,1,79,28,11,0,9,21,43,17,47,20,28,22,13,52,58,1,3,0,14,44,33,24,27,35,30,0,3,0,9,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,20,1,64,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,21,2,31,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,14,0,72,26,38,6,186,43,117,63,32,7,3,0,3,7,2,1,2,23,16,0,2,0,95,7,3,38,17,0,2,0,29,0,11,39,8,0,22,0,12,45,20,0,19,72,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,16,0,2,12,2,33,125,0,80,921,103,110,18,195,2637,96,16,1071,18,5,4026,582,8634,568,8,30,18,78,18,29,19,47,17,3,32,20,6,18,689,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,1237,43,8,8936,3,2,6,2,1,2,290,16,0,30,2,3,0,15,3,9,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,1845,30,7,5,262,61,147,44,11,6,17,0,322,29,19,43,485,27,757,6,2,3,2,1,2,14,2,196,60,67,8,0,1205,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42719,33,4153,7,221,3,5761,15,7472,3104,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,370,1,81,2,71,10,50,3,123,2,54,14,32,10,3,1,11,3,46,10,8,0,46,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,2,11,83,11,7,0,3,0,158,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,71,5,2,1,3,3,2,0,2,1,13,9,120,6,3,6,4,0,29,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,10,1,2,0,49,6,4,4,14,9,5351,0,7,14,13835,9,87,9,39,4,60,6,26,9,1014,0,2,54,8,3,82,0,12,1,19628,1,4706,45,3,22,543,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,101,0,161,6,10,9,357,0,62,13,499,13,983,6,110,6,6,9,4759,9,787719,239];\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 {\n  defineAliasedType,\n  arrayOfType,\n  assertOneOf,\n  assertValueType,\n  validate,\n  validateArrayOfType,\n  validateOptional,\n  validateOptionalType,\n  validateType,\n} from \"./utils\";\n\nconst defineType = defineAliasedType(\"Flow\");\n\nconst defineInterfaceishType = (\n  name: \"DeclareClass\" | \"DeclareInterface\" | \"InterfaceDeclaration\",\n) => {\n  defineType(name, {\n    builder: [\"id\", \"typeParameters\", \"extends\", \"body\"],\n    visitor: [\n      \"id\",\n      \"typeParameters\",\n      \"extends\",\n      \"mixins\",\n      \"implements\",\n      \"body\",\n    ],\n    aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n    fields: {\n      id: validateType(\"Identifier\"),\n      typeParameters: validateOptionalType(\"TypeParameterDeclaration\"),\n      extends: validateOptional(arrayOfType(\"InterfaceExtends\")),\n      mixins: validateOptional(arrayOfType(\"InterfaceExtends\")),\n      implements: validateOptional(arrayOfType(\"ClassImplements\")),\n      body: validateType(\"ObjectTypeAnnotation\"),\n    },\n  });\n};\n\ndefineType(\"AnyTypeAnnotation\", {\n  aliases: [\"FlowType\", \"FlowBaseAnnotation\"],\n});\n\ndefineType(\"ArrayTypeAnnotation\", {\n  visitor: [\"elementType\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    elementType: validateType(\"FlowType\"),\n  },\n});\n\ndefineType(\"BooleanTypeAnnotation\", {\n  aliases: [\"FlowType\", \"FlowBaseAnnotation\"],\n});\n\ndefineType(\"BooleanLiteralTypeAnnotation\", {\n  builder: [\"value\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    value: validate(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"NullLiteralTypeAnnotation\", {\n  aliases: [\"FlowType\", \"FlowBaseAnnotation\"],\n});\n\ndefineType(\"ClassImplements\", {\n  visitor: [\"id\", \"typeParameters\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    typeParameters: validateOptionalType(\"TypeParameterInstantiation\"),\n  },\n});\n\ndefineInterfaceishType(\"DeclareClass\");\n\ndefineType(\"DeclareFunction\", {\n  visitor: [\"id\"],\n  aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    predicate: validateOptionalType(\"DeclaredPredicate\"),\n  },\n});\n\ndefineInterfaceishType(\"DeclareInterface\");\n\ndefineType(\"DeclareModule\", {\n  builder: [\"id\", \"body\", \"kind\"],\n  visitor: [\"id\", \"body\"],\n  aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n  fields: {\n    id: validateType([\"Identifier\", \"StringLiteral\"]),\n    body: validateType(\"BlockStatement\"),\n    kind: validateOptional(assertOneOf(\"CommonJS\", \"ES\")),\n  },\n});\n\ndefineType(\"DeclareModuleExports\", {\n  visitor: [\"typeAnnotation\"],\n  aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n  fields: {\n    typeAnnotation: validateType(\"TypeAnnotation\"),\n  },\n});\n\ndefineType(\"DeclareTypeAlias\", {\n  visitor: [\"id\", \"typeParameters\", \"right\"],\n  aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    typeParameters: validateOptionalType(\"TypeParameterDeclaration\"),\n    right: validateType(\"FlowType\"),\n  },\n});\n\ndefineType(\"DeclareOpaqueType\", {\n  visitor: [\"id\", \"typeParameters\", \"supertype\"],\n  aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    typeParameters: validateOptionalType(\"TypeParameterDeclaration\"),\n    supertype: validateOptionalType(\"FlowType\"),\n    impltype: validateOptionalType(\"FlowType\"),\n  },\n});\n\ndefineType(\"DeclareVariable\", {\n  visitor: [\"id\"],\n  aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n  },\n});\n\ndefineType(\"DeclareExportDeclaration\", {\n  visitor: [\"declaration\", \"specifiers\", \"source\"],\n  aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n  fields: {\n    declaration: validateOptionalType(\"Flow\"),\n    specifiers: validateOptional(\n      arrayOfType([\"ExportSpecifier\", \"ExportNamespaceSpecifier\"]),\n    ),\n    source: validateOptionalType(\"StringLiteral\"),\n    default: validateOptional(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"DeclareExportAllDeclaration\", {\n  visitor: [\"source\"],\n  aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n  fields: {\n    source: validateType(\"StringLiteral\"),\n    exportKind: validateOptional(assertOneOf(\"type\", \"value\")),\n  },\n});\n\ndefineType(\"DeclaredPredicate\", {\n  visitor: [\"value\"],\n  aliases: [\"FlowPredicate\"],\n  fields: {\n    value: validateType(\"Flow\"),\n  },\n});\n\ndefineType(\"ExistsTypeAnnotation\", {\n  aliases: [\"FlowType\"],\n});\n\ndefineType(\"FunctionTypeAnnotation\", {\n  visitor: [\"typeParameters\", \"params\", \"rest\", \"returnType\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    typeParameters: validateOptionalType(\"TypeParameterDeclaration\"),\n    params: validate(arrayOfType(\"FunctionTypeParam\")),\n    rest: validateOptionalType(\"FunctionTypeParam\"),\n    this: validateOptionalType(\"FunctionTypeParam\"),\n    returnType: validateType(\"FlowType\"),\n  },\n});\n\ndefineType(\"FunctionTypeParam\", {\n  visitor: [\"name\", \"typeAnnotation\"],\n  fields: {\n    name: validateOptionalType(\"Identifier\"),\n    typeAnnotation: validateType(\"FlowType\"),\n    optional: validateOptional(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"GenericTypeAnnotation\", {\n  visitor: [\"id\", \"typeParameters\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    id: validateType([\"Identifier\", \"QualifiedTypeIdentifier\"]),\n    typeParameters: validateOptionalType(\"TypeParameterInstantiation\"),\n  },\n});\n\ndefineType(\"InferredPredicate\", {\n  aliases: [\"FlowPredicate\"],\n});\n\ndefineType(\"InterfaceExtends\", {\n  visitor: [\"id\", \"typeParameters\"],\n  fields: {\n    id: validateType([\"Identifier\", \"QualifiedTypeIdentifier\"]),\n    typeParameters: validateOptionalType(\"TypeParameterInstantiation\"),\n  },\n});\n\ndefineInterfaceishType(\"InterfaceDeclaration\");\n\ndefineType(\"InterfaceTypeAnnotation\", {\n  visitor: [\"extends\", \"body\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    extends: validateOptional(arrayOfType(\"InterfaceExtends\")),\n    body: validateType(\"ObjectTypeAnnotation\"),\n  },\n});\n\ndefineType(\"IntersectionTypeAnnotation\", {\n  visitor: [\"types\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    types: validate(arrayOfType(\"FlowType\")),\n  },\n});\n\ndefineType(\"MixedTypeAnnotation\", {\n  aliases: [\"FlowType\", \"FlowBaseAnnotation\"],\n});\n\ndefineType(\"EmptyTypeAnnotation\", {\n  aliases: [\"FlowType\", \"FlowBaseAnnotation\"],\n});\n\ndefineType(\"NullableTypeAnnotation\", {\n  visitor: [\"typeAnnotation\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    typeAnnotation: validateType(\"FlowType\"),\n  },\n});\n\ndefineType(\"NumberLiteralTypeAnnotation\", {\n  builder: [\"value\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    value: validate(assertValueType(\"number\")),\n  },\n});\n\ndefineType(\"NumberTypeAnnotation\", {\n  aliases: [\"FlowType\", \"FlowBaseAnnotation\"],\n});\n\ndefineType(\"ObjectTypeAnnotation\", {\n  visitor: [\"properties\", \"indexers\", \"callProperties\", \"internalSlots\"],\n  aliases: [\"FlowType\"],\n  builder: [\n    \"properties\",\n    \"indexers\",\n    \"callProperties\",\n    \"internalSlots\",\n    \"exact\",\n  ],\n  fields: {\n    properties: validate(\n      arrayOfType([\"ObjectTypeProperty\", \"ObjectTypeSpreadProperty\"]),\n    ),\n    indexers: {\n      validate: arrayOfType(\"ObjectTypeIndexer\"),\n      optional: process.env.BABEL_8_BREAKING ? false : true,\n      default: [],\n    },\n    callProperties: {\n      validate: arrayOfType(\"ObjectTypeCallProperty\"),\n      optional: process.env.BABEL_8_BREAKING ? false : true,\n      default: [],\n    },\n    internalSlots: {\n      validate: arrayOfType(\"ObjectTypeInternalSlot\"),\n      optional: process.env.BABEL_8_BREAKING ? false : true,\n      default: [],\n    },\n    exact: {\n      validate: assertValueType(\"boolean\"),\n      default: false,\n    },\n    // If the inexact flag is present then this is an object type, and not a\n    // declare class, declare interface, or interface. If it is true, the\n    // object uses ... to express that it is inexact.\n    inexact: validateOptional(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"ObjectTypeInternalSlot\", {\n  visitor: [\"id\", \"value\", \"optional\", \"static\", \"method\"],\n  aliases: [\"UserWhitespacable\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    value: validateType(\"FlowType\"),\n    optional: validate(assertValueType(\"boolean\")),\n    static: validate(assertValueType(\"boolean\")),\n    method: validate(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"ObjectTypeCallProperty\", {\n  visitor: [\"value\"],\n  aliases: [\"UserWhitespacable\"],\n  fields: {\n    value: validateType(\"FlowType\"),\n    static: validate(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"ObjectTypeIndexer\", {\n  visitor: [\"id\", \"key\", \"value\", \"variance\"],\n  aliases: [\"UserWhitespacable\"],\n  fields: {\n    id: validateOptionalType(\"Identifier\"),\n    key: validateType(\"FlowType\"),\n    value: validateType(\"FlowType\"),\n    static: validate(assertValueType(\"boolean\")),\n    variance: validateOptionalType(\"Variance\"),\n  },\n});\n\ndefineType(\"ObjectTypeProperty\", {\n  visitor: [\"key\", \"value\", \"variance\"],\n  aliases: [\"UserWhitespacable\"],\n  fields: {\n    key: validateType([\"Identifier\", \"StringLiteral\"]),\n    value: validateType(\"FlowType\"),\n    kind: validate(assertOneOf(\"init\", \"get\", \"set\")),\n    static: validate(assertValueType(\"boolean\")),\n    proto: validate(assertValueType(\"boolean\")),\n    optional: validate(assertValueType(\"boolean\")),\n    variance: validateOptionalType(\"Variance\"),\n    method: validate(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"ObjectTypeSpreadProperty\", {\n  visitor: [\"argument\"],\n  aliases: [\"UserWhitespacable\"],\n  fields: {\n    argument: validateType(\"FlowType\"),\n  },\n});\n\ndefineType(\"OpaqueType\", {\n  visitor: [\"id\", \"typeParameters\", \"supertype\", \"impltype\"],\n  aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    typeParameters: validateOptionalType(\"TypeParameterDeclaration\"),\n    supertype: validateOptionalType(\"FlowType\"),\n    impltype: validateType(\"FlowType\"),\n  },\n});\n\ndefineType(\"QualifiedTypeIdentifier\", {\n  visitor: [\"id\", \"qualification\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    qualification: validateType([\"Identifier\", \"QualifiedTypeIdentifier\"]),\n  },\n});\n\ndefineType(\"StringLiteralTypeAnnotation\", {\n  builder: [\"value\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    value: validate(assertValueType(\"string\")),\n  },\n});\n\ndefineType(\"StringTypeAnnotation\", {\n  aliases: [\"FlowType\", \"FlowBaseAnnotation\"],\n});\n\ndefineType(\"SymbolTypeAnnotation\", {\n  aliases: [\"FlowType\", \"FlowBaseAnnotation\"],\n});\n\ndefineType(\"ThisTypeAnnotation\", {\n  aliases: [\"FlowType\", \"FlowBaseAnnotation\"],\n});\n\ndefineType(\"TupleTypeAnnotation\", {\n  visitor: [\"types\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    types: validate(arrayOfType(\"FlowType\")),\n  },\n});\n\ndefineType(\"TypeofTypeAnnotation\", {\n  visitor: [\"argument\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    argument: validateType(\"FlowType\"),\n  },\n});\n\ndefineType(\"TypeAlias\", {\n  visitor: [\"id\", \"typeParameters\", \"right\"],\n  aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    typeParameters: validateOptionalType(\"TypeParameterDeclaration\"),\n    right: validateType(\"FlowType\"),\n  },\n});\n\ndefineType(\"TypeAnnotation\", {\n  visitor: [\"typeAnnotation\"],\n  fields: {\n    typeAnnotation: validateType(\"FlowType\"),\n  },\n});\n\ndefineType(\"TypeCastExpression\", {\n  visitor: [\"expression\", \"typeAnnotation\"],\n  aliases: [\"ExpressionWrapper\", \"Expression\"],\n  fields: {\n    expression: validateType(\"Expression\"),\n    typeAnnotation: validateType(\"TypeAnnotation\"),\n  },\n});\n\ndefineType(\"TypeParameter\", {\n  visitor: [\"bound\", \"default\", \"variance\"],\n  fields: {\n    name: validate(assertValueType(\"string\")),\n    bound: validateOptionalType(\"TypeAnnotation\"),\n    default: validateOptionalType(\"FlowType\"),\n    variance: validateOptionalType(\"Variance\"),\n  },\n});\n\ndefineType(\"TypeParameterDeclaration\", {\n  visitor: [\"params\"],\n  fields: {\n    params: validate(arrayOfType(\"TypeParameter\")),\n  },\n});\n\ndefineType(\"TypeParameterInstantiation\", {\n  visitor: [\"params\"],\n  fields: {\n    params: validate(arrayOfType(\"FlowType\")),\n  },\n});\n\ndefineType(\"UnionTypeAnnotation\", {\n  visitor: [\"types\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    types: validate(arrayOfType(\"FlowType\")),\n  },\n});\n\ndefineType(\"Variance\", {\n  builder: [\"kind\"],\n  fields: {\n    kind: validate(assertOneOf(\"minus\", \"plus\")),\n  },\n});\n\ndefineType(\"VoidTypeAnnotation\", {\n  aliases: [\"FlowType\", \"FlowBaseAnnotation\"],\n});\n\n// Enums\ndefineType(\"EnumDeclaration\", {\n  aliases: [\"Statement\", \"Declaration\"],\n  visitor: [\"id\", \"body\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    body: validateType([\n      \"EnumBooleanBody\",\n      \"EnumNumberBody\",\n      \"EnumStringBody\",\n      \"EnumSymbolBody\",\n    ]),\n  },\n});\n\ndefineType(\"EnumBooleanBody\", {\n  aliases: [\"EnumBody\"],\n  visitor: [\"members\"],\n  fields: {\n    explicitType: validate(assertValueType(\"boolean\")),\n    members: validateArrayOfType(\"EnumBooleanMember\"),\n    hasUnknownMembers: validate(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"EnumNumberBody\", {\n  aliases: [\"EnumBody\"],\n  visitor: [\"members\"],\n  fields: {\n    explicitType: validate(assertValueType(\"boolean\")),\n    members: validateArrayOfType(\"EnumNumberMember\"),\n    hasUnknownMembers: validate(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"EnumStringBody\", {\n  aliases: [\"EnumBody\"],\n  visitor: [\"members\"],\n  fields: {\n    explicitType: validate(assertValueType(\"boolean\")),\n    members: validateArrayOfType([\"EnumStringMember\", \"EnumDefaultedMember\"]),\n    hasUnknownMembers: validate(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"EnumSymbolBody\", {\n  aliases: [\"EnumBody\"],\n  visitor: [\"members\"],\n  fields: {\n    members: validateArrayOfType(\"EnumDefaultedMember\"),\n    hasUnknownMembers: validate(assertValueType(\"boolean\")),\n  },\n});\n\ndefineType(\"EnumBooleanMember\", {\n  aliases: [\"EnumMember\"],\n  visitor: [\"id\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    init: validateType(\"BooleanLiteral\"),\n  },\n});\n\ndefineType(\"EnumNumberMember\", {\n  aliases: [\"EnumMember\"],\n  visitor: [\"id\", \"init\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    init: validateType(\"NumericLiteral\"),\n  },\n});\n\ndefineType(\"EnumStringMember\", {\n  aliases: [\"EnumMember\"],\n  visitor: [\"id\", \"init\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n    init: validateType(\"StringLiteral\"),\n  },\n});\n\ndefineType(\"EnumDefaultedMember\", {\n  aliases: [\"EnumMember\"],\n  visitor: [\"id\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n  },\n});\n\ndefineType(\"IndexedAccessType\", {\n  visitor: [\"objectType\", \"indexType\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    objectType: validateType(\"FlowType\"),\n    indexType: validateType(\"FlowType\"),\n  },\n});\n\ndefineType(\"OptionalIndexedAccessType\", {\n  visitor: [\"objectType\", \"indexType\"],\n  aliases: [\"FlowType\"],\n  fields: {\n    objectType: validateType(\"FlowType\"),\n    indexType: validateType(\"FlowType\"),\n    optional: validate(assertValueType(\"boolean\")),\n  },\n});\n","import {\n  defineAliasedType,\n  assertNodeType,\n  assertValueType,\n  chain,\n  assertEach,\n} from \"./utils\";\n\nconst defineType = defineAliasedType(\"JSX\");\n\ndefineType(\"JSXAttribute\", {\n  visitor: [\"name\", \"value\"],\n  aliases: [\"Immutable\"],\n  fields: {\n    name: {\n      validate: assertNodeType(\"JSXIdentifier\", \"JSXNamespacedName\"),\n    },\n    value: {\n      optional: true,\n      validate: assertNodeType(\n        \"JSXElement\",\n        \"JSXFragment\",\n        \"StringLiteral\",\n        \"JSXExpressionContainer\",\n      ),\n    },\n  },\n});\n\ndefineType(\"JSXClosingElement\", {\n  visitor: [\"name\"],\n  aliases: [\"Immutable\"],\n  fields: {\n    name: {\n      validate: assertNodeType(\n        \"JSXIdentifier\",\n        \"JSXMemberExpression\",\n        \"JSXNamespacedName\",\n      ),\n    },\n  },\n});\n\ndefineType(\"JSXElement\", {\n  builder: process.env.BABEL_8_BREAKING\n    ? [\"openingElement\", \"closingElement\", \"children\"]\n    : [\"openingElement\", \"closingElement\", \"children\", \"selfClosing\"],\n  visitor: [\"openingElement\", \"children\", \"closingElement\"],\n  aliases: [\"Immutable\", \"Expression\"],\n  fields: {\n    openingElement: {\n      validate: assertNodeType(\"JSXOpeningElement\"),\n    },\n    closingElement: {\n      optional: true,\n      validate: assertNodeType(\"JSXClosingElement\"),\n    },\n    children: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeType(\n            \"JSXText\",\n            \"JSXExpressionContainer\",\n            \"JSXSpreadChild\",\n            \"JSXElement\",\n            \"JSXFragment\",\n          ),\n        ),\n      ),\n    },\n    ...(process.env.BABEL_8_BREAKING\n      ? {}\n      : {\n          selfClosing: {\n            validate: assertValueType(\"boolean\"),\n            optional: true,\n          },\n        }),\n  },\n});\n\ndefineType(\"JSXEmptyExpression\", {});\n\ndefineType(\"JSXExpressionContainer\", {\n  visitor: [\"expression\"],\n  aliases: [\"Immutable\"],\n  fields: {\n    expression: {\n      validate: assertNodeType(\"Expression\", \"JSXEmptyExpression\"),\n    },\n  },\n});\n\ndefineType(\"JSXSpreadChild\", {\n  visitor: [\"expression\"],\n  aliases: [\"Immutable\"],\n  fields: {\n    expression: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n});\n\ndefineType(\"JSXIdentifier\", {\n  builder: [\"name\"],\n  fields: {\n    name: {\n      validate: assertValueType(\"string\"),\n    },\n  },\n});\n\ndefineType(\"JSXMemberExpression\", {\n  visitor: [\"object\", \"property\"],\n  fields: {\n    object: {\n      validate: assertNodeType(\"JSXMemberExpression\", \"JSXIdentifier\"),\n    },\n    property: {\n      validate: assertNodeType(\"JSXIdentifier\"),\n    },\n  },\n});\n\ndefineType(\"JSXNamespacedName\", {\n  visitor: [\"namespace\", \"name\"],\n  fields: {\n    namespace: {\n      validate: assertNodeType(\"JSXIdentifier\"),\n    },\n    name: {\n      validate: assertNodeType(\"JSXIdentifier\"),\n    },\n  },\n});\n\ndefineType(\"JSXOpeningElement\", {\n  builder: [\"name\", \"attributes\", \"selfClosing\"],\n  visitor: [\"name\", \"attributes\"],\n  aliases: [\"Immutable\"],\n  fields: {\n    name: {\n      validate: assertNodeType(\n        \"JSXIdentifier\",\n        \"JSXMemberExpression\",\n        \"JSXNamespacedName\",\n      ),\n    },\n    selfClosing: {\n      default: false,\n    },\n    attributes: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"JSXAttribute\", \"JSXSpreadAttribute\")),\n      ),\n    },\n    typeParameters: {\n      validate: assertNodeType(\n        \"TypeParameterInstantiation\",\n        \"TSTypeParameterInstantiation\",\n      ),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"JSXSpreadAttribute\", {\n  visitor: [\"argument\"],\n  fields: {\n    argument: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n});\n\ndefineType(\"JSXText\", {\n  aliases: [\"Immutable\"],\n  builder: [\"value\"],\n  fields: {\n    value: {\n      validate: assertValueType(\"string\"),\n    },\n  },\n});\n\ndefineType(\"JSXFragment\", {\n  builder: [\"openingFragment\", \"closingFragment\", \"children\"],\n  visitor: [\"openingFragment\", \"children\", \"closingFragment\"],\n  aliases: [\"Immutable\", \"Expression\"],\n  fields: {\n    openingFragment: {\n      validate: assertNodeType(\"JSXOpeningFragment\"),\n    },\n    closingFragment: {\n      validate: assertNodeType(\"JSXClosingFragment\"),\n    },\n    children: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(\n          assertNodeType(\n            \"JSXText\",\n            \"JSXExpressionContainer\",\n            \"JSXSpreadChild\",\n            \"JSXElement\",\n            \"JSXFragment\",\n          ),\n        ),\n      ),\n    },\n  },\n});\n\ndefineType(\"JSXOpeningFragment\", {\n  aliases: [\"Immutable\"],\n});\n\ndefineType(\"JSXClosingFragment\", {\n  aliases: [\"Immutable\"],\n});\n","import {\n  defineAliasedType,\n  assertNodeType,\n  assertOneOf,\n  assertValueType,\n} from \"./utils\";\nimport { PLACEHOLDERS } from \"./placeholders\";\n\nconst defineType = defineAliasedType(\"Miscellaneous\");\n\nif (!process.env.BABEL_8_BREAKING) {\n  defineType(\"Noop\", {\n    visitor: [],\n  });\n}\n\ndefineType(\"Placeholder\", {\n  visitor: [],\n  builder: [\"expectedNode\", \"name\"],\n  // aliases: [], defined in placeholders.js\n  fields: {\n    name: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n    expectedNode: {\n      validate: assertOneOf(...PLACEHOLDERS),\n    },\n  },\n});\n\ndefineType(\"V8IntrinsicIdentifier\", {\n  builder: [\"name\"],\n  fields: {\n    name: {\n      validate: assertValueType(\"string\"),\n    },\n  },\n});\n","import defineType, {\n  assertEach,\n  assertNodeType,\n  assertValueType,\n  chain,\n} from \"./utils\";\n\ndefineType(\"ArgumentPlaceholder\", {});\n\ndefineType(\"BindExpression\", {\n  visitor: [\"object\", \"callee\"],\n  aliases: [\"Expression\"],\n  fields: !process.env.BABEL_TYPES_8_BREAKING\n    ? {\n        object: {\n          validate: Object.assign(() => {}, {\n            oneOfNodeTypes: [\"Expression\"],\n          }),\n        },\n        callee: {\n          validate: Object.assign(() => {}, {\n            oneOfNodeTypes: [\"Expression\"],\n          }),\n        },\n      }\n    : {\n        object: {\n          validate: assertNodeType(\"Expression\"),\n        },\n        callee: {\n          validate: assertNodeType(\"Expression\"),\n        },\n      },\n});\n\ndefineType(\"ImportAttribute\", {\n  visitor: [\"key\", \"value\"],\n  fields: {\n    key: {\n      validate: assertNodeType(\"Identifier\", \"StringLiteral\"),\n    },\n    value: {\n      validate: assertNodeType(\"StringLiteral\"),\n    },\n  },\n});\n\ndefineType(\"Decorator\", {\n  visitor: [\"expression\"],\n  fields: {\n    expression: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n});\n\ndefineType(\"DoExpression\", {\n  visitor: [\"body\"],\n  builder: [\"body\", \"async\"],\n  aliases: [\"Expression\"],\n  fields: {\n    body: {\n      validate: assertNodeType(\"BlockStatement\"),\n    },\n    async: {\n      validate: assertValueType(\"boolean\"),\n      default: false,\n    },\n  },\n});\n\ndefineType(\"ExportDefaultSpecifier\", {\n  visitor: [\"exported\"],\n  aliases: [\"ModuleSpecifier\"],\n  fields: {\n    exported: {\n      validate: assertNodeType(\"Identifier\"),\n    },\n  },\n});\n\ndefineType(\"RecordExpression\", {\n  visitor: [\"properties\"],\n  aliases: [\"Expression\"],\n  fields: {\n    properties: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"ObjectProperty\", \"SpreadElement\")),\n      ),\n    },\n  },\n});\n\ndefineType(\"TupleExpression\", {\n  fields: {\n    elements: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Expression\", \"SpreadElement\")),\n      ),\n      default: [],\n    },\n  },\n  visitor: [\"elements\"],\n  aliases: [\"Expression\"],\n});\n\ndefineType(\"DecimalLiteral\", {\n  builder: [\"value\"],\n  fields: {\n    value: {\n      validate: assertValueType(\"string\"),\n    },\n  },\n  aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"],\n});\n\n// https://github.com/tc39/proposal-js-module-blocks\ndefineType(\"ModuleExpression\", {\n  visitor: [\"body\"],\n  fields: {\n    body: {\n      validate: assertNodeType(\"Program\"),\n    },\n  },\n  aliases: [\"Expression\"],\n});\n\n// https://github.com/tc39/proposal-pipeline-operator\n// https://github.com/js-choi/proposal-hack-pipes\ndefineType(\"TopicReference\", {\n  aliases: [\"Expression\"],\n});\n\n// https://github.com/tc39/proposal-pipeline-operator\n// https://github.com/js-choi/proposal-smart-pipes\ndefineType(\"PipelineTopicExpression\", {\n  builder: [\"expression\"],\n  visitor: [\"expression\"],\n  fields: {\n    expression: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n  aliases: [\"Expression\"],\n});\n\ndefineType(\"PipelineBareFunction\", {\n  builder: [\"callee\"],\n  visitor: [\"callee\"],\n  fields: {\n    callee: {\n      validate: assertNodeType(\"Expression\"),\n    },\n  },\n  aliases: [\"Expression\"],\n});\n\ndefineType(\"PipelinePrimaryTopicReference\", {\n  aliases: [\"Expression\"],\n});\n","import {\n  defineAliasedType,\n  arrayOfType,\n  assertEach,\n  assertNodeType,\n  assertOneOf,\n  assertValueType,\n  chain,\n  validate,\n  validateArrayOfType,\n  validateOptional,\n  validateOptionalType,\n  validateType,\n} from \"./utils\";\nimport {\n  functionDeclarationCommon,\n  classMethodOrDeclareMethodCommon,\n} from \"./core\";\nimport is from \"../validators/is\";\n\nconst defineType = defineAliasedType(\"TypeScript\");\n\nconst bool = assertValueType(\"boolean\");\n\nconst tSFunctionTypeAnnotationCommon = () => ({\n  returnType: {\n    validate: process.env.BABEL_8_BREAKING\n      ? assertNodeType(\"TSTypeAnnotation\")\n      : // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n        assertNodeType(\"TSTypeAnnotation\", \"Noop\"),\n    optional: true,\n  },\n  typeParameters: {\n    validate: process.env.BABEL_8_BREAKING\n      ? assertNodeType(\"TSTypeParameterDeclaration\")\n      : // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST\n        assertNodeType(\"TSTypeParameterDeclaration\", \"Noop\"),\n    optional: true,\n  },\n});\n\ndefineType(\"TSParameterProperty\", {\n  aliases: [\"LVal\"], // TODO: This isn't usable in general as an LVal. Should have a \"Parameter\" alias.\n  visitor: [\"parameter\"],\n  fields: {\n    accessibility: {\n      validate: assertOneOf(\"public\", \"private\", \"protected\"),\n      optional: true,\n    },\n    readonly: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    parameter: {\n      validate: assertNodeType(\"Identifier\", \"AssignmentPattern\"),\n    },\n    override: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    decorators: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"Decorator\")),\n      ),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"TSDeclareFunction\", {\n  aliases: [\"Statement\", \"Declaration\"],\n  visitor: [\"id\", \"typeParameters\", \"params\", \"returnType\"],\n  fields: {\n    ...functionDeclarationCommon(),\n    ...tSFunctionTypeAnnotationCommon(),\n  },\n});\n\ndefineType(\"TSDeclareMethod\", {\n  visitor: [\"decorators\", \"key\", \"typeParameters\", \"params\", \"returnType\"],\n  fields: {\n    ...classMethodOrDeclareMethodCommon(),\n    ...tSFunctionTypeAnnotationCommon(),\n  },\n});\n\ndefineType(\"TSQualifiedName\", {\n  aliases: [\"TSEntityName\"],\n  visitor: [\"left\", \"right\"],\n  fields: {\n    left: validateType(\"TSEntityName\"),\n    right: validateType(\"Identifier\"),\n  },\n});\n\nconst signatureDeclarationCommon = () => ({\n  typeParameters: validateOptionalType(\"TSTypeParameterDeclaration\"),\n  [process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\"]: validateArrayOfType(\n    [\"Identifier\", \"RestElement\"],\n  ),\n  [process.env.BABEL_8_BREAKING ? \"returnType\" : \"typeAnnotation\"]:\n    validateOptionalType(\"TSTypeAnnotation\"),\n});\n\nconst callConstructSignatureDeclaration = {\n  aliases: [\"TSTypeElement\"],\n  visitor: [\n    \"typeParameters\",\n    process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\",\n    process.env.BABEL_8_BREAKING ? \"returnType\" : \"typeAnnotation\",\n  ],\n  fields: signatureDeclarationCommon(),\n};\n\ndefineType(\"TSCallSignatureDeclaration\", callConstructSignatureDeclaration);\ndefineType(\n  \"TSConstructSignatureDeclaration\",\n  callConstructSignatureDeclaration,\n);\n\nconst namedTypeElementCommon = () => ({\n  key: validateType(\"Expression\"),\n  computed: { default: false },\n  optional: validateOptional(bool),\n});\n\ndefineType(\"TSPropertySignature\", {\n  aliases: [\"TSTypeElement\"],\n  visitor: [\"key\", \"typeAnnotation\", \"initializer\"],\n  fields: {\n    ...namedTypeElementCommon(),\n    readonly: validateOptional(bool),\n    typeAnnotation: validateOptionalType(\"TSTypeAnnotation\"),\n    initializer: validateOptionalType(\"Expression\"),\n    kind: {\n      validate: assertOneOf(\"get\", \"set\"),\n    },\n  },\n});\n\ndefineType(\"TSMethodSignature\", {\n  aliases: [\"TSTypeElement\"],\n  visitor: [\n    \"key\",\n    \"typeParameters\",\n    process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\",\n    process.env.BABEL_8_BREAKING ? \"returnType\" : \"typeAnnotation\",\n  ],\n  fields: {\n    ...signatureDeclarationCommon(),\n    ...namedTypeElementCommon(),\n    kind: {\n      validate: assertOneOf(\"method\", \"get\", \"set\"),\n    },\n  },\n});\n\ndefineType(\"TSIndexSignature\", {\n  aliases: [\"TSTypeElement\"],\n  visitor: [\"parameters\", \"typeAnnotation\"],\n  fields: {\n    readonly: validateOptional(bool),\n    static: validateOptional(bool),\n    parameters: validateArrayOfType(\"Identifier\"), // Length must be 1\n    typeAnnotation: validateOptionalType(\"TSTypeAnnotation\"),\n  },\n});\n\nconst tsKeywordTypes = [\n  \"TSAnyKeyword\",\n  \"TSBooleanKeyword\",\n  \"TSBigIntKeyword\",\n  \"TSIntrinsicKeyword\",\n  \"TSNeverKeyword\",\n  \"TSNullKeyword\",\n  \"TSNumberKeyword\",\n  \"TSObjectKeyword\",\n  \"TSStringKeyword\",\n  \"TSSymbolKeyword\",\n  \"TSUndefinedKeyword\",\n  \"TSUnknownKeyword\",\n  \"TSVoidKeyword\",\n] as const;\n\nfor (const type of tsKeywordTypes) {\n  defineType(type, {\n    aliases: [\"TSType\", \"TSBaseType\"],\n    visitor: [],\n    fields: {},\n  });\n}\n\ndefineType(\"TSThisType\", {\n  aliases: [\"TSType\", \"TSBaseType\"],\n  visitor: [],\n  fields: {},\n});\n\nconst fnOrCtrBase = {\n  aliases: [\"TSType\"],\n  visitor: [\n    \"typeParameters\",\n    process.env.BABEL_8_BREAKING ? \"params\" : \"parameters\",\n    process.env.BABEL_8_BREAKING ? \"returnType\" : \"typeAnnotation\",\n  ],\n};\n\ndefineType(\"TSFunctionType\", {\n  ...fnOrCtrBase,\n  fields: signatureDeclarationCommon(),\n});\ndefineType(\"TSConstructorType\", {\n  ...fnOrCtrBase,\n  fields: {\n    ...signatureDeclarationCommon(),\n    abstract: validateOptional(bool),\n  },\n});\n\ndefineType(\"TSTypeReference\", {\n  aliases: [\"TSType\"],\n  visitor: [\"typeName\", \"typeParameters\"],\n  fields: {\n    typeName: validateType(\"TSEntityName\"),\n    typeParameters: validateOptionalType(\"TSTypeParameterInstantiation\"),\n  },\n});\n\ndefineType(\"TSTypePredicate\", {\n  aliases: [\"TSType\"],\n  visitor: [\"parameterName\", \"typeAnnotation\"],\n  builder: [\"parameterName\", \"typeAnnotation\", \"asserts\"],\n  fields: {\n    parameterName: validateType([\"Identifier\", \"TSThisType\"]),\n    typeAnnotation: validateOptionalType(\"TSTypeAnnotation\"),\n    asserts: validateOptional(bool),\n  },\n});\n\ndefineType(\"TSTypeQuery\", {\n  aliases: [\"TSType\"],\n  visitor: [\"exprName\", \"typeParameters\"],\n  fields: {\n    exprName: validateType([\"TSEntityName\", \"TSImportType\"]),\n    typeParameters: validateOptionalType(\"TSTypeParameterInstantiation\"),\n  },\n});\n\ndefineType(\"TSTypeLiteral\", {\n  aliases: [\"TSType\"],\n  visitor: [\"members\"],\n  fields: {\n    members: validateArrayOfType(\"TSTypeElement\"),\n  },\n});\n\ndefineType(\"TSArrayType\", {\n  aliases: [\"TSType\"],\n  visitor: [\"elementType\"],\n  fields: {\n    elementType: validateType(\"TSType\"),\n  },\n});\n\ndefineType(\"TSTupleType\", {\n  aliases: [\"TSType\"],\n  visitor: [\"elementTypes\"],\n  fields: {\n    elementTypes: validateArrayOfType([\"TSType\", \"TSNamedTupleMember\"]),\n  },\n});\n\ndefineType(\"TSOptionalType\", {\n  aliases: [\"TSType\"],\n  visitor: [\"typeAnnotation\"],\n  fields: {\n    typeAnnotation: validateType(\"TSType\"),\n  },\n});\n\ndefineType(\"TSRestType\", {\n  aliases: [\"TSType\"],\n  visitor: [\"typeAnnotation\"],\n  fields: {\n    typeAnnotation: validateType(\"TSType\"),\n  },\n});\n\ndefineType(\"TSNamedTupleMember\", {\n  visitor: [\"label\", \"elementType\"],\n  builder: [\"label\", \"elementType\", \"optional\"],\n  fields: {\n    label: validateType(\"Identifier\"),\n    optional: {\n      validate: bool,\n      default: false,\n    },\n    elementType: validateType(\"TSType\"),\n  },\n});\n\nconst unionOrIntersection = {\n  aliases: [\"TSType\"],\n  visitor: [\"types\"],\n  fields: {\n    types: validateArrayOfType(\"TSType\"),\n  },\n};\n\ndefineType(\"TSUnionType\", unionOrIntersection);\ndefineType(\"TSIntersectionType\", unionOrIntersection);\n\ndefineType(\"TSConditionalType\", {\n  aliases: [\"TSType\"],\n  visitor: [\"checkType\", \"extendsType\", \"trueType\", \"falseType\"],\n  fields: {\n    checkType: validateType(\"TSType\"),\n    extendsType: validateType(\"TSType\"),\n    trueType: validateType(\"TSType\"),\n    falseType: validateType(\"TSType\"),\n  },\n});\n\ndefineType(\"TSInferType\", {\n  aliases: [\"TSType\"],\n  visitor: [\"typeParameter\"],\n  fields: {\n    typeParameter: validateType(\"TSTypeParameter\"),\n  },\n});\n\ndefineType(\"TSParenthesizedType\", {\n  aliases: [\"TSType\"],\n  visitor: [\"typeAnnotation\"],\n  fields: {\n    typeAnnotation: validateType(\"TSType\"),\n  },\n});\n\ndefineType(\"TSTypeOperator\", {\n  aliases: [\"TSType\"],\n  visitor: [\"typeAnnotation\"],\n  fields: {\n    operator: validate(assertValueType(\"string\")),\n    typeAnnotation: validateType(\"TSType\"),\n  },\n});\n\ndefineType(\"TSIndexedAccessType\", {\n  aliases: [\"TSType\"],\n  visitor: [\"objectType\", \"indexType\"],\n  fields: {\n    objectType: validateType(\"TSType\"),\n    indexType: validateType(\"TSType\"),\n  },\n});\n\ndefineType(\"TSMappedType\", {\n  aliases: [\"TSType\"],\n  visitor: [\"typeParameter\", \"typeAnnotation\", \"nameType\"],\n  fields: {\n    readonly: validateOptional(assertOneOf(true, false, \"+\", \"-\")),\n    typeParameter: validateType(\"TSTypeParameter\"),\n    optional: validateOptional(assertOneOf(true, false, \"+\", \"-\")),\n    typeAnnotation: validateOptionalType(\"TSType\"),\n    nameType: validateOptionalType(\"TSType\"),\n  },\n});\n\ndefineType(\"TSLiteralType\", {\n  aliases: [\"TSType\", \"TSBaseType\"],\n  visitor: [\"literal\"],\n  fields: {\n    literal: {\n      validate: (function () {\n        const unaryExpression = assertNodeType(\n          \"NumericLiteral\",\n          \"BigIntLiteral\",\n        );\n        const unaryOperator = assertOneOf(\"-\");\n\n        const literal = assertNodeType(\n          \"NumericLiteral\",\n          \"StringLiteral\",\n          \"BooleanLiteral\",\n          \"BigIntLiteral\",\n          \"TemplateLiteral\",\n        );\n        function validator(parent: any, key: string, node: any) {\n          // type A = -1 | 1;\n          if (is(\"UnaryExpression\", node)) {\n            // check operator first\n            unaryOperator(node, \"operator\", node.operator);\n            unaryExpression(node, \"argument\", node.argument);\n          } else {\n            // type A = 'foo' | 'bar' | false | 1;\n            literal(parent, key, node);\n          }\n        }\n\n        validator.oneOfNodeTypes = [\n          \"NumericLiteral\",\n          \"StringLiteral\",\n          \"BooleanLiteral\",\n          \"BigIntLiteral\",\n          \"TemplateLiteral\",\n          \"UnaryExpression\",\n        ];\n\n        return validator;\n      })(),\n    },\n  },\n});\n\ndefineType(\"TSExpressionWithTypeArguments\", {\n  aliases: [\"TSType\"],\n  visitor: [\"expression\", \"typeParameters\"],\n  fields: {\n    expression: validateType(\"TSEntityName\"),\n    typeParameters: validateOptionalType(\"TSTypeParameterInstantiation\"),\n  },\n});\n\ndefineType(\"TSInterfaceDeclaration\", {\n  // \"Statement\" alias prevents a semicolon from appearing after it in an export declaration.\n  aliases: [\"Statement\", \"Declaration\"],\n  visitor: [\"id\", \"typeParameters\", \"extends\", \"body\"],\n  fields: {\n    declare: validateOptional(bool),\n    id: validateType(\"Identifier\"),\n    typeParameters: validateOptionalType(\"TSTypeParameterDeclaration\"),\n    extends: validateOptional(arrayOfType(\"TSExpressionWithTypeArguments\")),\n    body: validateType(\"TSInterfaceBody\"),\n  },\n});\n\ndefineType(\"TSInterfaceBody\", {\n  visitor: [\"body\"],\n  fields: {\n    body: validateArrayOfType(\"TSTypeElement\"),\n  },\n});\n\ndefineType(\"TSTypeAliasDeclaration\", {\n  aliases: [\"Statement\", \"Declaration\"],\n  visitor: [\"id\", \"typeParameters\", \"typeAnnotation\"],\n  fields: {\n    declare: validateOptional(bool),\n    id: validateType(\"Identifier\"),\n    typeParameters: validateOptionalType(\"TSTypeParameterDeclaration\"),\n    typeAnnotation: validateType(\"TSType\"),\n  },\n});\n\ndefineType(\"TSInstantiationExpression\", {\n  aliases: [\"Expression\"],\n  visitor: [\"expression\", \"typeParameters\"],\n  fields: {\n    expression: validateType(\"Expression\"),\n    typeParameters: validateOptionalType(\"TSTypeParameterInstantiation\"),\n  },\n});\n\nconst TSTypeExpression = {\n  aliases: [\"Expression\", \"LVal\", \"PatternLike\"],\n  visitor: [\"expression\", \"typeAnnotation\"],\n  fields: {\n    expression: validateType(\"Expression\"),\n    typeAnnotation: validateType(\"TSType\"),\n  },\n};\n\ndefineType(\"TSAsExpression\", TSTypeExpression);\ndefineType(\"TSSatisfiesExpression\", TSTypeExpression);\n\ndefineType(\"TSTypeAssertion\", {\n  aliases: [\"Expression\", \"LVal\", \"PatternLike\"],\n  visitor: [\"typeAnnotation\", \"expression\"],\n  fields: {\n    typeAnnotation: validateType(\"TSType\"),\n    expression: validateType(\"Expression\"),\n  },\n});\n\ndefineType(\"TSEnumDeclaration\", {\n  // \"Statement\" alias prevents a semicolon from appearing after it in an export declaration.\n  aliases: [\"Statement\", \"Declaration\"],\n  visitor: [\"id\", \"members\"],\n  fields: {\n    declare: validateOptional(bool),\n    const: validateOptional(bool),\n    id: validateType(\"Identifier\"),\n    members: validateArrayOfType(\"TSEnumMember\"),\n    initializer: validateOptionalType(\"Expression\"),\n  },\n});\n\ndefineType(\"TSEnumMember\", {\n  visitor: [\"id\", \"initializer\"],\n  fields: {\n    id: validateType([\"Identifier\", \"StringLiteral\"]),\n    initializer: validateOptionalType(\"Expression\"),\n  },\n});\n\ndefineType(\"TSModuleDeclaration\", {\n  aliases: [\"Statement\", \"Declaration\"],\n  visitor: [\"id\", \"body\"],\n  fields: {\n    declare: validateOptional(bool),\n    global: validateOptional(bool),\n    id: validateType([\"Identifier\", \"StringLiteral\"]),\n    body: validateType([\"TSModuleBlock\", \"TSModuleDeclaration\"]),\n  },\n});\n\ndefineType(\"TSModuleBlock\", {\n  aliases: [\"Scopable\", \"Block\", \"BlockParent\", \"FunctionParent\"],\n  visitor: [\"body\"],\n  fields: {\n    body: validateArrayOfType(\"Statement\"),\n  },\n});\n\ndefineType(\"TSImportType\", {\n  aliases: [\"TSType\"],\n  visitor: [\"argument\", \"qualifier\", \"typeParameters\"],\n  fields: {\n    argument: validateType(\"StringLiteral\"),\n    qualifier: validateOptionalType(\"TSEntityName\"),\n    typeParameters: validateOptionalType(\"TSTypeParameterInstantiation\"),\n  },\n});\n\ndefineType(\"TSImportEqualsDeclaration\", {\n  aliases: [\"Statement\"],\n  visitor: [\"id\", \"moduleReference\"],\n  fields: {\n    isExport: validate(bool),\n    id: validateType(\"Identifier\"),\n    moduleReference: validateType([\n      \"TSEntityName\",\n      \"TSExternalModuleReference\",\n    ]),\n    importKind: {\n      validate: assertOneOf(\"type\", \"value\"),\n      optional: true,\n    },\n  },\n});\n\ndefineType(\"TSExternalModuleReference\", {\n  visitor: [\"expression\"],\n  fields: {\n    expression: validateType(\"StringLiteral\"),\n  },\n});\n\ndefineType(\"TSNonNullExpression\", {\n  aliases: [\"Expression\", \"LVal\", \"PatternLike\"],\n  visitor: [\"expression\"],\n  fields: {\n    expression: validateType(\"Expression\"),\n  },\n});\n\ndefineType(\"TSExportAssignment\", {\n  aliases: [\"Statement\"],\n  visitor: [\"expression\"],\n  fields: {\n    expression: validateType(\"Expression\"),\n  },\n});\n\ndefineType(\"TSNamespaceExportDeclaration\", {\n  aliases: [\"Statement\"],\n  visitor: [\"id\"],\n  fields: {\n    id: validateType(\"Identifier\"),\n  },\n});\n\ndefineType(\"TSTypeAnnotation\", {\n  visitor: [\"typeAnnotation\"],\n  fields: {\n    typeAnnotation: {\n      validate: assertNodeType(\"TSType\"),\n    },\n  },\n});\n\ndefineType(\"TSTypeParameterInstantiation\", {\n  visitor: [\"params\"],\n  fields: {\n    params: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"TSType\")),\n      ),\n    },\n  },\n});\n\ndefineType(\"TSTypeParameterDeclaration\", {\n  visitor: [\"params\"],\n  fields: {\n    params: {\n      validate: chain(\n        assertValueType(\"array\"),\n        assertEach(assertNodeType(\"TSTypeParameter\")),\n      ),\n    },\n  },\n});\n\ndefineType(\"TSTypeParameter\", {\n  builder: [\"constraint\", \"default\", \"name\"],\n  visitor: [\"constraint\", \"default\"],\n  fields: {\n    name: {\n      validate: !process.env.BABEL_8_BREAKING\n        ? assertValueType(\"string\")\n        : assertNodeType(\"Identifier\"),\n    },\n    in: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    out: {\n      validate: assertValueType(\"boolean\"),\n      optional: true,\n    },\n    constraint: {\n      validate: assertNodeType(\"TSType\"),\n      optional: true,\n    },\n    default: {\n      validate: assertNodeType(\"TSType\"),\n      optional: true,\n    },\n  },\n});\n","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty;","import isNode from \"../validators/isNode\";\nimport type * as t from \"..\";\n\nexport default function assertNode(node?: any): asserts node is t.Node {\n  if (!isNode(node)) {\n    const type = node?.type ?? JSON.stringify(node);\n    throw new TypeError(`Not a valid node of type \"${type}\"`);\n  }\n}\n","/*\n * This file is auto-generated! Do not modify it directly.\n * To re-generate run 'make build'\n */\nimport is from \"../../validators/is\";\nimport type * as t from \"../..\";\n\nfunction assert(type: string, node: any, opts?: any): void {\n  if (!is(type, node, opts)) {\n    throw new Error(\n      `Expected type \"${type}\" with option ${JSON.stringify(opts)}, ` +\n        `but instead got \"${node.type}\".`,\n    );\n  }\n}\n\nexport function assertArrayExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ArrayExpression {\n  assert(\"ArrayExpression\", node, opts);\n}\nexport function assertAssignmentExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.AssignmentExpression {\n  assert(\"AssignmentExpression\", node, opts);\n}\nexport function assertBinaryExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.BinaryExpression {\n  assert(\"BinaryExpression\", node, opts);\n}\nexport function assertInterpreterDirective(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.InterpreterDirective {\n  assert(\"InterpreterDirective\", node, opts);\n}\nexport function assertDirective(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Directive {\n  assert(\"Directive\", node, opts);\n}\nexport function assertDirectiveLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DirectiveLiteral {\n  assert(\"DirectiveLiteral\", node, opts);\n}\nexport function assertBlockStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.BlockStatement {\n  assert(\"BlockStatement\", node, opts);\n}\nexport function assertBreakStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.BreakStatement {\n  assert(\"BreakStatement\", node, opts);\n}\nexport function assertCallExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.CallExpression {\n  assert(\"CallExpression\", node, opts);\n}\nexport function assertCatchClause(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.CatchClause {\n  assert(\"CatchClause\", node, opts);\n}\nexport function assertConditionalExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ConditionalExpression {\n  assert(\"ConditionalExpression\", node, opts);\n}\nexport function assertContinueStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ContinueStatement {\n  assert(\"ContinueStatement\", node, opts);\n}\nexport function assertDebuggerStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DebuggerStatement {\n  assert(\"DebuggerStatement\", node, opts);\n}\nexport function assertDoWhileStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DoWhileStatement {\n  assert(\"DoWhileStatement\", node, opts);\n}\nexport function assertEmptyStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EmptyStatement {\n  assert(\"EmptyStatement\", node, opts);\n}\nexport function assertExpressionStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ExpressionStatement {\n  assert(\"ExpressionStatement\", node, opts);\n}\nexport function assertFile(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.File {\n  assert(\"File\", node, opts);\n}\nexport function assertForInStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ForInStatement {\n  assert(\"ForInStatement\", node, opts);\n}\nexport function assertForStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ForStatement {\n  assert(\"ForStatement\", node, opts);\n}\nexport function assertFunctionDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.FunctionDeclaration {\n  assert(\"FunctionDeclaration\", node, opts);\n}\nexport function assertFunctionExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.FunctionExpression {\n  assert(\"FunctionExpression\", node, opts);\n}\nexport function assertIdentifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Identifier {\n  assert(\"Identifier\", node, opts);\n}\nexport function assertIfStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.IfStatement {\n  assert(\"IfStatement\", node, opts);\n}\nexport function assertLabeledStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.LabeledStatement {\n  assert(\"LabeledStatement\", node, opts);\n}\nexport function assertStringLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.StringLiteral {\n  assert(\"StringLiteral\", node, opts);\n}\nexport function assertNumericLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.NumericLiteral {\n  assert(\"NumericLiteral\", node, opts);\n}\nexport function assertNullLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.NullLiteral {\n  assert(\"NullLiteral\", node, opts);\n}\nexport function assertBooleanLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.BooleanLiteral {\n  assert(\"BooleanLiteral\", node, opts);\n}\nexport function assertRegExpLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.RegExpLiteral {\n  assert(\"RegExpLiteral\", node, opts);\n}\nexport function assertLogicalExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.LogicalExpression {\n  assert(\"LogicalExpression\", node, opts);\n}\nexport function assertMemberExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.MemberExpression {\n  assert(\"MemberExpression\", node, opts);\n}\nexport function assertNewExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.NewExpression {\n  assert(\"NewExpression\", node, opts);\n}\nexport function assertProgram(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Program {\n  assert(\"Program\", node, opts);\n}\nexport function assertObjectExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectExpression {\n  assert(\"ObjectExpression\", node, opts);\n}\nexport function assertObjectMethod(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectMethod {\n  assert(\"ObjectMethod\", node, opts);\n}\nexport function assertObjectProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectProperty {\n  assert(\"ObjectProperty\", node, opts);\n}\nexport function assertRestElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.RestElement {\n  assert(\"RestElement\", node, opts);\n}\nexport function assertReturnStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ReturnStatement {\n  assert(\"ReturnStatement\", node, opts);\n}\nexport function assertSequenceExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.SequenceExpression {\n  assert(\"SequenceExpression\", node, opts);\n}\nexport function assertParenthesizedExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ParenthesizedExpression {\n  assert(\"ParenthesizedExpression\", node, opts);\n}\nexport function assertSwitchCase(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.SwitchCase {\n  assert(\"SwitchCase\", node, opts);\n}\nexport function assertSwitchStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.SwitchStatement {\n  assert(\"SwitchStatement\", node, opts);\n}\nexport function assertThisExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ThisExpression {\n  assert(\"ThisExpression\", node, opts);\n}\nexport function assertThrowStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ThrowStatement {\n  assert(\"ThrowStatement\", node, opts);\n}\nexport function assertTryStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TryStatement {\n  assert(\"TryStatement\", node, opts);\n}\nexport function assertUnaryExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.UnaryExpression {\n  assert(\"UnaryExpression\", node, opts);\n}\nexport function assertUpdateExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.UpdateExpression {\n  assert(\"UpdateExpression\", node, opts);\n}\nexport function assertVariableDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.VariableDeclaration {\n  assert(\"VariableDeclaration\", node, opts);\n}\nexport function assertVariableDeclarator(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.VariableDeclarator {\n  assert(\"VariableDeclarator\", node, opts);\n}\nexport function assertWhileStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.WhileStatement {\n  assert(\"WhileStatement\", node, opts);\n}\nexport function assertWithStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.WithStatement {\n  assert(\"WithStatement\", node, opts);\n}\nexport function assertAssignmentPattern(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.AssignmentPattern {\n  assert(\"AssignmentPattern\", node, opts);\n}\nexport function assertArrayPattern(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ArrayPattern {\n  assert(\"ArrayPattern\", node, opts);\n}\nexport function assertArrowFunctionExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ArrowFunctionExpression {\n  assert(\"ArrowFunctionExpression\", node, opts);\n}\nexport function assertClassBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ClassBody {\n  assert(\"ClassBody\", node, opts);\n}\nexport function assertClassExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ClassExpression {\n  assert(\"ClassExpression\", node, opts);\n}\nexport function assertClassDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ClassDeclaration {\n  assert(\"ClassDeclaration\", node, opts);\n}\nexport function assertExportAllDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ExportAllDeclaration {\n  assert(\"ExportAllDeclaration\", node, opts);\n}\nexport function assertExportDefaultDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ExportDefaultDeclaration {\n  assert(\"ExportDefaultDeclaration\", node, opts);\n}\nexport function assertExportNamedDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ExportNamedDeclaration {\n  assert(\"ExportNamedDeclaration\", node, opts);\n}\nexport function assertExportSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ExportSpecifier {\n  assert(\"ExportSpecifier\", node, opts);\n}\nexport function assertForOfStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ForOfStatement {\n  assert(\"ForOfStatement\", node, opts);\n}\nexport function assertImportDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ImportDeclaration {\n  assert(\"ImportDeclaration\", node, opts);\n}\nexport function assertImportDefaultSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ImportDefaultSpecifier {\n  assert(\"ImportDefaultSpecifier\", node, opts);\n}\nexport function assertImportNamespaceSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ImportNamespaceSpecifier {\n  assert(\"ImportNamespaceSpecifier\", node, opts);\n}\nexport function assertImportSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ImportSpecifier {\n  assert(\"ImportSpecifier\", node, opts);\n}\nexport function assertMetaProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.MetaProperty {\n  assert(\"MetaProperty\", node, opts);\n}\nexport function assertClassMethod(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ClassMethod {\n  assert(\"ClassMethod\", node, opts);\n}\nexport function assertObjectPattern(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectPattern {\n  assert(\"ObjectPattern\", node, opts);\n}\nexport function assertSpreadElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.SpreadElement {\n  assert(\"SpreadElement\", node, opts);\n}\nexport function assertSuper(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Super {\n  assert(\"Super\", node, opts);\n}\nexport function assertTaggedTemplateExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TaggedTemplateExpression {\n  assert(\"TaggedTemplateExpression\", node, opts);\n}\nexport function assertTemplateElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TemplateElement {\n  assert(\"TemplateElement\", node, opts);\n}\nexport function assertTemplateLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TemplateLiteral {\n  assert(\"TemplateLiteral\", node, opts);\n}\nexport function assertYieldExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.YieldExpression {\n  assert(\"YieldExpression\", node, opts);\n}\nexport function assertAwaitExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.AwaitExpression {\n  assert(\"AwaitExpression\", node, opts);\n}\nexport function assertImport(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Import {\n  assert(\"Import\", node, opts);\n}\nexport function assertBigIntLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.BigIntLiteral {\n  assert(\"BigIntLiteral\", node, opts);\n}\nexport function assertExportNamespaceSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ExportNamespaceSpecifier {\n  assert(\"ExportNamespaceSpecifier\", node, opts);\n}\nexport function assertOptionalMemberExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.OptionalMemberExpression {\n  assert(\"OptionalMemberExpression\", node, opts);\n}\nexport function assertOptionalCallExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.OptionalCallExpression {\n  assert(\"OptionalCallExpression\", node, opts);\n}\nexport function assertClassProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ClassProperty {\n  assert(\"ClassProperty\", node, opts);\n}\nexport function assertClassAccessorProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ClassAccessorProperty {\n  assert(\"ClassAccessorProperty\", node, opts);\n}\nexport function assertClassPrivateProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ClassPrivateProperty {\n  assert(\"ClassPrivateProperty\", node, opts);\n}\nexport function assertClassPrivateMethod(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ClassPrivateMethod {\n  assert(\"ClassPrivateMethod\", node, opts);\n}\nexport function assertPrivateName(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.PrivateName {\n  assert(\"PrivateName\", node, opts);\n}\nexport function assertStaticBlock(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.StaticBlock {\n  assert(\"StaticBlock\", node, opts);\n}\nexport function assertAnyTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.AnyTypeAnnotation {\n  assert(\"AnyTypeAnnotation\", node, opts);\n}\nexport function assertArrayTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ArrayTypeAnnotation {\n  assert(\"ArrayTypeAnnotation\", node, opts);\n}\nexport function assertBooleanTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.BooleanTypeAnnotation {\n  assert(\"BooleanTypeAnnotation\", node, opts);\n}\nexport function assertBooleanLiteralTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.BooleanLiteralTypeAnnotation {\n  assert(\"BooleanLiteralTypeAnnotation\", node, opts);\n}\nexport function assertNullLiteralTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.NullLiteralTypeAnnotation {\n  assert(\"NullLiteralTypeAnnotation\", node, opts);\n}\nexport function assertClassImplements(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ClassImplements {\n  assert(\"ClassImplements\", node, opts);\n}\nexport function assertDeclareClass(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclareClass {\n  assert(\"DeclareClass\", node, opts);\n}\nexport function assertDeclareFunction(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclareFunction {\n  assert(\"DeclareFunction\", node, opts);\n}\nexport function assertDeclareInterface(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclareInterface {\n  assert(\"DeclareInterface\", node, opts);\n}\nexport function assertDeclareModule(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclareModule {\n  assert(\"DeclareModule\", node, opts);\n}\nexport function assertDeclareModuleExports(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclareModuleExports {\n  assert(\"DeclareModuleExports\", node, opts);\n}\nexport function assertDeclareTypeAlias(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclareTypeAlias {\n  assert(\"DeclareTypeAlias\", node, opts);\n}\nexport function assertDeclareOpaqueType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclareOpaqueType {\n  assert(\"DeclareOpaqueType\", node, opts);\n}\nexport function assertDeclareVariable(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclareVariable {\n  assert(\"DeclareVariable\", node, opts);\n}\nexport function assertDeclareExportDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclareExportDeclaration {\n  assert(\"DeclareExportDeclaration\", node, opts);\n}\nexport function assertDeclareExportAllDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclareExportAllDeclaration {\n  assert(\"DeclareExportAllDeclaration\", node, opts);\n}\nexport function assertDeclaredPredicate(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DeclaredPredicate {\n  assert(\"DeclaredPredicate\", node, opts);\n}\nexport function assertExistsTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ExistsTypeAnnotation {\n  assert(\"ExistsTypeAnnotation\", node, opts);\n}\nexport function assertFunctionTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.FunctionTypeAnnotation {\n  assert(\"FunctionTypeAnnotation\", node, opts);\n}\nexport function assertFunctionTypeParam(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.FunctionTypeParam {\n  assert(\"FunctionTypeParam\", node, opts);\n}\nexport function assertGenericTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.GenericTypeAnnotation {\n  assert(\"GenericTypeAnnotation\", node, opts);\n}\nexport function assertInferredPredicate(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.InferredPredicate {\n  assert(\"InferredPredicate\", node, opts);\n}\nexport function assertInterfaceExtends(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.InterfaceExtends {\n  assert(\"InterfaceExtends\", node, opts);\n}\nexport function assertInterfaceDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.InterfaceDeclaration {\n  assert(\"InterfaceDeclaration\", node, opts);\n}\nexport function assertInterfaceTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.InterfaceTypeAnnotation {\n  assert(\"InterfaceTypeAnnotation\", node, opts);\n}\nexport function assertIntersectionTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.IntersectionTypeAnnotation {\n  assert(\"IntersectionTypeAnnotation\", node, opts);\n}\nexport function assertMixedTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.MixedTypeAnnotation {\n  assert(\"MixedTypeAnnotation\", node, opts);\n}\nexport function assertEmptyTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EmptyTypeAnnotation {\n  assert(\"EmptyTypeAnnotation\", node, opts);\n}\nexport function assertNullableTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.NullableTypeAnnotation {\n  assert(\"NullableTypeAnnotation\", node, opts);\n}\nexport function assertNumberLiteralTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.NumberLiteralTypeAnnotation {\n  assert(\"NumberLiteralTypeAnnotation\", node, opts);\n}\nexport function assertNumberTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.NumberTypeAnnotation {\n  assert(\"NumberTypeAnnotation\", node, opts);\n}\nexport function assertObjectTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectTypeAnnotation {\n  assert(\"ObjectTypeAnnotation\", node, opts);\n}\nexport function assertObjectTypeInternalSlot(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectTypeInternalSlot {\n  assert(\"ObjectTypeInternalSlot\", node, opts);\n}\nexport function assertObjectTypeCallProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectTypeCallProperty {\n  assert(\"ObjectTypeCallProperty\", node, opts);\n}\nexport function assertObjectTypeIndexer(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectTypeIndexer {\n  assert(\"ObjectTypeIndexer\", node, opts);\n}\nexport function assertObjectTypeProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectTypeProperty {\n  assert(\"ObjectTypeProperty\", node, opts);\n}\nexport function assertObjectTypeSpreadProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectTypeSpreadProperty {\n  assert(\"ObjectTypeSpreadProperty\", node, opts);\n}\nexport function assertOpaqueType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.OpaqueType {\n  assert(\"OpaqueType\", node, opts);\n}\nexport function assertQualifiedTypeIdentifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.QualifiedTypeIdentifier {\n  assert(\"QualifiedTypeIdentifier\", node, opts);\n}\nexport function assertStringLiteralTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.StringLiteralTypeAnnotation {\n  assert(\"StringLiteralTypeAnnotation\", node, opts);\n}\nexport function assertStringTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.StringTypeAnnotation {\n  assert(\"StringTypeAnnotation\", node, opts);\n}\nexport function assertSymbolTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.SymbolTypeAnnotation {\n  assert(\"SymbolTypeAnnotation\", node, opts);\n}\nexport function assertThisTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ThisTypeAnnotation {\n  assert(\"ThisTypeAnnotation\", node, opts);\n}\nexport function assertTupleTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TupleTypeAnnotation {\n  assert(\"TupleTypeAnnotation\", node, opts);\n}\nexport function assertTypeofTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TypeofTypeAnnotation {\n  assert(\"TypeofTypeAnnotation\", node, opts);\n}\nexport function assertTypeAlias(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TypeAlias {\n  assert(\"TypeAlias\", node, opts);\n}\nexport function assertTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TypeAnnotation {\n  assert(\"TypeAnnotation\", node, opts);\n}\nexport function assertTypeCastExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TypeCastExpression {\n  assert(\"TypeCastExpression\", node, opts);\n}\nexport function assertTypeParameter(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TypeParameter {\n  assert(\"TypeParameter\", node, opts);\n}\nexport function assertTypeParameterDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TypeParameterDeclaration {\n  assert(\"TypeParameterDeclaration\", node, opts);\n}\nexport function assertTypeParameterInstantiation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TypeParameterInstantiation {\n  assert(\"TypeParameterInstantiation\", node, opts);\n}\nexport function assertUnionTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.UnionTypeAnnotation {\n  assert(\"UnionTypeAnnotation\", node, opts);\n}\nexport function assertVariance(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Variance {\n  assert(\"Variance\", node, opts);\n}\nexport function assertVoidTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.VoidTypeAnnotation {\n  assert(\"VoidTypeAnnotation\", node, opts);\n}\nexport function assertEnumDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumDeclaration {\n  assert(\"EnumDeclaration\", node, opts);\n}\nexport function assertEnumBooleanBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumBooleanBody {\n  assert(\"EnumBooleanBody\", node, opts);\n}\nexport function assertEnumNumberBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumNumberBody {\n  assert(\"EnumNumberBody\", node, opts);\n}\nexport function assertEnumStringBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumStringBody {\n  assert(\"EnumStringBody\", node, opts);\n}\nexport function assertEnumSymbolBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumSymbolBody {\n  assert(\"EnumSymbolBody\", node, opts);\n}\nexport function assertEnumBooleanMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumBooleanMember {\n  assert(\"EnumBooleanMember\", node, opts);\n}\nexport function assertEnumNumberMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumNumberMember {\n  assert(\"EnumNumberMember\", node, opts);\n}\nexport function assertEnumStringMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumStringMember {\n  assert(\"EnumStringMember\", node, opts);\n}\nexport function assertEnumDefaultedMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumDefaultedMember {\n  assert(\"EnumDefaultedMember\", node, opts);\n}\nexport function assertIndexedAccessType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.IndexedAccessType {\n  assert(\"IndexedAccessType\", node, opts);\n}\nexport function assertOptionalIndexedAccessType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.OptionalIndexedAccessType {\n  assert(\"OptionalIndexedAccessType\", node, opts);\n}\nexport function assertJSXAttribute(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXAttribute {\n  assert(\"JSXAttribute\", node, opts);\n}\nexport function assertJSXClosingElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXClosingElement {\n  assert(\"JSXClosingElement\", node, opts);\n}\nexport function assertJSXElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXElement {\n  assert(\"JSXElement\", node, opts);\n}\nexport function assertJSXEmptyExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXEmptyExpression {\n  assert(\"JSXEmptyExpression\", node, opts);\n}\nexport function assertJSXExpressionContainer(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXExpressionContainer {\n  assert(\"JSXExpressionContainer\", node, opts);\n}\nexport function assertJSXSpreadChild(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXSpreadChild {\n  assert(\"JSXSpreadChild\", node, opts);\n}\nexport function assertJSXIdentifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXIdentifier {\n  assert(\"JSXIdentifier\", node, opts);\n}\nexport function assertJSXMemberExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXMemberExpression {\n  assert(\"JSXMemberExpression\", node, opts);\n}\nexport function assertJSXNamespacedName(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXNamespacedName {\n  assert(\"JSXNamespacedName\", node, opts);\n}\nexport function assertJSXOpeningElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXOpeningElement {\n  assert(\"JSXOpeningElement\", node, opts);\n}\nexport function assertJSXSpreadAttribute(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXSpreadAttribute {\n  assert(\"JSXSpreadAttribute\", node, opts);\n}\nexport function assertJSXText(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXText {\n  assert(\"JSXText\", node, opts);\n}\nexport function assertJSXFragment(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXFragment {\n  assert(\"JSXFragment\", node, opts);\n}\nexport function assertJSXOpeningFragment(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXOpeningFragment {\n  assert(\"JSXOpeningFragment\", node, opts);\n}\nexport function assertJSXClosingFragment(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSXClosingFragment {\n  assert(\"JSXClosingFragment\", node, opts);\n}\nexport function assertNoop(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Noop {\n  assert(\"Noop\", node, opts);\n}\nexport function assertPlaceholder(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Placeholder {\n  assert(\"Placeholder\", node, opts);\n}\nexport function assertV8IntrinsicIdentifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.V8IntrinsicIdentifier {\n  assert(\"V8IntrinsicIdentifier\", node, opts);\n}\nexport function assertArgumentPlaceholder(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ArgumentPlaceholder {\n  assert(\"ArgumentPlaceholder\", node, opts);\n}\nexport function assertBindExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.BindExpression {\n  assert(\"BindExpression\", node, opts);\n}\nexport function assertImportAttribute(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ImportAttribute {\n  assert(\"ImportAttribute\", node, opts);\n}\nexport function assertDecorator(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Decorator {\n  assert(\"Decorator\", node, opts);\n}\nexport function assertDoExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DoExpression {\n  assert(\"DoExpression\", node, opts);\n}\nexport function assertExportDefaultSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ExportDefaultSpecifier {\n  assert(\"ExportDefaultSpecifier\", node, opts);\n}\nexport function assertRecordExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.RecordExpression {\n  assert(\"RecordExpression\", node, opts);\n}\nexport function assertTupleExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TupleExpression {\n  assert(\"TupleExpression\", node, opts);\n}\nexport function assertDecimalLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.DecimalLiteral {\n  assert(\"DecimalLiteral\", node, opts);\n}\nexport function assertModuleExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ModuleExpression {\n  assert(\"ModuleExpression\", node, opts);\n}\nexport function assertTopicReference(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TopicReference {\n  assert(\"TopicReference\", node, opts);\n}\nexport function assertPipelineTopicExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.PipelineTopicExpression {\n  assert(\"PipelineTopicExpression\", node, opts);\n}\nexport function assertPipelineBareFunction(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.PipelineBareFunction {\n  assert(\"PipelineBareFunction\", node, opts);\n}\nexport function assertPipelinePrimaryTopicReference(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.PipelinePrimaryTopicReference {\n  assert(\"PipelinePrimaryTopicReference\", node, opts);\n}\nexport function assertTSParameterProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSParameterProperty {\n  assert(\"TSParameterProperty\", node, opts);\n}\nexport function assertTSDeclareFunction(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSDeclareFunction {\n  assert(\"TSDeclareFunction\", node, opts);\n}\nexport function assertTSDeclareMethod(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSDeclareMethod {\n  assert(\"TSDeclareMethod\", node, opts);\n}\nexport function assertTSQualifiedName(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSQualifiedName {\n  assert(\"TSQualifiedName\", node, opts);\n}\nexport function assertTSCallSignatureDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSCallSignatureDeclaration {\n  assert(\"TSCallSignatureDeclaration\", node, opts);\n}\nexport function assertTSConstructSignatureDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSConstructSignatureDeclaration {\n  assert(\"TSConstructSignatureDeclaration\", node, opts);\n}\nexport function assertTSPropertySignature(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSPropertySignature {\n  assert(\"TSPropertySignature\", node, opts);\n}\nexport function assertTSMethodSignature(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSMethodSignature {\n  assert(\"TSMethodSignature\", node, opts);\n}\nexport function assertTSIndexSignature(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSIndexSignature {\n  assert(\"TSIndexSignature\", node, opts);\n}\nexport function assertTSAnyKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSAnyKeyword {\n  assert(\"TSAnyKeyword\", node, opts);\n}\nexport function assertTSBooleanKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSBooleanKeyword {\n  assert(\"TSBooleanKeyword\", node, opts);\n}\nexport function assertTSBigIntKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSBigIntKeyword {\n  assert(\"TSBigIntKeyword\", node, opts);\n}\nexport function assertTSIntrinsicKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSIntrinsicKeyword {\n  assert(\"TSIntrinsicKeyword\", node, opts);\n}\nexport function assertTSNeverKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSNeverKeyword {\n  assert(\"TSNeverKeyword\", node, opts);\n}\nexport function assertTSNullKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSNullKeyword {\n  assert(\"TSNullKeyword\", node, opts);\n}\nexport function assertTSNumberKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSNumberKeyword {\n  assert(\"TSNumberKeyword\", node, opts);\n}\nexport function assertTSObjectKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSObjectKeyword {\n  assert(\"TSObjectKeyword\", node, opts);\n}\nexport function assertTSStringKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSStringKeyword {\n  assert(\"TSStringKeyword\", node, opts);\n}\nexport function assertTSSymbolKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSSymbolKeyword {\n  assert(\"TSSymbolKeyword\", node, opts);\n}\nexport function assertTSUndefinedKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSUndefinedKeyword {\n  assert(\"TSUndefinedKeyword\", node, opts);\n}\nexport function assertTSUnknownKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSUnknownKeyword {\n  assert(\"TSUnknownKeyword\", node, opts);\n}\nexport function assertTSVoidKeyword(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSVoidKeyword {\n  assert(\"TSVoidKeyword\", node, opts);\n}\nexport function assertTSThisType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSThisType {\n  assert(\"TSThisType\", node, opts);\n}\nexport function assertTSFunctionType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSFunctionType {\n  assert(\"TSFunctionType\", node, opts);\n}\nexport function assertTSConstructorType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSConstructorType {\n  assert(\"TSConstructorType\", node, opts);\n}\nexport function assertTSTypeReference(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeReference {\n  assert(\"TSTypeReference\", node, opts);\n}\nexport function assertTSTypePredicate(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypePredicate {\n  assert(\"TSTypePredicate\", node, opts);\n}\nexport function assertTSTypeQuery(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeQuery {\n  assert(\"TSTypeQuery\", node, opts);\n}\nexport function assertTSTypeLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeLiteral {\n  assert(\"TSTypeLiteral\", node, opts);\n}\nexport function assertTSArrayType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSArrayType {\n  assert(\"TSArrayType\", node, opts);\n}\nexport function assertTSTupleType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTupleType {\n  assert(\"TSTupleType\", node, opts);\n}\nexport function assertTSOptionalType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSOptionalType {\n  assert(\"TSOptionalType\", node, opts);\n}\nexport function assertTSRestType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSRestType {\n  assert(\"TSRestType\", node, opts);\n}\nexport function assertTSNamedTupleMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSNamedTupleMember {\n  assert(\"TSNamedTupleMember\", node, opts);\n}\nexport function assertTSUnionType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSUnionType {\n  assert(\"TSUnionType\", node, opts);\n}\nexport function assertTSIntersectionType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSIntersectionType {\n  assert(\"TSIntersectionType\", node, opts);\n}\nexport function assertTSConditionalType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSConditionalType {\n  assert(\"TSConditionalType\", node, opts);\n}\nexport function assertTSInferType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSInferType {\n  assert(\"TSInferType\", node, opts);\n}\nexport function assertTSParenthesizedType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSParenthesizedType {\n  assert(\"TSParenthesizedType\", node, opts);\n}\nexport function assertTSTypeOperator(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeOperator {\n  assert(\"TSTypeOperator\", node, opts);\n}\nexport function assertTSIndexedAccessType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSIndexedAccessType {\n  assert(\"TSIndexedAccessType\", node, opts);\n}\nexport function assertTSMappedType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSMappedType {\n  assert(\"TSMappedType\", node, opts);\n}\nexport function assertTSLiteralType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSLiteralType {\n  assert(\"TSLiteralType\", node, opts);\n}\nexport function assertTSExpressionWithTypeArguments(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSExpressionWithTypeArguments {\n  assert(\"TSExpressionWithTypeArguments\", node, opts);\n}\nexport function assertTSInterfaceDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSInterfaceDeclaration {\n  assert(\"TSInterfaceDeclaration\", node, opts);\n}\nexport function assertTSInterfaceBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSInterfaceBody {\n  assert(\"TSInterfaceBody\", node, opts);\n}\nexport function assertTSTypeAliasDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeAliasDeclaration {\n  assert(\"TSTypeAliasDeclaration\", node, opts);\n}\nexport function assertTSInstantiationExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSInstantiationExpression {\n  assert(\"TSInstantiationExpression\", node, opts);\n}\nexport function assertTSAsExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSAsExpression {\n  assert(\"TSAsExpression\", node, opts);\n}\nexport function assertTSSatisfiesExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSSatisfiesExpression {\n  assert(\"TSSatisfiesExpression\", node, opts);\n}\nexport function assertTSTypeAssertion(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeAssertion {\n  assert(\"TSTypeAssertion\", node, opts);\n}\nexport function assertTSEnumDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSEnumDeclaration {\n  assert(\"TSEnumDeclaration\", node, opts);\n}\nexport function assertTSEnumMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSEnumMember {\n  assert(\"TSEnumMember\", node, opts);\n}\nexport function assertTSModuleDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSModuleDeclaration {\n  assert(\"TSModuleDeclaration\", node, opts);\n}\nexport function assertTSModuleBlock(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSModuleBlock {\n  assert(\"TSModuleBlock\", node, opts);\n}\nexport function assertTSImportType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSImportType {\n  assert(\"TSImportType\", node, opts);\n}\nexport function assertTSImportEqualsDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSImportEqualsDeclaration {\n  assert(\"TSImportEqualsDeclaration\", node, opts);\n}\nexport function assertTSExternalModuleReference(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSExternalModuleReference {\n  assert(\"TSExternalModuleReference\", node, opts);\n}\nexport function assertTSNonNullExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSNonNullExpression {\n  assert(\"TSNonNullExpression\", node, opts);\n}\nexport function assertTSExportAssignment(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSExportAssignment {\n  assert(\"TSExportAssignment\", node, opts);\n}\nexport function assertTSNamespaceExportDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSNamespaceExportDeclaration {\n  assert(\"TSNamespaceExportDeclaration\", node, opts);\n}\nexport function assertTSTypeAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeAnnotation {\n  assert(\"TSTypeAnnotation\", node, opts);\n}\nexport function assertTSTypeParameterInstantiation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeParameterInstantiation {\n  assert(\"TSTypeParameterInstantiation\", node, opts);\n}\nexport function assertTSTypeParameterDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeParameterDeclaration {\n  assert(\"TSTypeParameterDeclaration\", node, opts);\n}\nexport function assertTSTypeParameter(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeParameter {\n  assert(\"TSTypeParameter\", node, opts);\n}\nexport function assertStandardized(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Standardized {\n  assert(\"Standardized\", node, opts);\n}\nexport function assertExpression(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Expression {\n  assert(\"Expression\", node, opts);\n}\nexport function assertBinary(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Binary {\n  assert(\"Binary\", node, opts);\n}\nexport function assertScopable(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Scopable {\n  assert(\"Scopable\", node, opts);\n}\nexport function assertBlockParent(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.BlockParent {\n  assert(\"BlockParent\", node, opts);\n}\nexport function assertBlock(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Block {\n  assert(\"Block\", node, opts);\n}\nexport function assertStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Statement {\n  assert(\"Statement\", node, opts);\n}\nexport function assertTerminatorless(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Terminatorless {\n  assert(\"Terminatorless\", node, opts);\n}\nexport function assertCompletionStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.CompletionStatement {\n  assert(\"CompletionStatement\", node, opts);\n}\nexport function assertConditional(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Conditional {\n  assert(\"Conditional\", node, opts);\n}\nexport function assertLoop(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Loop {\n  assert(\"Loop\", node, opts);\n}\nexport function assertWhile(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.While {\n  assert(\"While\", node, opts);\n}\nexport function assertExpressionWrapper(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ExpressionWrapper {\n  assert(\"ExpressionWrapper\", node, opts);\n}\nexport function assertFor(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.For {\n  assert(\"For\", node, opts);\n}\nexport function assertForXStatement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ForXStatement {\n  assert(\"ForXStatement\", node, opts);\n}\nexport function assertFunction(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Function {\n  assert(\"Function\", node, opts);\n}\nexport function assertFunctionParent(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.FunctionParent {\n  assert(\"FunctionParent\", node, opts);\n}\nexport function assertPureish(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Pureish {\n  assert(\"Pureish\", node, opts);\n}\nexport function assertDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Declaration {\n  assert(\"Declaration\", node, opts);\n}\nexport function assertPatternLike(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.PatternLike {\n  assert(\"PatternLike\", node, opts);\n}\nexport function assertLVal(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.LVal {\n  assert(\"LVal\", node, opts);\n}\nexport function assertTSEntityName(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSEntityName {\n  assert(\"TSEntityName\", node, opts);\n}\nexport function assertLiteral(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Literal {\n  assert(\"Literal\", node, opts);\n}\nexport function assertImmutable(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Immutable {\n  assert(\"Immutable\", node, opts);\n}\nexport function assertUserWhitespacable(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.UserWhitespacable {\n  assert(\"UserWhitespacable\", node, opts);\n}\nexport function assertMethod(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Method {\n  assert(\"Method\", node, opts);\n}\nexport function assertObjectMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ObjectMember {\n  assert(\"ObjectMember\", node, opts);\n}\nexport function assertProperty(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Property {\n  assert(\"Property\", node, opts);\n}\nexport function assertUnaryLike(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.UnaryLike {\n  assert(\"UnaryLike\", node, opts);\n}\nexport function assertPattern(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Pattern {\n  assert(\"Pattern\", node, opts);\n}\nexport function assertClass(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Class {\n  assert(\"Class\", node, opts);\n}\nexport function assertModuleDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ModuleDeclaration {\n  assert(\"ModuleDeclaration\", node, opts);\n}\nexport function assertExportDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ExportDeclaration {\n  assert(\"ExportDeclaration\", node, opts);\n}\nexport function assertModuleSpecifier(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.ModuleSpecifier {\n  assert(\"ModuleSpecifier\", node, opts);\n}\nexport function assertAccessor(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Accessor {\n  assert(\"Accessor\", node, opts);\n}\nexport function assertPrivate(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Private {\n  assert(\"Private\", node, opts);\n}\nexport function assertFlow(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Flow {\n  assert(\"Flow\", node, opts);\n}\nexport function assertFlowType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.FlowType {\n  assert(\"FlowType\", node, opts);\n}\nexport function assertFlowBaseAnnotation(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.FlowBaseAnnotation {\n  assert(\"FlowBaseAnnotation\", node, opts);\n}\nexport function assertFlowDeclaration(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.FlowDeclaration {\n  assert(\"FlowDeclaration\", node, opts);\n}\nexport function assertFlowPredicate(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.FlowPredicate {\n  assert(\"FlowPredicate\", node, opts);\n}\nexport function assertEnumBody(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumBody {\n  assert(\"EnumBody\", node, opts);\n}\nexport function assertEnumMember(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.EnumMember {\n  assert(\"EnumMember\", node, opts);\n}\nexport function assertJSX(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.JSX {\n  assert(\"JSX\", node, opts);\n}\nexport function assertMiscellaneous(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.Miscellaneous {\n  assert(\"Miscellaneous\", node, opts);\n}\nexport function assertTypeScript(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TypeScript {\n  assert(\"TypeScript\", node, opts);\n}\nexport function assertTSTypeElement(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSTypeElement {\n  assert(\"TSTypeElement\", node, opts);\n}\nexport function assertTSType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSType {\n  assert(\"TSType\", node, opts);\n}\nexport function assertTSBaseType(\n  node: object | null | undefined,\n  opts?: object | null,\n): asserts node is t.TSBaseType {\n  assert(\"TSBaseType\", node, opts);\n}\nexport function assertNumberLiteral(node: any, opts: any): void {\n  console.trace(\n    \"The node type NumberLiteral has been renamed to NumericLiteral\",\n  );\n  assert(\"NumberLiteral\", node, opts);\n}\nexport function assertRegexLiteral(node: any, opts: any): void {\n  console.trace(\"The node type RegexLiteral has been renamed to RegExpLiteral\");\n  assert(\"RegexLiteral\", node, opts);\n}\nexport function assertRestProperty(node: any, opts: any): void {\n  console.trace(\"The node type RestProperty has been renamed to RestElement\");\n  assert(\"RestProperty\", node, opts);\n}\nexport function assertSpreadProperty(node: any, opts: any): void {\n  console.trace(\n    \"The node type SpreadProperty has been renamed to SpreadElement\",\n  );\n  assert(\"SpreadProperty\", node, opts);\n}\n","import {\n  anyTypeAnnotation,\n  stringTypeAnnotation,\n  numberTypeAnnotation,\n  voidTypeAnnotation,\n  booleanTypeAnnotation,\n  genericTypeAnnotation,\n  identifier,\n} from \"../generated\";\nimport type * as t from \"../..\";\n\nexport default createTypeAnnotationBasedOnTypeof as {\n  (type: \"string\"): t.StringTypeAnnotation;\n  (type: \"number\"): t.NumberTypeAnnotation;\n  (type: \"undefined\"): t.VoidTypeAnnotation;\n  (type: \"boolean\"): t.BooleanTypeAnnotation;\n  (type: \"function\"): t.GenericTypeAnnotation;\n  (type: \"object\"): t.GenericTypeAnnotation;\n  (type: \"symbol\"): t.GenericTypeAnnotation;\n  (type: \"bigint\"): t.AnyTypeAnnotation;\n};\n\n/**\n * Create a type annotation based on typeof expression.\n */\nfunction createTypeAnnotationBasedOnTypeof(type: string): t.FlowType {\n  switch (type) {\n    case \"string\":\n      return stringTypeAnnotation();\n    case \"number\":\n      return numberTypeAnnotation();\n    case \"undefined\":\n      return voidTypeAnnotation();\n    case \"boolean\":\n      return booleanTypeAnnotation();\n    case \"function\":\n      return genericTypeAnnotation(identifier(\"Function\"));\n    case \"object\":\n      return genericTypeAnnotation(identifier(\"Object\"));\n    case \"symbol\":\n      return genericTypeAnnotation(identifier(\"Symbol\"));\n    case \"bigint\":\n      // todo: use BigInt annotation when Flow supports BigInt\n      // https://github.com/facebook/flow/issues/6639\n      return anyTypeAnnotation();\n  }\n  throw new Error(\"Invalid typeof value: \" + type);\n}\n","import { unionTypeAnnotation } from \"../generated\";\nimport removeTypeDuplicates from \"../../modifications/flow/removeTypeDuplicates\";\nimport type * as t from \"../..\";\n\n/**\n * Takes an array of `types` and flattens them, removing duplicates and\n * returns a `UnionTypeAnnotation` node containing them.\n */\nexport default function createFlowUnionType<T extends t.FlowType>(\n  types: [T] | Array<T>,\n): T | t.UnionTypeAnnotation {\n  const flattened = removeTypeDuplicates(types);\n\n  if (flattened.length === 1) {\n    return flattened[0] as T;\n  } else {\n    return unionTypeAnnotation(flattened);\n  }\n}\n","import { tsUnionType } from \"../generated\";\nimport removeTypeDuplicates from \"../../modifications/typescript/removeTypeDuplicates\";\nimport { isTSTypeAnnotation } from \"../../validators/generated/index\";\nimport type * as t from \"../..\";\n\n/**\n * Takes an array of `types` and flattens them, removing duplicates and\n * returns a `UnionTypeAnnotation` node containing them.\n */\nexport default function createTSUnionType(\n  typeAnnotations: Array<t.TSTypeAnnotation | t.TSType>,\n): t.TSType {\n  const types = typeAnnotations.map(type => {\n    return isTSTypeAnnotation(type) ? type.typeAnnotation : type;\n  });\n  const flattened = removeTypeDuplicates(types);\n\n  if (flattened.length === 1) {\n    return flattened[0];\n  } else {\n    return tsUnionType(flattened);\n  }\n}\n","import {\n  isIdentifier,\n  isTSAnyKeyword,\n  isTSTypeReference,\n  isTSUnionType,\n  isTSBaseType,\n} from \"../../validators/generated\";\nimport type * as t from \"../..\";\n\nfunction getQualifiedName(node: t.TSTypeReference[\"typeName\"]): string {\n  return isIdentifier(node)\n    ? node.name\n    : `${node.right.name}.${getQualifiedName(node.left)}`;\n}\n\n/**\n * Dedupe type annotations.\n */\nexport default function removeTypeDuplicates(\n  nodes: Array<t.TSType>,\n): Array<t.TSType> {\n  const generics = new Map<string, t.TSTypeReference>();\n  const bases = new Map<t.TSBaseType[\"type\"], t.TSBaseType>();\n\n  // store union type groups to circular references\n  const typeGroups = new Set<t.TSType[]>();\n\n  const types: t.TSType[] = [];\n\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i];\n    if (!node) continue;\n\n    // detect duplicates\n    if (types.indexOf(node) >= 0) {\n      continue;\n    }\n\n    // this type matches anything\n    if (isTSAnyKeyword(node)) {\n      return [node];\n    }\n\n    // Analogue of FlowBaseAnnotation\n    if (isTSBaseType(node)) {\n      bases.set(node.type, node);\n      continue;\n    }\n\n    if (isTSUnionType(node)) {\n      if (!typeGroups.has(node.types)) {\n        nodes.push(...node.types);\n        typeGroups.add(node.types);\n      }\n      continue;\n    }\n\n    // todo: support merging tuples: number[]\n    if (isTSTypeReference(node) && node.typeParameters) {\n      const name = getQualifiedName(node.typeName);\n\n      if (generics.has(name)) {\n        let existing: t.TypeScript = generics.get(name);\n        if (existing.typeParameters) {\n          if (node.typeParameters) {\n            existing.typeParameters.params = removeTypeDuplicates(\n              existing.typeParameters.params.concat(node.typeParameters.params),\n            );\n          }\n        } else {\n          existing = node.typeParameters;\n        }\n      } else {\n        generics.set(name, node);\n      }\n\n      continue;\n    }\n\n    types.push(node);\n  }\n\n  // add back in bases\n  for (const [, baseType] of bases) {\n    types.push(baseType);\n  }\n\n  // add back in generics\n  for (const [, genericName] of generics) {\n    types.push(genericName);\n  }\n\n  return types;\n}\n","/*\n * This file is auto-generated! Do not modify it directly.\n * To re-generate run 'make build'\n */\n\n/**\n * This file is written in JavaScript and not TypeScript because uppercase builders\n * conflict with AST types. TypeScript reads the uppercase.d.ts file instead.\n */\n\nexport {\n  arrayExpression as ArrayExpression,\n  assignmentExpression as AssignmentExpression,\n  binaryExpression as BinaryExpression,\n  interpreterDirective as InterpreterDirective,\n  directive as Directive,\n  directiveLiteral as DirectiveLiteral,\n  blockStatement as BlockStatement,\n  breakStatement as BreakStatement,\n  callExpression as CallExpression,\n  catchClause as CatchClause,\n  conditionalExpression as ConditionalExpression,\n  continueStatement as ContinueStatement,\n  debuggerStatement as DebuggerStatement,\n  doWhileStatement as DoWhileStatement,\n  emptyStatement as EmptyStatement,\n  expressionStatement as ExpressionStatement,\n  file as File,\n  forInStatement as ForInStatement,\n  forStatement as ForStatement,\n  functionDeclaration as FunctionDeclaration,\n  functionExpression as FunctionExpression,\n  identifier as Identifier,\n  ifStatement as IfStatement,\n  labeledStatement as LabeledStatement,\n  stringLiteral as StringLiteral,\n  numericLiteral as NumericLiteral,\n  nullLiteral as NullLiteral,\n  booleanLiteral as BooleanLiteral,\n  regExpLiteral as RegExpLiteral,\n  logicalExpression as LogicalExpression,\n  memberExpression as MemberExpression,\n  newExpression as NewExpression,\n  program as Program,\n  objectExpression as ObjectExpression,\n  objectMethod as ObjectMethod,\n  objectProperty as ObjectProperty,\n  restElement as RestElement,\n  returnStatement as ReturnStatement,\n  sequenceExpression as SequenceExpression,\n  parenthesizedExpression as ParenthesizedExpression,\n  switchCase as SwitchCase,\n  switchStatement as SwitchStatement,\n  thisExpression as ThisExpression,\n  throwStatement as ThrowStatement,\n  tryStatement as TryStatement,\n  unaryExpression as UnaryExpression,\n  updateExpression as UpdateExpression,\n  variableDeclaration as VariableDeclaration,\n  variableDeclarator as VariableDeclarator,\n  whileStatement as WhileStatement,\n  withStatement as WithStatement,\n  assignmentPattern as AssignmentPattern,\n  arrayPattern as ArrayPattern,\n  arrowFunctionExpression as ArrowFunctionExpression,\n  classBody as ClassBody,\n  classExpression as ClassExpression,\n  classDeclaration as ClassDeclaration,\n  exportAllDeclaration as ExportAllDeclaration,\n  exportDefaultDeclaration as ExportDefaultDeclaration,\n  exportNamedDeclaration as ExportNamedDeclaration,\n  exportSpecifier as ExportSpecifier,\n  forOfStatement as ForOfStatement,\n  importDeclaration as ImportDeclaration,\n  importDefaultSpecifier as ImportDefaultSpecifier,\n  importNamespaceSpecifier as ImportNamespaceSpecifier,\n  importSpecifier as ImportSpecifier,\n  metaProperty as MetaProperty,\n  classMethod as ClassMethod,\n  objectPattern as ObjectPattern,\n  spreadElement as SpreadElement,\n  super as Super,\n  taggedTemplateExpression as TaggedTemplateExpression,\n  templateElement as TemplateElement,\n  templateLiteral as TemplateLiteral,\n  yieldExpression as YieldExpression,\n  awaitExpression as AwaitExpression,\n  import as Import,\n  bigIntLiteral as BigIntLiteral,\n  exportNamespaceSpecifier as ExportNamespaceSpecifier,\n  optionalMemberExpression as OptionalMemberExpression,\n  optionalCallExpression as OptionalCallExpression,\n  classProperty as ClassProperty,\n  classAccessorProperty as ClassAccessorProperty,\n  classPrivateProperty as ClassPrivateProperty,\n  classPrivateMethod as ClassPrivateMethod,\n  privateName as PrivateName,\n  staticBlock as StaticBlock,\n  anyTypeAnnotation as AnyTypeAnnotation,\n  arrayTypeAnnotation as ArrayTypeAnnotation,\n  booleanTypeAnnotation as BooleanTypeAnnotation,\n  booleanLiteralTypeAnnotation as BooleanLiteralTypeAnnotation,\n  nullLiteralTypeAnnotation as NullLiteralTypeAnnotation,\n  classImplements as ClassImplements,\n  declareClass as DeclareClass,\n  declareFunction as DeclareFunction,\n  declareInterface as DeclareInterface,\n  declareModule as DeclareModule,\n  declareModuleExports as DeclareModuleExports,\n  declareTypeAlias as DeclareTypeAlias,\n  declareOpaqueType as DeclareOpaqueType,\n  declareVariable as DeclareVariable,\n  declareExportDeclaration as DeclareExportDeclaration,\n  declareExportAllDeclaration as DeclareExportAllDeclaration,\n  declaredPredicate as DeclaredPredicate,\n  existsTypeAnnotation as ExistsTypeAnnotation,\n  functionTypeAnnotation as FunctionTypeAnnotation,\n  functionTypeParam as FunctionTypeParam,\n  genericTypeAnnotation as GenericTypeAnnotation,\n  inferredPredicate as InferredPredicate,\n  interfaceExtends as InterfaceExtends,\n  interfaceDeclaration as InterfaceDeclaration,\n  interfaceTypeAnnotation as InterfaceTypeAnnotation,\n  intersectionTypeAnnotation as IntersectionTypeAnnotation,\n  mixedTypeAnnotation as MixedTypeAnnotation,\n  emptyTypeAnnotation as EmptyTypeAnnotation,\n  nullableTypeAnnotation as NullableTypeAnnotation,\n  numberLiteralTypeAnnotation as NumberLiteralTypeAnnotation,\n  numberTypeAnnotation as NumberTypeAnnotation,\n  objectTypeAnnotation as ObjectTypeAnnotation,\n  objectTypeInternalSlot as ObjectTypeInternalSlot,\n  objectTypeCallProperty as ObjectTypeCallProperty,\n  objectTypeIndexer as ObjectTypeIndexer,\n  objectTypeProperty as ObjectTypeProperty,\n  objectTypeSpreadProperty as ObjectTypeSpreadProperty,\n  opaqueType as OpaqueType,\n  qualifiedTypeIdentifier as QualifiedTypeIdentifier,\n  stringLiteralTypeAnnotation as StringLiteralTypeAnnotation,\n  stringTypeAnnotation as StringTypeAnnotation,\n  symbolTypeAnnotation as SymbolTypeAnnotation,\n  thisTypeAnnotation as ThisTypeAnnotation,\n  tupleTypeAnnotation as TupleTypeAnnotation,\n  typeofTypeAnnotation as TypeofTypeAnnotation,\n  typeAlias as TypeAlias,\n  typeAnnotation as TypeAnnotation,\n  typeCastExpression as TypeCastExpression,\n  typeParameter as TypeParameter,\n  typeParameterDeclaration as TypeParameterDeclaration,\n  typeParameterInstantiation as TypeParameterInstantiation,\n  unionTypeAnnotation as UnionTypeAnnotation,\n  variance as Variance,\n  voidTypeAnnotation as VoidTypeAnnotation,\n  enumDeclaration as EnumDeclaration,\n  enumBooleanBody as EnumBooleanBody,\n  enumNumberBody as EnumNumberBody,\n  enumStringBody as EnumStringBody,\n  enumSymbolBody as EnumSymbolBody,\n  enumBooleanMember as EnumBooleanMember,\n  enumNumberMember as EnumNumberMember,\n  enumStringMember as EnumStringMember,\n  enumDefaultedMember as EnumDefaultedMember,\n  indexedAccessType as IndexedAccessType,\n  optionalIndexedAccessType as OptionalIndexedAccessType,\n  jsxAttribute as JSXAttribute,\n  jsxClosingElement as JSXClosingElement,\n  jsxElement as JSXElement,\n  jsxEmptyExpression as JSXEmptyExpression,\n  jsxExpressionContainer as JSXExpressionContainer,\n  jsxSpreadChild as JSXSpreadChild,\n  jsxIdentifier as JSXIdentifier,\n  jsxMemberExpression as JSXMemberExpression,\n  jsxNamespacedName as JSXNamespacedName,\n  jsxOpeningElement as JSXOpeningElement,\n  jsxSpreadAttribute as JSXSpreadAttribute,\n  jsxText as JSXText,\n  jsxFragment as JSXFragment,\n  jsxOpeningFragment as JSXOpeningFragment,\n  jsxClosingFragment as JSXClosingFragment,\n  noop as Noop,\n  placeholder as Placeholder,\n  v8IntrinsicIdentifier as V8IntrinsicIdentifier,\n  argumentPlaceholder as ArgumentPlaceholder,\n  bindExpression as BindExpression,\n  importAttribute as ImportAttribute,\n  decorator as Decorator,\n  doExpression as DoExpression,\n  exportDefaultSpecifier as ExportDefaultSpecifier,\n  recordExpression as RecordExpression,\n  tupleExpression as TupleExpression,\n  decimalLiteral as DecimalLiteral,\n  moduleExpression as ModuleExpression,\n  topicReference as TopicReference,\n  pipelineTopicExpression as PipelineTopicExpression,\n  pipelineBareFunction as PipelineBareFunction,\n  pipelinePrimaryTopicReference as PipelinePrimaryTopicReference,\n  tsParameterProperty as TSParameterProperty,\n  tsDeclareFunction as TSDeclareFunction,\n  tsDeclareMethod as TSDeclareMethod,\n  tsQualifiedName as TSQualifiedName,\n  tsCallSignatureDeclaration as TSCallSignatureDeclaration,\n  tsConstructSignatureDeclaration as TSConstructSignatureDeclaration,\n  tsPropertySignature as TSPropertySignature,\n  tsMethodSignature as TSMethodSignature,\n  tsIndexSignature as TSIndexSignature,\n  tsAnyKeyword as TSAnyKeyword,\n  tsBooleanKeyword as TSBooleanKeyword,\n  tsBigIntKeyword as TSBigIntKeyword,\n  tsIntrinsicKeyword as TSIntrinsicKeyword,\n  tsNeverKeyword as TSNeverKeyword,\n  tsNullKeyword as TSNullKeyword,\n  tsNumberKeyword as TSNumberKeyword,\n  tsObjectKeyword as TSObjectKeyword,\n  tsStringKeyword as TSStringKeyword,\n  tsSymbolKeyword as TSSymbolKeyword,\n  tsUndefinedKeyword as TSUndefinedKeyword,\n  tsUnknownKeyword as TSUnknownKeyword,\n  tsVoidKeyword as TSVoidKeyword,\n  tsThisType as TSThisType,\n  tsFunctionType as TSFunctionType,\n  tsConstructorType as TSConstructorType,\n  tsTypeReference as TSTypeReference,\n  tsTypePredicate as TSTypePredicate,\n  tsTypeQuery as TSTypeQuery,\n  tsTypeLiteral as TSTypeLiteral,\n  tsArrayType as TSArrayType,\n  tsTupleType as TSTupleType,\n  tsOptionalType as TSOptionalType,\n  tsRestType as TSRestType,\n  tsNamedTupleMember as TSNamedTupleMember,\n  tsUnionType as TSUnionType,\n  tsIntersectionType as TSIntersectionType,\n  tsConditionalType as TSConditionalType,\n  tsInferType as TSInferType,\n  tsParenthesizedType as TSParenthesizedType,\n  tsTypeOperator as TSTypeOperator,\n  tsIndexedAccessType as TSIndexedAccessType,\n  tsMappedType as TSMappedType,\n  tsLiteralType as TSLiteralType,\n  tsExpressionWithTypeArguments as TSExpressionWithTypeArguments,\n  tsInterfaceDeclaration as TSInterfaceDeclaration,\n  tsInterfaceBody as TSInterfaceBody,\n  tsTypeAliasDeclaration as TSTypeAliasDeclaration,\n  tsInstantiationExpression as TSInstantiationExpression,\n  tsAsExpression as TSAsExpression,\n  tsSatisfiesExpression as TSSatisfiesExpression,\n  tsTypeAssertion as TSTypeAssertion,\n  tsEnumDeclaration as TSEnumDeclaration,\n  tsEnumMember as TSEnumMember,\n  tsModuleDeclaration as TSModuleDeclaration,\n  tsModuleBlock as TSModuleBlock,\n  tsImportType as TSImportType,\n  tsImportEqualsDeclaration as TSImportEqualsDeclaration,\n  tsExternalModuleReference as TSExternalModuleReference,\n  tsNonNullExpression as TSNonNullExpression,\n  tsExportAssignment as TSExportAssignment,\n  tsNamespaceExportDeclaration as TSNamespaceExportDeclaration,\n  tsTypeAnnotation as TSTypeAnnotation,\n  tsTypeParameterInstantiation as TSTypeParameterInstantiation,\n  tsTypeParameterDeclaration as TSTypeParameterDeclaration,\n  tsTypeParameter as TSTypeParameter,\n  numberLiteral as NumberLiteral,\n  regexLiteral as RegexLiteral,\n  restProperty as RestProperty,\n  spreadProperty as SpreadProperty,\n} from \"./index\";\n","import cloneNode from \"./cloneNode\";\nimport type * as t from \"..\";\n\n/**\n * Create a shallow clone of a `node`, including only\n * properties belonging to the node.\n * @deprecated Use t.cloneNode instead.\n */\nexport default function clone<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ false);\n}\n","import cloneNode from \"./cloneNode\";\nimport type * as t from \"..\";\n\n/**\n * Create a deep clone of a `node` and all of it's child nodes\n * including only properties belonging to the node.\n * @deprecated Use t.cloneNode instead.\n */\nexport default function cloneDeep<T extends t.Node>(node: T): T {\n  return cloneNode(node);\n}\n","import cloneNode from \"./cloneNode\";\nimport type * as t from \"..\";\n/**\n * Create a deep clone of a `node` and all of it's child nodes\n * including only properties belonging to the node.\n * excluding `_private` and location properties.\n */\nexport default function cloneDeepWithoutLoc<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ true, /* withoutLoc */ true);\n}\n","import cloneNode from \"./cloneNode\";\nimport type * as t from \"..\";\n\n/**\n * Create a shallow clone of a `node` excluding `_private` and location properties.\n */\nexport default function cloneWithoutLoc<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ false, /* withoutLoc */ true);\n}\n","import addComments from \"./addComments\";\nimport type * as t from \"..\";\n\n/**\n * Add comment of certain type to a node.\n */\nexport default function addComment<T extends t.Node>(\n  node: T,\n  type: t.CommentTypeShorthand,\n  content: string,\n  line?: boolean,\n): T {\n  return addComments(node, type, [\n    {\n      type: line ? \"CommentLine\" : \"CommentBlock\",\n      value: content,\n    } as t.Comment,\n  ]);\n}\n","import { COMMENT_KEYS } from \"../constants\";\nimport type * as t from \"..\";\n\n/**\n * Remove comment properties from a node.\n */\nexport default function removeComments<T extends t.Node>(node: T): T {\n  COMMENT_KEYS.forEach(key => {\n    node[key] = null;\n  });\n\n  return node;\n}\n","/*\n * This file is auto-generated! Do not modify it directly.\n * To re-generate run 'make build'\n */\nimport { FLIPPED_ALIAS_KEYS } from \"../../definitions\";\n\nexport const STANDARDIZED_TYPES = FLIPPED_ALIAS_KEYS[\"Standardized\"];\nexport const EXPRESSION_TYPES = FLIPPED_ALIAS_KEYS[\"Expression\"];\nexport const BINARY_TYPES = FLIPPED_ALIAS_KEYS[\"Binary\"];\nexport const SCOPABLE_TYPES = FLIPPED_ALIAS_KEYS[\"Scopable\"];\nexport const BLOCKPARENT_TYPES = FLIPPED_ALIAS_KEYS[\"BlockParent\"];\nexport const BLOCK_TYPES = FLIPPED_ALIAS_KEYS[\"Block\"];\nexport const STATEMENT_TYPES = FLIPPED_ALIAS_KEYS[\"Statement\"];\nexport const TERMINATORLESS_TYPES = FLIPPED_ALIAS_KEYS[\"Terminatorless\"];\nexport const COMPLETIONSTATEMENT_TYPES =\n  FLIPPED_ALIAS_KEYS[\"CompletionStatement\"];\nexport const CONDITIONAL_TYPES = FLIPPED_ALIAS_KEYS[\"Conditional\"];\nexport const LOOP_TYPES = FLIPPED_ALIAS_KEYS[\"Loop\"];\nexport const WHILE_TYPES = FLIPPED_ALIAS_KEYS[\"While\"];\nexport const EXPRESSIONWRAPPER_TYPES = FLIPPED_ALIAS_KEYS[\"ExpressionWrapper\"];\nexport const FOR_TYPES = FLIPPED_ALIAS_KEYS[\"For\"];\nexport const FORXSTATEMENT_TYPES = FLIPPED_ALIAS_KEYS[\"ForXStatement\"];\nexport const FUNCTION_TYPES = FLIPPED_ALIAS_KEYS[\"Function\"];\nexport const FUNCTIONPARENT_TYPES = FLIPPED_ALIAS_KEYS[\"FunctionParent\"];\nexport const PUREISH_TYPES = FLIPPED_ALIAS_KEYS[\"Pureish\"];\nexport const DECLARATION_TYPES = FLIPPED_ALIAS_KEYS[\"Declaration\"];\nexport const PATTERNLIKE_TYPES = FLIPPED_ALIAS_KEYS[\"PatternLike\"];\nexport const LVAL_TYPES = FLIPPED_ALIAS_KEYS[\"LVal\"];\nexport const TSENTITYNAME_TYPES = FLIPPED_ALIAS_KEYS[\"TSEntityName\"];\nexport const LITERAL_TYPES = FLIPPED_ALIAS_KEYS[\"Literal\"];\nexport const IMMUTABLE_TYPES = FLIPPED_ALIAS_KEYS[\"Immutable\"];\nexport const USERWHITESPACABLE_TYPES = FLIPPED_ALIAS_KEYS[\"UserWhitespacable\"];\nexport const METHOD_TYPES = FLIPPED_ALIAS_KEYS[\"Method\"];\nexport const OBJECTMEMBER_TYPES = FLIPPED_ALIAS_KEYS[\"ObjectMember\"];\nexport const PROPERTY_TYPES = FLIPPED_ALIAS_KEYS[\"Property\"];\nexport const UNARYLIKE_TYPES = FLIPPED_ALIAS_KEYS[\"UnaryLike\"];\nexport const PATTERN_TYPES = FLIPPED_ALIAS_KEYS[\"Pattern\"];\nexport const CLASS_TYPES = FLIPPED_ALIAS_KEYS[\"Class\"];\nexport const MODULEDECLARATION_TYPES = FLIPPED_ALIAS_KEYS[\"ModuleDeclaration\"];\nexport const EXPORTDECLARATION_TYPES = FLIPPED_ALIAS_KEYS[\"ExportDeclaration\"];\nexport const MODULESPECIFIER_TYPES = FLIPPED_ALIAS_KEYS[\"ModuleSpecifier\"];\nexport const ACCESSOR_TYPES = FLIPPED_ALIAS_KEYS[\"Accessor\"];\nexport const PRIVATE_TYPES = FLIPPED_ALIAS_KEYS[\"Private\"];\nexport const FLOW_TYPES = FLIPPED_ALIAS_KEYS[\"Flow\"];\nexport const FLOWTYPE_TYPES = FLIPPED_ALIAS_KEYS[\"FlowType\"];\nexport const FLOWBASEANNOTATION_TYPES =\n  FLIPPED_ALIAS_KEYS[\"FlowBaseAnnotation\"];\nexport const FLOWDECLARATION_TYPES = FLIPPED_ALIAS_KEYS[\"FlowDeclaration\"];\nexport const FLOWPREDICATE_TYPES = FLIPPED_ALIAS_KEYS[\"FlowPredicate\"];\nexport const ENUMBODY_TYPES = FLIPPED_ALIAS_KEYS[\"EnumBody\"];\nexport const ENUMMEMBER_TYPES = FLIPPED_ALIAS_KEYS[\"EnumMember\"];\nexport const JSX_TYPES = FLIPPED_ALIAS_KEYS[\"JSX\"];\nexport const MISCELLANEOUS_TYPES = FLIPPED_ALIAS_KEYS[\"Miscellaneous\"];\nexport const TYPESCRIPT_TYPES = FLIPPED_ALIAS_KEYS[\"TypeScript\"];\nexport const TSTYPEELEMENT_TYPES = FLIPPED_ALIAS_KEYS[\"TSTypeElement\"];\nexport const TSTYPE_TYPES = FLIPPED_ALIAS_KEYS[\"TSType\"];\nexport const TSBASETYPE_TYPES = FLIPPED_ALIAS_KEYS[\"TSBaseType\"];\n","import toBlock from \"./toBlock\";\nimport type * as t from \"..\";\n\n/**\n * Ensure the `key` (defaults to \"body\") of a `node` is a block.\n * Casting it to a block if it is not.\n *\n * Returns the BlockStatement\n */\nexport default function ensureBlock(\n  node: t.Node,\n  key: string = \"body\",\n): t.BlockStatement {\n  // @ts-expect-error Fixme: key may not exist in node, consider remove key = \"body\"\n  const result = toBlock(node[key], node);\n  // @ts-expect-error Fixme: key may not exist in node, consider remove key = \"body\"\n  node[key] = result;\n  return result;\n}\n","import toIdentifier from \"./toIdentifier\";\n\nexport default function toBindingIdentifierName(name: string): string {\n  name = toIdentifier(name);\n  if (name === \"eval\" || name === \"arguments\") name = \"_\" + name;\n\n  return name;\n}\n","import { isIdentifier } from \"../validators/generated\";\nimport { stringLiteral } from \"../builders/generated\";\nimport type * as t from \"..\";\n\nexport default function toComputedKey(\n  node:\n    | t.ObjectMember\n    | t.ObjectProperty\n    | t.ClassMethod\n    | t.ClassProperty\n    | t.ClassAccessorProperty\n    | t.MemberExpression\n    | t.OptionalMemberExpression,\n  // @ts-expect-error todo(flow->ts): maybe check the type of node before accessing .key and .property\n  key: t.Expression | t.PrivateName = node.key || node.property,\n) {\n  if (!node.computed && isIdentifier(key)) key = stringLiteral(key.name);\n\n  return key;\n}\n","import {\n  isExpression,\n  isFunction,\n  isClass,\n  isExpressionStatement,\n} from \"../validators/generated\";\nimport type * as t from \"..\";\n\nexport default toExpression as {\n  (node: t.Function): t.FunctionExpression;\n  (node: t.Class): t.ClassExpression;\n  (\n    node: t.ExpressionStatement | t.Expression | t.Class | t.Function,\n  ): t.Expression;\n};\n\nfunction toExpression(\n  node: t.ExpressionStatement | t.Expression | t.Class | t.Function,\n): t.Expression {\n  if (isExpressionStatement(node)) {\n    node = node.expression;\n  }\n\n  // return unmodified node\n  // important for things like ArrowFunctions where\n  // type change from ArrowFunction to FunctionExpression\n  // produces bugs like -> `()=>a` to `function () a`\n  // without generating a BlockStatement for it\n  // ref: https://github.com/babel/babili/issues/130\n  if (isExpression(node)) {\n    return node;\n  }\n\n  // convert all classes and functions\n  // ClassDeclaration -> ClassExpression\n  // FunctionDeclaration, ObjectMethod, ClassMethod -> FunctionExpression\n  if (isClass(node)) {\n    // @ts-expect-error todo(flow->ts): avoid type unsafe mutations\n    node.type = \"ClassExpression\";\n  } else if (isFunction(node)) {\n    // @ts-expect-error todo(flow->ts): avoid type unsafe mutations\n    node.type = \"FunctionExpression\";\n  }\n\n  // if it's still not an expression\n  if (!isExpression(node)) {\n    throw new Error(`cannot turn ${node.type} to an expression`);\n  }\n\n  return node;\n}\n","import { isIdentifier, isStringLiteral } from \"../validators/generated\";\nimport cloneNode from \"../clone/cloneNode\";\nimport removePropertiesDeep from \"../modifications/removePropertiesDeep\";\nimport type * as t from \"..\";\n\nexport default function toKeyAlias(\n  node: t.Method | t.Property,\n  key: t.Node = node.key,\n): string {\n  let alias;\n\n  // @ts-expect-error todo(flow->ts): maybe add node type check before checking `.kind`\n  if (node.kind === \"method\") {\n    return toKeyAlias.increment() + \"\";\n  } else if (isIdentifier(key)) {\n    alias = key.name;\n  } else if (isStringLiteral(key)) {\n    alias = JSON.stringify(key.value);\n  } else {\n    alias = JSON.stringify(removePropertiesDeep(cloneNode(key)));\n  }\n\n  // @ts-expect-error todo(flow->ts): maybe add node type check before checking `.computed`\n  if (node.computed) {\n    alias = `[${alias}]`;\n  }\n\n  // @ts-expect-error todo(flow->ts): maybe add node type check before checking `.static`\n  if (node.static) {\n    alias = `static:${alias}`;\n  }\n\n  return alias;\n}\n\ntoKeyAlias.uid = 0;\n\ntoKeyAlias.increment = function () {\n  if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) {\n    return (toKeyAlias.uid = 0);\n  } else {\n    return toKeyAlias.uid++;\n  }\n};\n","import gatherSequenceExpressions from \"./gatherSequenceExpressions\";\nimport type * as t from \"..\";\nimport type { DeclarationInfo } from \"./gatherSequenceExpressions\";\n\n/**\n * Turn an array of statement `nodes` into a `SequenceExpression`.\n *\n * Variable declarations are turned into simple assignments and their\n * declarations hoisted to the top of the current scope.\n *\n * Expression statements are just resolved to their expression.\n */\nexport default function toSequenceExpression(\n  nodes: ReadonlyArray<t.Node>,\n  scope: any,\n): t.SequenceExpression | undefined {\n  if (!nodes?.length) return;\n\n  const declars: DeclarationInfo[] = [];\n  const result = gatherSequenceExpressions(nodes, scope, declars);\n  if (!result) return;\n\n  for (const declar of declars) {\n    scope.push(declar);\n  }\n\n  // @ts-expect-error fixme: gatherSequenceExpressions will return an Expression when there are only one element\n  return result;\n}\n","import getBindingIdentifiers from \"../retrievers/getBindingIdentifiers\";\nimport {\n  isExpression,\n  isExpressionStatement,\n  isVariableDeclaration,\n  isIfStatement,\n  isBlockStatement,\n  isEmptyStatement,\n} from \"../validators/generated\";\nimport {\n  sequenceExpression,\n  assignmentExpression,\n  conditionalExpression,\n} from \"../builders/generated\";\nimport cloneNode from \"../clone/cloneNode\";\nimport type * as t from \"..\";\nimport type { Scope } from \"@babel/traverse\";\n\nexport type DeclarationInfo = {\n  kind: t.VariableDeclaration[\"kind\"];\n  id: t.Identifier;\n};\n\nexport default function gatherSequenceExpressions(\n  nodes: ReadonlyArray<t.Node>,\n  scope: Scope,\n  declars: Array<DeclarationInfo>,\n) {\n  const exprs: t.Expression[] = [];\n  let ensureLastUndefined = true;\n\n  for (const node of nodes) {\n    // if we encounter emptyStatement before a non-emptyStatement\n    // we want to disregard that\n    if (!isEmptyStatement(node)) {\n      ensureLastUndefined = false;\n    }\n\n    if (isExpression(node)) {\n      exprs.push(node);\n    } else if (isExpressionStatement(node)) {\n      exprs.push(node.expression);\n    } else if (isVariableDeclaration(node)) {\n      if (node.kind !== \"var\") return; // bailed\n\n      for (const declar of node.declarations) {\n        const bindings = getBindingIdentifiers(declar);\n        for (const key of Object.keys(bindings)) {\n          declars.push({\n            kind: node.kind,\n            id: cloneNode(bindings[key]),\n          });\n        }\n\n        if (declar.init) {\n          exprs.push(assignmentExpression(\"=\", declar.id, declar.init));\n        }\n      }\n\n      ensureLastUndefined = true;\n    } else if (isIfStatement(node)) {\n      const consequent = node.consequent\n        ? gatherSequenceExpressions([node.consequent], scope, declars)\n        : scope.buildUndefinedNode();\n      const alternate = node.alternate\n        ? gatherSequenceExpressions([node.alternate], scope, declars)\n        : scope.buildUndefinedNode();\n      if (!consequent || !alternate) return; // bailed\n\n      exprs.push(conditionalExpression(node.test, consequent, alternate));\n    } else if (isBlockStatement(node)) {\n      const body = gatherSequenceExpressions(node.body, scope, declars);\n      if (!body) return; // bailed\n\n      exprs.push(body);\n    } else if (isEmptyStatement(node)) {\n      // empty statement so ensure the last item is undefined if we're last\n      // checks if emptyStatement is first\n      if (nodes.indexOf(node) === 0) {\n        ensureLastUndefined = true;\n      }\n    } else {\n      // bailed, we can't turn this statement into an expression\n      return;\n    }\n  }\n\n  if (ensureLastUndefined) {\n    exprs.push(scope.buildUndefinedNode());\n  }\n\n  if (exprs.length === 1) {\n    return exprs[0];\n  } else {\n    return sequenceExpression(exprs);\n  }\n}\n","import {\n  isStatement,\n  isFunction,\n  isClass,\n  isAssignmentExpression,\n} from \"../validators/generated\";\nimport { expressionStatement } from \"../builders/generated\";\nimport type * as t from \"..\";\n\nexport default toStatement as {\n  (node: t.AssignmentExpression, ignore?: boolean): t.ExpressionStatement;\n\n  <T extends t.Statement>(node: T, ignore: false): T;\n  <T extends t.Statement>(node: T, ignore?: boolean): T | false;\n\n  (node: t.Class, ignore: false): t.ClassDeclaration;\n  (node: t.Class, ignore?: boolean): t.ClassDeclaration | false;\n\n  (node: t.Function, ignore: false): t.FunctionDeclaration;\n  (node: t.Function, ignore?: boolean): t.FunctionDeclaration | false;\n\n  (node: t.Node, ignore: false): t.Statement;\n  (node: t.Node, ignore?: boolean): t.Statement | false;\n};\n\nfunction toStatement(node: t.Node, ignore?: boolean): t.Statement | false {\n  if (isStatement(node)) {\n    return node;\n  }\n\n  let mustHaveId = false;\n  let newType;\n\n  if (isClass(node)) {\n    mustHaveId = true;\n    newType = \"ClassDeclaration\" as const;\n  } else if (isFunction(node)) {\n    mustHaveId = true;\n    newType = \"FunctionDeclaration\" as const;\n  } else if (isAssignmentExpression(node)) {\n    return expressionStatement(node);\n  }\n\n  // @ts-expect-error todo(flow->ts): node.id might be missing\n  if (mustHaveId && !node.id) {\n    newType = false as false;\n  }\n\n  if (!newType) {\n    if (ignore) {\n      return false;\n    } else {\n      throw new Error(`cannot turn ${node.type} to a statement`);\n    }\n  }\n\n  // @ts-expect-error manipulating node.type\n  node.type = newType;\n\n  // @ts-expect-error todo(flow->ts) refactor to avoid type unsafe mutations like reassigning node type above\n  return node;\n}\n","import isValidIdentifier from \"../validators/isValidIdentifier\";\nimport {\n  identifier,\n  booleanLiteral,\n  nullLiteral,\n  stringLiteral,\n  numericLiteral,\n  regExpLiteral,\n  arrayExpression,\n  objectProperty,\n  objectExpression,\n  unaryExpression,\n  binaryExpression,\n} from \"../builders/generated\";\nimport type * as t from \"..\";\n\nexport default valueToNode as {\n  (value: undefined): t.Identifier; // TODO: This should return \"void 0\"\n  (value: boolean): t.BooleanLiteral;\n  (value: null): t.NullLiteral;\n  (value: string): t.StringLiteral;\n  // Infinities and NaN need to use a BinaryExpression; negative values must be wrapped in UnaryExpression\n  (value: number): t.NumericLiteral | t.BinaryExpression | t.UnaryExpression;\n  (value: RegExp): t.RegExpLiteral;\n  (value: ReadonlyArray<unknown>): t.ArrayExpression;\n\n  // this throws with objects that are not plain objects,\n  // or if there are non-valueToNode-able values\n  (value: object): t.ObjectExpression;\n\n  (value: unknown): t.Expression;\n};\n\n// @ts-expect-error: Object.prototype.toString must return a string\nconst objectToString: (value: unknown) => string = Function.call.bind(\n  Object.prototype.toString,\n);\n\nfunction isRegExp(value: unknown): value is RegExp {\n  return objectToString(value) === \"[object RegExp]\";\n}\n\nfunction isPlainObject(value: unknown): value is object {\n  if (\n    typeof value !== \"object\" ||\n    value === null ||\n    Object.prototype.toString.call(value) !== \"[object Object]\"\n  ) {\n    return false;\n  }\n  const proto = Object.getPrototypeOf(value);\n  // Object.prototype's __proto__ is null. Every other class's __proto__.__proto__ is\n  // not null by default. We cannot check if proto === Object.prototype because it\n  // could come from another realm.\n  return proto === null || Object.getPrototypeOf(proto) === null;\n}\n\nfunction valueToNode(value: unknown): t.Expression {\n  // undefined\n  if (value === undefined) {\n    return identifier(\"undefined\");\n  }\n\n  // boolean\n  if (value === true || value === false) {\n    return booleanLiteral(value);\n  }\n\n  // null\n  if (value === null) {\n    return nullLiteral();\n  }\n\n  // strings\n  if (typeof value === \"string\") {\n    return stringLiteral(value);\n  }\n\n  // numbers\n  if (typeof value === \"number\") {\n    let result;\n    if (Number.isFinite(value)) {\n      result = numericLiteral(Math.abs(value));\n    } else {\n      let numerator;\n      if (Number.isNaN(value)) {\n        // NaN\n        numerator = numericLiteral(0);\n      } else {\n        // Infinity / -Infinity\n        numerator = numericLiteral(1);\n      }\n\n      result = binaryExpression(\"/\", numerator, numericLiteral(0));\n    }\n\n    if (value < 0 || Object.is(value, -0)) {\n      result = unaryExpression(\"-\", result);\n    }\n\n    return result;\n  }\n\n  // regexes\n  if (isRegExp(value)) {\n    const pattern = value.source;\n    const flags = value.toString().match(/\\/([a-z]+|)$/)[1];\n    return regExpLiteral(pattern, flags);\n  }\n\n  // array\n  if (Array.isArray(value)) {\n    return arrayExpression(value.map(valueToNode));\n  }\n\n  // object\n  if (isPlainObject(value)) {\n    const props = [];\n    for (const key of Object.keys(value)) {\n      let nodeKey;\n      if (isValidIdentifier(key)) {\n        nodeKey = identifier(key);\n      } else {\n        nodeKey = stringLiteral(key);\n      }\n      props.push(\n        objectProperty(\n          nodeKey,\n          valueToNode(\n            // @ts-expect-error key must present in value\n            value[key],\n          ),\n        ),\n      );\n    }\n    return objectExpression(props);\n  }\n\n  throw new Error(\"don't know how to turn this value into a node\");\n}\n","import { memberExpression } from \"../builders/generated\";\nimport type * as t from \"..\";\n\n/**\n * Append a node to a member expression.\n */\nexport default function appendToMemberExpression(\n  member: t.MemberExpression,\n  append: t.MemberExpression[\"property\"],\n  computed: boolean = false,\n): t.MemberExpression {\n  member.object = memberExpression(\n    member.object,\n    member.property,\n    member.computed,\n  );\n  member.property = append;\n  member.computed = !!computed;\n\n  return member;\n}\n","import { INHERIT_KEYS } from \"../constants\";\nimport inheritsComments from \"../comments/inheritsComments\";\nimport type * as t from \"..\";\n\n/**\n * Inherit all contextual properties from `parent` node to `child` node.\n */\nexport default function inherits<T extends t.Node | null | undefined>(\n  child: T,\n  parent: t.Node | null | undefined,\n): T {\n  if (!child || !parent) return child;\n\n  // optionally inherit specific properties if not null\n  for (const key of INHERIT_KEYS.optional) {\n    // @ts-expect-error Fixme: refine parent types\n    if (child[key] == null) {\n      // @ts-expect-error Fixme: refine parent types\n      child[key] = parent[key];\n    }\n  }\n\n  // force inherit \"private\" properties\n  for (const key of Object.keys(parent)) {\n    if (key[0] === \"_\" && key !== \"__clone\") {\n      // @ts-expect-error Fixme: refine parent types\n      child[key] = parent[key];\n    }\n  }\n\n  // force inherit select properties\n  for (const key of INHERIT_KEYS.force) {\n    // @ts-expect-error Fixme: refine parent types\n    child[key] = parent[key];\n  }\n\n  inheritsComments(child, parent);\n\n  return child;\n}\n","import { memberExpression } from \"../builders/generated\";\nimport { isSuper } from \"..\";\nimport type * as t from \"..\";\n\n/**\n * Prepend a node to a member expression.\n */\nexport default function prependToMemberExpression<\n  T extends Pick<t.MemberExpression, \"object\" | \"property\">,\n>(member: T, prepend: t.MemberExpression[\"object\"]): T {\n  if (isSuper(member.object)) {\n    throw new Error(\n      \"Cannot prepend node to super property access (`super.foo`).\",\n    );\n  }\n  member.object = memberExpression(prepend, member.object);\n\n  return member;\n}\n","import getBindingIdentifiers from \"./getBindingIdentifiers\";\nimport type * as t from \"..\";\n\nexport default getOuterBindingIdentifiers as {\n  (node: t.Node, duplicates: true): Record<string, Array<t.Identifier>>;\n  (node: t.Node, duplicates?: false): Record<string, t.Identifier>;\n  (node: t.Node, duplicates?: boolean):\n    | Record<string, t.Identifier>\n    | Record<string, Array<t.Identifier>>;\n};\n\nfunction getOuterBindingIdentifiers(\n  node: t.Node,\n  duplicates: boolean,\n): Record<string, t.Identifier> | Record<string, Array<t.Identifier>> {\n  return getBindingIdentifiers(node, duplicates, true);\n}\n","import { VISITOR_KEYS } from \"../definitions\";\nimport type * as t from \"..\";\n\nexport type TraversalAncestors = Array<{\n  node: t.Node;\n  key: string;\n  index?: number;\n}>;\n\nexport type TraversalHandler<T> = (\n  this: undefined,\n  node: t.Node,\n  parent: TraversalAncestors,\n  state: T,\n) => void;\n\nexport type TraversalHandlers<T> = {\n  enter?: TraversalHandler<T>;\n  exit?: TraversalHandler<T>;\n};\n\n/**\n * A general AST traversal with both prefix and postfix handlers, and a\n * state object. Exposes ancestry data to each handler so that more complex\n * AST data can be taken into account.\n */\nexport default function traverse<T>(\n  node: t.Node,\n  handlers: TraversalHandler<T> | TraversalHandlers<T>,\n  state?: T,\n): void {\n  if (typeof handlers === \"function\") {\n    handlers = { enter: handlers };\n  }\n\n  const { enter, exit } = handlers;\n\n  traverseSimpleImpl(node, enter, exit, state, []);\n}\n\nfunction traverseSimpleImpl<T>(\n  node: any,\n  enter: Function | undefined,\n  exit: Function | undefined,\n  state: T | undefined,\n  ancestors: TraversalAncestors,\n) {\n  const keys = VISITOR_KEYS[node.type];\n  if (!keys) return;\n\n  if (enter) enter(node, ancestors, state);\n\n  for (const key of keys) {\n    const subNode = node[key];\n\n    if (Array.isArray(subNode)) {\n      for (let i = 0; i < subNode.length; i++) {\n        const child = subNode[i];\n        if (!child) continue;\n\n        ancestors.push({\n          node,\n          key,\n          index: i,\n        });\n\n        traverseSimpleImpl(child, enter, exit, state, ancestors);\n\n        ancestors.pop();\n      }\n    } else if (subNode) {\n      ancestors.push({\n        node,\n        key,\n      });\n\n      traverseSimpleImpl(subNode, enter, exit, state, ancestors);\n\n      ancestors.pop();\n    }\n  }\n\n  if (exit) exit(node, ancestors, state);\n}\n","import getBindingIdentifiers from \"../retrievers/getBindingIdentifiers\";\nimport type * as t from \"..\";\n/**\n * Check if the input `node` is a binding identifier.\n */\nexport default function isBinding(\n  node: t.Node,\n  parent: t.Node,\n  grandparent?: t.Node,\n): boolean {\n  if (\n    grandparent &&\n    node.type === \"Identifier\" &&\n    parent.type === \"ObjectProperty\" &&\n    grandparent.type === \"ObjectExpression\"\n  ) {\n    // We need to special-case this, because getBindingIdentifiers\n    // has an ObjectProperty->value entry for destructuring patterns.\n    return false;\n  }\n\n  const keys =\n    // @ts-expect-error getBindingIdentifiers.keys does not cover all AST types\n    getBindingIdentifiers.keys[parent.type];\n  if (keys) {\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n      const val =\n        // @ts-expect-error key must present in parent\n        parent[key];\n      if (Array.isArray(val)) {\n        if (val.indexOf(node) >= 0) return true;\n      } else {\n        if (val === node) return true;\n      }\n    }\n  }\n\n  return false;\n}\n","import { isClassDeclaration, isFunctionDeclaration } from \"./generated\";\nimport isLet from \"./isLet\";\nimport type * as t from \"..\";\n\n/**\n * Check if the input `node` is block scoped.\n */\nexport default function isBlockScoped(node: t.Node): boolean {\n  return isFunctionDeclaration(node) || isClassDeclaration(node) || isLet(node);\n}\n","import isType from \"./isType\";\nimport { isIdentifier } from \"./generated\";\nimport type * as t from \"..\";\n\n/**\n * Check if the input `node` is definitely immutable.\n */\nexport default function isImmutable(node: t.Node): boolean {\n  if (isType(node.type, \"Immutable\")) return true;\n\n  if (isIdentifier(node)) {\n    if (node.name === \"undefined\") {\n      // immutable!\n      return true;\n    } else {\n      // no idea...\n      return false;\n    }\n  }\n\n  return false;\n}\n","import { NODE_FIELDS, VISITOR_KEYS } from \"../definitions\";\nimport type * as t from \"..\";\n\n/**\n * Check if two nodes are equivalent\n */\nexport default function isNodesEquivalent<T extends Partial<t.Node>>(\n  a: T,\n  b: any,\n): b is T {\n  if (\n    typeof a !== \"object\" ||\n    typeof b !== \"object\" ||\n    a == null ||\n    b == null\n  ) {\n    return a === b;\n  }\n\n  if (a.type !== b.type) {\n    return false;\n  }\n\n  const fields = Object.keys(NODE_FIELDS[a.type] || a.type);\n  const visitorKeys = VISITOR_KEYS[a.type];\n\n  for (const field of fields) {\n    const val_a =\n      // @ts-expect-error field must present in a\n      a[field];\n    const val_b = b[field];\n    if (typeof val_a !== typeof val_b) {\n      return false;\n    }\n    if (val_a == null && val_b == null) {\n      continue;\n    } else if (val_a == null || val_b == null) {\n      return false;\n    }\n\n    if (Array.isArray(val_a)) {\n      if (!Array.isArray(val_b)) {\n        return false;\n      }\n      if (val_a.length !== val_b.length) {\n        return false;\n      }\n\n      for (let i = 0; i < val_a.length; i++) {\n        if (!isNodesEquivalent(val_a[i], val_b[i])) {\n          return false;\n        }\n      }\n      continue;\n    }\n\n    if (typeof val_a === \"object\" && !visitorKeys?.includes(field)) {\n      for (const key of Object.keys(val_a)) {\n        if (val_a[key] !== val_b[key]) {\n          return false;\n        }\n      }\n      continue;\n    }\n\n    if (!isNodesEquivalent(val_a, val_b)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import type * as t from \"..\";\n\n/**\n * Check if the input `node` is a reference to a bound variable.\n */\nexport default function isReferenced(\n  node: t.Node,\n  parent: t.Node,\n  grandparent?: t.Node,\n): boolean {\n  switch (parent.type) {\n    // yes: PARENT[NODE]\n    // yes: NODE.child\n    // no: parent.NODE\n    case \"MemberExpression\":\n    case \"OptionalMemberExpression\":\n      if (parent.property === node) {\n        return !!parent.computed;\n      }\n      return parent.object === node;\n\n    case \"JSXMemberExpression\":\n      return parent.object === node;\n    // no: let NODE = init;\n    // yes: let id = NODE;\n    case \"VariableDeclarator\":\n      return parent.init === node;\n\n    // yes: () => NODE\n    // no: (NODE) => {}\n    case \"ArrowFunctionExpression\":\n      return parent.body === node;\n\n    // no: class { #NODE; }\n    // no: class { get #NODE() {} }\n    // no: class { #NODE() {} }\n    // no: class { fn() { return this.#NODE; } }\n    case \"PrivateName\":\n      return false;\n\n    // no: class { NODE() {} }\n    // yes: class { [NODE]() {} }\n    // no: class { foo(NODE) {} }\n    case \"ClassMethod\":\n    case \"ClassPrivateMethod\":\n    case \"ObjectMethod\":\n      if (parent.key === node) {\n        return !!parent.computed;\n      }\n      return false;\n\n    // yes: { [NODE]: \"\" }\n    // no: { NODE: \"\" }\n    // depends: { NODE }\n    // depends: { key: NODE }\n    case \"ObjectProperty\":\n      if (parent.key === node) {\n        return !!parent.computed;\n      }\n      // parent.value === node\n      return !grandparent || grandparent.type !== \"ObjectPattern\";\n    // no: class { NODE = value; }\n    // yes: class { [NODE] = value; }\n    // yes: class { key = NODE; }\n    case \"ClassProperty\":\n    case \"ClassAccessorProperty\":\n      if (parent.key === node) {\n        return !!parent.computed;\n      }\n      return true;\n    case \"ClassPrivateProperty\":\n      return parent.key !== node;\n\n    // no: class NODE {}\n    // yes: class Foo extends NODE {}\n    case \"ClassDeclaration\":\n    case \"ClassExpression\":\n      return parent.superClass === node;\n\n    // yes: left = NODE;\n    // no: NODE = right;\n    case \"AssignmentExpression\":\n      return parent.right === node;\n\n    // no: [NODE = foo] = [];\n    // yes: [foo = NODE] = [];\n    case \"AssignmentPattern\":\n      return parent.right === node;\n\n    // no: NODE: for (;;) {}\n    case \"LabeledStatement\":\n      return false;\n\n    // no: try {} catch (NODE) {}\n    case \"CatchClause\":\n      return false;\n\n    // no: function foo(...NODE) {}\n    case \"RestElement\":\n      return false;\n\n    case \"BreakStatement\":\n    case \"ContinueStatement\":\n      return false;\n\n    // no: function NODE() {}\n    // no: function foo(NODE) {}\n    case \"FunctionDeclaration\":\n    case \"FunctionExpression\":\n      return false;\n\n    // no: export NODE from \"foo\";\n    // no: export * as NODE from \"foo\";\n    case \"ExportNamespaceSpecifier\":\n    case \"ExportDefaultSpecifier\":\n      return false;\n\n    // no: export { foo as NODE };\n    // yes: export { NODE as foo };\n    // no: export { NODE as foo } from \"foo\";\n    case \"ExportSpecifier\":\n      // @ts-expect-error todo(flow->ts): Property 'source' does not exist on type 'AnyTypeAnnotation'.\n      if (grandparent?.source) {\n        return false;\n      }\n      return parent.local === node;\n\n    // no: import NODE from \"foo\";\n    // no: import * as NODE from \"foo\";\n    // no: import { NODE as foo } from \"foo\";\n    // no: import { foo as NODE } from \"foo\";\n    // no: import NODE from \"bar\";\n    case \"ImportDefaultSpecifier\":\n    case \"ImportNamespaceSpecifier\":\n    case \"ImportSpecifier\":\n      return false;\n\n    // no: import \"foo\" assert { NODE: \"json\" }\n    case \"ImportAttribute\":\n      return false;\n\n    // no: <div NODE=\"foo\" />\n    case \"JSXAttribute\":\n      return false;\n\n    // no: [NODE] = [];\n    // no: ({ NODE }) = [];\n    case \"ObjectPattern\":\n    case \"ArrayPattern\":\n      return false;\n\n    // no: new.NODE\n    // no: NODE.target\n    case \"MetaProperty\":\n      return false;\n\n    // yes: type X = { somePropert: NODE }\n    // no: type X = { NODE: OtherType }\n    case \"ObjectTypeProperty\":\n      return parent.key !== node;\n\n    // yes: enum X { Foo = NODE }\n    // no: enum X { NODE }\n    case \"TSEnumMember\":\n      return parent.id !== node;\n\n    // yes: { [NODE]: value }\n    // no: { NODE: value }\n    case \"TSPropertySignature\":\n      if (parent.key === node) {\n        return !!parent.computed;\n      }\n\n      return true;\n  }\n\n  return true;\n}\n","import {\n  isFunction,\n  isCatchClause,\n  isBlockStatement,\n  isScopable,\n  isPattern,\n} from \"./generated\";\nimport type * as t from \"..\";\n\n/**\n * Check if the input `node` is a scope.\n */\nexport default function isScope(node: t.Node, parent: t.Node): boolean {\n  // If a BlockStatement is an immediate descendent of a Function/CatchClause, it must be in the body.\n  // Hence we skipped the parentKey === \"params\" check\n  if (isBlockStatement(node) && (isFunction(parent) || isCatchClause(parent))) {\n    return false;\n  }\n\n  // If a Pattern is an immediate descendent of a Function/CatchClause, it must be in the params.\n  // Hence we skipped the parentKey === \"params\" check\n  if (isPattern(node) && (isFunction(parent) || isCatchClause(parent))) {\n    return true;\n  }\n\n  return isScopable(node);\n}\n","import { isIdentifier, isImportDefaultSpecifier } from \"./generated\";\nimport type * as t from \"..\";\n\n/**\n * Check if the input `specifier` is a `default` import or export.\n */\nexport default function isSpecifierDefault(\n  specifier: t.ModuleSpecifier,\n): boolean {\n  return (\n    isImportDefaultSpecifier(specifier) ||\n    // @ts-expect-error todo(flow->ts): stricter type for specifier\n    isIdentifier(specifier.imported || specifier.exported, {\n      name: \"default\",\n    })\n  );\n}\n","import isValidIdentifier from \"./isValidIdentifier\";\n\nconst RESERVED_WORDS_ES3_ONLY: Set<string> = new Set([\n  \"abstract\",\n  \"boolean\",\n  \"byte\",\n  \"char\",\n  \"double\",\n  \"enum\",\n  \"final\",\n  \"float\",\n  \"goto\",\n  \"implements\",\n  \"int\",\n  \"interface\",\n  \"long\",\n  \"native\",\n  \"package\",\n  \"private\",\n  \"protected\",\n  \"public\",\n  \"short\",\n  \"static\",\n  \"synchronized\",\n  \"throws\",\n  \"transient\",\n  \"volatile\",\n]);\n\n/**\n * Check if the input `name` is a valid identifier name according to the ES3 specification.\n *\n * Additional ES3 reserved words are\n */\nexport default function isValidES3Identifier(name: string): boolean {\n  return isValidIdentifier(name) && !RESERVED_WORDS_ES3_ONLY.has(name);\n}\n","import { isVariableDeclaration } from \"./generated\";\nimport { BLOCK_SCOPED_SYMBOL } from \"../constants\";\nimport type * as t from \"..\";\n\n/**\n * Check if the input `node` is a variable declaration.\n */\nexport default function isVar(node: t.Node): boolean {\n  return (\n    isVariableDeclaration(node, { kind: \"var\" }) &&\n    !(\n      // @ts-expect-error document private properties\n      node[BLOCK_SCOPED_SYMBOL]\n    )\n  );\n}\n"],"sourceRoot":""}

Zerion Mini Shell 1.0