/** * Copyright (c) Meta Platforms, Inc. and affiliates. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. * * * @generated */ /* * !!! GENERATED FILE !!! * * Any manual changes to this file will be overwritten. To regenerate run `yarn build`. */ // lint directives to let us do some basic validation of generated files /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */ /* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray, $FlowFixMe */ 'use strict'; /*:: import type { ESNode, Token, AFunction, ClassMember, BigIntLiteral, BooleanLiteral, NullLiteral, NumericLiteral, RegExpLiteral, StringLiteral, Identifier, JSXIdentifier, JSXText, AnyTypeAnnotation, ArrayExpression, ArrayPattern, ArrayTypeAnnotation, ArrowFunctionExpression, AsConstExpression, AsExpression, AssignmentExpression, AssignmentPattern, AwaitExpression, BigIntLiteralTypeAnnotation, BigIntTypeAnnotation, BinaryExpression, BlockStatement, BooleanLiteralTypeAnnotation, BooleanTypeAnnotation, BreakStatement, CallExpression, CatchClause, ChainExpression, ClassBody, ClassDeclaration, ClassExpression, ClassImplements, ComponentDeclaration, ComponentParameter, ComponentTypeAnnotation, ComponentTypeParameter, ConditionalExpression, ConditionalTypeAnnotation, ContinueStatement, DebuggerStatement, DeclareClass, DeclareComponent, DeclaredPredicate, DeclareEnum, DeclareExportAllDeclaration, DeclareExportDeclaration, DeclareFunction, DeclareHook, DeclareInterface, DeclareModule, DeclareModuleExports, DeclareNamespace, DeclareOpaqueType, DeclareTypeAlias, DeclareVariable, DoWhileStatement, EmptyStatement, EmptyTypeAnnotation, EnumBigIntBody, EnumBigIntMember, EnumBooleanBody, EnumBooleanMember, EnumDeclaration, EnumDefaultedMember, EnumNumberBody, EnumNumberMember, EnumStringBody, EnumStringMember, EnumSymbolBody, ExistsTypeAnnotation, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier, ExpressionStatement, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeAnnotation, FunctionTypeParam, GenericTypeAnnotation, HookDeclaration, HookTypeAnnotation, IfStatement, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier, IndexedAccessType, InferredPredicate, InferTypeAnnotation, InterfaceDeclaration, InterfaceExtends, InterfaceTypeAnnotation, IntersectionTypeAnnotation, JSXAttribute, JSXClosingElement, JSXClosingFragment, JSXElement, JSXEmptyExpression, JSXExpressionContainer, JSXFragment, JSXMemberExpression, JSXNamespacedName, JSXOpeningElement, JSXOpeningFragment, JSXSpreadAttribute, JSXSpreadChild, KeyofTypeAnnotation, LabeledStatement, LogicalExpression, MemberExpression, MetaProperty, MethodDefinition, MixedTypeAnnotation, NewExpression, NullableTypeAnnotation, NullLiteralTypeAnnotation, NumberLiteralTypeAnnotation, NumberTypeAnnotation, ObjectExpression, ObjectPattern, ObjectTypeAnnotation, ObjectTypeCallProperty, ObjectTypeIndexer, ObjectTypeInternalSlot, ObjectTypeMappedTypeProperty, ObjectTypeProperty, ObjectTypeSpreadProperty, OpaqueType, OptionalIndexedAccessType, PrivateIdentifier, Program, Property, PropertyDefinition, QualifiedTypeIdentifier, QualifiedTypeofIdentifier, RestElement, ReturnStatement, SequenceExpression, SpreadElement, StringLiteralTypeAnnotation, StringTypeAnnotation, Super, SwitchCase, SwitchStatement, SymbolTypeAnnotation, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThisTypeAnnotation, ThrowStatement, TryStatement, TupleTypeAnnotation, TupleTypeLabeledElement, TupleTypeSpreadElement, TypeAlias, TypeAnnotation, TypeCastExpression, TypeofTypeAnnotation, TypeOperator, TypeParameter, TypeParameterDeclaration, TypeParameterInstantiation, TypePredicate, UnaryExpression, UnionTypeAnnotation, UpdateExpression, VariableDeclaration, VariableDeclarator, Variance, VoidTypeAnnotation, WhileStatement, WithStatement, YieldExpression, Literal, LineComment, BlockComment, MostTokens, } from '../types'; */ Object.defineProperty(exports, "__esModule", { value: true }); exports.isAnyTypeAnnotation = isAnyTypeAnnotation; exports.isArrayExpression = isArrayExpression; exports.isArrayPattern = isArrayPattern; exports.isArrayTypeAnnotation = isArrayTypeAnnotation; exports.isArrowFunctionExpression = isArrowFunctionExpression; exports.isAsConstExpression = isAsConstExpression; exports.isAsExpression = isAsExpression; exports.isAsKeyword = isAsKeyword; exports.isAssignmentExpression = isAssignmentExpression; exports.isAssignmentPattern = isAssignmentPattern; exports.isAsterixToken = isAsterixToken; exports.isAsyncKeyword = isAsyncKeyword; exports.isAwaitExpression = isAwaitExpression; exports.isAwaitKeyword = isAwaitKeyword; exports.isBigIntLiteralTypeAnnotation = isBigIntLiteralTypeAnnotation; exports.isBigIntTypeAnnotation = isBigIntTypeAnnotation; exports.isBinaryExpression = isBinaryExpression; exports.isBitwiseANDEqualToken = isBitwiseANDEqualToken; exports.isBitwiseANDToken = isBitwiseANDToken; exports.isBitwiseLeftShiftEqualToken = isBitwiseLeftShiftEqualToken; exports.isBitwiseLeftShiftToken = isBitwiseLeftShiftToken; exports.isBitwiseOREqualToken = isBitwiseOREqualToken; exports.isBitwiseORToken = isBitwiseORToken; exports.isBitwiseRightShiftEqualToken = isBitwiseRightShiftEqualToken; exports.isBitwiseRightShiftToken = isBitwiseRightShiftToken; exports.isBitwiseUnsignedRightShiftEqualToken = isBitwiseUnsignedRightShiftEqualToken; exports.isBitwiseUnsignedRightShiftToken = isBitwiseUnsignedRightShiftToken; exports.isBitwiseXOREqualToken = isBitwiseXOREqualToken; exports.isBitwiseXORToken = isBitwiseXORToken; exports.isBlockComment = isBlockComment; exports.isBlockStatement = isBlockStatement; exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation; exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation; exports.isBreakStatement = isBreakStatement; exports.isBreakToken = isBreakToken; exports.isCallExpression = isCallExpression; exports.isCaseToken = isCaseToken; exports.isCatchClause = isCatchClause; exports.isCatchToken = isCatchToken; exports.isChainExpression = isChainExpression; exports.isClassBody = isClassBody; exports.isClassDeclaration = isClassDeclaration; exports.isClassExpression = isClassExpression; exports.isClassImplements = isClassImplements; exports.isClassToken = isClassToken; exports.isClosingAngleBracketToken = isClosingAngleBracketToken; exports.isClosingCurlyBracketToken = isClosingCurlyBracketToken; exports.isClosingParenthesisToken = isClosingParenthesisToken; exports.isColonToken = isColonToken; exports.isCommaToken = isCommaToken; exports.isComponentDeclaration = isComponentDeclaration; exports.isComponentParameter = isComponentParameter; exports.isComponentTypeAnnotation = isComponentTypeAnnotation; exports.isComponentTypeParameter = isComponentTypeParameter; exports.isConditionalExpression = isConditionalExpression; exports.isConditionalTypeAnnotation = isConditionalTypeAnnotation; exports.isConstToken = isConstToken; exports.isContinueStatement = isContinueStatement; exports.isContinueToken = isContinueToken; exports.isDebuggerStatement = isDebuggerStatement; exports.isDebuggerToken = isDebuggerToken; exports.isDeclareClass = isDeclareClass; exports.isDeclareComponent = isDeclareComponent; exports.isDeclareEnum = isDeclareEnum; exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration; exports.isDeclareExportDeclaration = isDeclareExportDeclaration; exports.isDeclareFunction = isDeclareFunction; exports.isDeclareHook = isDeclareHook; exports.isDeclareInterface = isDeclareInterface; exports.isDeclareKeyword = isDeclareKeyword; exports.isDeclareModule = isDeclareModule; exports.isDeclareModuleExports = isDeclareModuleExports; exports.isDeclareNamespace = isDeclareNamespace; exports.isDeclareOpaqueType = isDeclareOpaqueType; exports.isDeclareTypeAlias = isDeclareTypeAlias; exports.isDeclareVariable = isDeclareVariable; exports.isDeclaredPredicate = isDeclaredPredicate; exports.isDecrementToken = isDecrementToken; exports.isDefaultToken = isDefaultToken; exports.isDeleteToken = isDeleteToken; exports.isDivideEqualToken = isDivideEqualToken; exports.isDoToken = isDoToken; exports.isDoWhileStatement = isDoWhileStatement; exports.isDotDotDotToken = isDotDotDotToken; exports.isDotToken = isDotToken; exports.isElseToken = isElseToken; exports.isEmptyStatement = isEmptyStatement; exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation; exports.isEnumBigIntBody = isEnumBigIntBody; exports.isEnumBigIntMember = isEnumBigIntMember; exports.isEnumBooleanBody = isEnumBooleanBody; exports.isEnumBooleanMember = isEnumBooleanMember; exports.isEnumDeclaration = isEnumDeclaration; exports.isEnumDefaultedMember = isEnumDefaultedMember; exports.isEnumNumberBody = isEnumNumberBody; exports.isEnumNumberMember = isEnumNumberMember; exports.isEnumStringBody = isEnumStringBody; exports.isEnumStringMember = isEnumStringMember; exports.isEnumSymbolBody = isEnumSymbolBody; exports.isEnumToken = isEnumToken; exports.isEqualToken = isEqualToken; exports.isExistsTypeAnnotation = isExistsTypeAnnotation; exports.isExponentateEqualToken = isExponentateEqualToken; exports.isExponentiationToken = isExponentiationToken; exports.isExportAllDeclaration = isExportAllDeclaration; exports.isExportDefaultDeclaration = isExportDefaultDeclaration; exports.isExportNamedDeclaration = isExportNamedDeclaration; exports.isExportSpecifier = isExportSpecifier; exports.isExportToken = isExportToken; exports.isExpressionStatement = isExpressionStatement; exports.isExtendsToken = isExtendsToken; exports.isFinallyToken = isFinallyToken; exports.isForInStatement = isForInStatement; exports.isForOfStatement = isForOfStatement; exports.isForStatement = isForStatement; exports.isForToken = isForToken; exports.isForwardSlashToken = isForwardSlashToken; exports.isFromKeyword = isFromKeyword; exports.isFunctionDeclaration = isFunctionDeclaration; exports.isFunctionExpression = isFunctionExpression; exports.isFunctionToken = isFunctionToken; exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation; exports.isFunctionTypeParam = isFunctionTypeParam; exports.isGenericTypeAnnotation = isGenericTypeAnnotation; exports.isGetKeyword = isGetKeyword; exports.isGreaterThanOrEqualToToken = isGreaterThanOrEqualToToken; exports.isGreaterThanToken = isGreaterThanToken; exports.isHookDeclaration = isHookDeclaration; exports.isHookTypeAnnotation = isHookTypeAnnotation; exports.isIdentifier = isIdentifier; exports.isIfStatement = isIfStatement; exports.isIfToken = isIfToken; exports.isImplementsToken = isImplementsToken; exports.isImportAttribute = isImportAttribute; exports.isImportDeclaration = isImportDeclaration; exports.isImportDefaultSpecifier = isImportDefaultSpecifier; exports.isImportExpression = isImportExpression; exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier; exports.isImportSpecifier = isImportSpecifier; exports.isImportToken = isImportToken; exports.isInToken = isInToken; exports.isIncrementToken = isIncrementToken; exports.isIndexedAccessType = isIndexedAccessType; exports.isInferTypeAnnotation = isInferTypeAnnotation; exports.isInferredPredicate = isInferredPredicate; exports.isInstanceOfToken = isInstanceOfToken; exports.isInterfaceDeclaration = isInterfaceDeclaration; exports.isInterfaceExtends = isInterfaceExtends; exports.isInterfaceToken = isInterfaceToken; exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation; exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation; exports.isIntersectionTypeToken = isIntersectionTypeToken; exports.isJSXAttribute = isJSXAttribute; exports.isJSXClosingElement = isJSXClosingElement; exports.isJSXClosingFragment = isJSXClosingFragment; exports.isJSXElement = isJSXElement; exports.isJSXEmptyExpression = isJSXEmptyExpression; exports.isJSXExpressionContainer = isJSXExpressionContainer; exports.isJSXFragment = isJSXFragment; exports.isJSXIdentifier = isJSXIdentifier; exports.isJSXMemberExpression = isJSXMemberExpression; exports.isJSXNamespacedName = isJSXNamespacedName; exports.isJSXOpeningElement = isJSXOpeningElement; exports.isJSXOpeningFragment = isJSXOpeningFragment; exports.isJSXSpreadAttribute = isJSXSpreadAttribute; exports.isJSXSpreadChild = isJSXSpreadChild; exports.isJSXText = isJSXText; exports.isKeyofTypeAnnotation = isKeyofTypeAnnotation; exports.isLabeledStatement = isLabeledStatement; exports.isLessThanOrEqualToToken = isLessThanOrEqualToToken; exports.isLessThanToken = isLessThanToken; exports.isLetKeyword = isLetKeyword; exports.isLineComment = isLineComment; exports.isLiteral = isLiteral; exports.isLogicalANDEqualToken = isLogicalANDEqualToken; exports.isLogicalANDToken = isLogicalANDToken; exports.isLogicalExpression = isLogicalExpression; exports.isLogicalNotToken = isLogicalNotToken; exports.isLogicalOREqualToken = isLogicalOREqualToken; exports.isLogicalORToken = isLogicalORToken; exports.isLooseEqualToken = isLooseEqualToken; exports.isLooseNotEqualToken = isLooseNotEqualToken; exports.isMemberExpression = isMemberExpression; exports.isMetaProperty = isMetaProperty; exports.isMethodDefinition = isMethodDefinition; exports.isMinusEqualToken = isMinusEqualToken; exports.isMinusToken = isMinusToken; exports.isMixedTypeAnnotation = isMixedTypeAnnotation; exports.isModuleKeyword = isModuleKeyword; exports.isMultiplyEqualToken = isMultiplyEqualToken; exports.isNewExpression = isNewExpression; exports.isNewToken = isNewToken; exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation; exports.isNullableTypeAnnotation = isNullableTypeAnnotation; exports.isNullishCoalesceEqualToken = isNullishCoalesceEqualToken; exports.isNullishCoalesceToken = isNullishCoalesceToken; exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation; exports.isNumberTypeAnnotation = isNumberTypeAnnotation; exports.isObjectExpression = isObjectExpression; exports.isObjectPattern = isObjectPattern; exports.isObjectTypeAnnotation = isObjectTypeAnnotation; exports.isObjectTypeCallProperty = isObjectTypeCallProperty; exports.isObjectTypeIndexer = isObjectTypeIndexer; exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot; exports.isObjectTypeMappedTypeProperty = isObjectTypeMappedTypeProperty; exports.isObjectTypeProperty = isObjectTypeProperty; exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty; exports.isOfKeyword = isOfKeyword; exports.isOpaqueType = isOpaqueType; exports.isOpeningAngleBracketToken = isOpeningAngleBracketToken; exports.isOpeningCurlyBracketToken = isOpeningCurlyBracketToken; exports.isOpeningParenthesisToken = isOpeningParenthesisToken; exports.isOptionalChainToken = isOptionalChainToken; exports.isOptionalIndexedAccessType = isOptionalIndexedAccessType; exports.isPercentToken = isPercentToken; exports.isPlusEqualToken = isPlusEqualToken; exports.isPlusToken = isPlusToken; exports.isPrivateIdentifier = isPrivateIdentifier; exports.isProgram = isProgram; exports.isProperty = isProperty; exports.isPropertyDefinition = isPropertyDefinition; exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier; exports.isQualifiedTypeofIdentifier = isQualifiedTypeofIdentifier; exports.isQuestionMarkToken = isQuestionMarkToken; exports.isRemainderEqualToken = isRemainderEqualToken; exports.isRestElement = isRestElement; exports.isReturnStatement = isReturnStatement; exports.isReturnToken = isReturnToken; exports.isSemicolonToken = isSemicolonToken; exports.isSequenceExpression = isSequenceExpression; exports.isSetKeyword = isSetKeyword; exports.isSpreadElement = isSpreadElement; exports.isStaticToken = isStaticToken; exports.isStrictEqualToken = isStrictEqualToken; exports.isStrictNotEqualToken = isStrictNotEqualToken; exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation; exports.isStringTypeAnnotation = isStringTypeAnnotation; exports.isSuper = isSuper; exports.isSuperToken = isSuperToken; exports.isSwitchCase = isSwitchCase; exports.isSwitchStatement = isSwitchStatement; exports.isSwitchToken = isSwitchToken; exports.isSymbolTypeAnnotation = isSymbolTypeAnnotation; exports.isTaggedTemplateExpression = isTaggedTemplateExpression; exports.isTemplateElement = isTemplateElement; exports.isTemplateLiteral = isTemplateLiteral; exports.isThisExpression = isThisExpression; exports.isThisToken = isThisToken; exports.isThisTypeAnnotation = isThisTypeAnnotation; exports.isThrowStatement = isThrowStatement; exports.isThrowToken = isThrowToken; exports.isTryStatement = isTryStatement; exports.isTryToken = isTryToken; exports.isTupleTypeAnnotation = isTupleTypeAnnotation; exports.isTupleTypeLabeledElement = isTupleTypeLabeledElement; exports.isTupleTypeSpreadElement = isTupleTypeSpreadElement; exports.isTypeAlias = isTypeAlias; exports.isTypeAnnotation = isTypeAnnotation; exports.isTypeCastExpression = isTypeCastExpression; exports.isTypeKeyword = isTypeKeyword; exports.isTypeOfToken = isTypeOfToken; exports.isTypeOperator = isTypeOperator; exports.isTypeParameter = isTypeParameter; exports.isTypeParameterDeclaration = isTypeParameterDeclaration; exports.isTypeParameterInstantiation = isTypeParameterInstantiation; exports.isTypePredicate = isTypePredicate; exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation; exports.isUnaryExpression = isUnaryExpression; exports.isUnaryNegationToken = isUnaryNegationToken; exports.isUnionTypeAnnotation = isUnionTypeAnnotation; exports.isUnionTypeToken = isUnionTypeToken; exports.isUpdateExpression = isUpdateExpression; exports.isVarToken = isVarToken; exports.isVariableDeclaration = isVariableDeclaration; exports.isVariableDeclarator = isVariableDeclarator; exports.isVariance = isVariance; exports.isVoidToken = isVoidToken; exports.isVoidTypeAnnotation = isVoidTypeAnnotation; exports.isWhileStatement = isWhileStatement; exports.isWhileToken = isWhileToken; exports.isWithStatement = isWithStatement; exports.isWithToken = isWithToken; exports.isYieldExpression = isYieldExpression; exports.isYieldToken = isYieldToken; function isIdentifier(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier'; } function isJSXIdentifier(node /*: ESNode | Token */ ) /*: implies node is (JSXIdentifier | MostTokens) */ { return node.type === 'JSXIdentifier'; } function isJSXText(node /*: ESNode | Token */ ) /*: implies node is (JSXText | MostTokens) */ { return node.type === 'JSXText'; } function isAnyTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is AnyTypeAnnotation */ { return node.type === 'AnyTypeAnnotation'; } function isArrayExpression(node /*: ESNode | Token */ ) /*: implies node is ArrayExpression */ { return node.type === 'ArrayExpression'; } function isArrayPattern(node /*: ESNode | Token */ ) /*: implies node is ArrayPattern */ { return node.type === 'ArrayPattern'; } function isArrayTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is ArrayTypeAnnotation */ { return node.type === 'ArrayTypeAnnotation'; } function isArrowFunctionExpression(node /*: ESNode | Token */ ) /*: implies node is ArrowFunctionExpression */ { return node.type === 'ArrowFunctionExpression'; } function isAsConstExpression(node /*: ESNode | Token */ ) /*: implies node is AsConstExpression */ { return node.type === 'AsConstExpression'; } function isAsExpression(node /*: ESNode | Token */ ) /*: implies node is AsExpression */ { return node.type === 'AsExpression'; } function isAssignmentExpression(node /*: ESNode | Token */ ) /*: implies node is AssignmentExpression */ { return node.type === 'AssignmentExpression'; } function isAssignmentPattern(node /*: ESNode | Token */ ) /*: implies node is AssignmentPattern */ { return node.type === 'AssignmentPattern'; } function isAwaitExpression(node /*: ESNode | Token */ ) /*: implies node is AwaitExpression */ { return node.type === 'AwaitExpression'; } function isBigIntLiteralTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is BigIntLiteralTypeAnnotation */ { return node.type === 'BigIntLiteralTypeAnnotation'; } function isBigIntTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is BigIntTypeAnnotation */ { return node.type === 'BigIntTypeAnnotation'; } function isBinaryExpression(node /*: ESNode | Token */ ) /*: implies node is BinaryExpression */ { return node.type === 'BinaryExpression'; } function isBlockStatement(node /*: ESNode | Token */ ) /*: implies node is BlockStatement */ { return node.type === 'BlockStatement'; } function isBooleanLiteralTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is BooleanLiteralTypeAnnotation */ { return node.type === 'BooleanLiteralTypeAnnotation'; } function isBooleanTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is BooleanTypeAnnotation */ { return node.type === 'BooleanTypeAnnotation'; } function isBreakStatement(node /*: ESNode | Token */ ) /*: implies node is BreakStatement */ { return node.type === 'BreakStatement'; } function isCallExpression(node /*: ESNode | Token */ ) /*: implies node is CallExpression */ { return node.type === 'CallExpression'; } function isCatchClause(node /*: ESNode | Token */ ) /*: implies node is CatchClause */ { return node.type === 'CatchClause'; } function isChainExpression(node /*: ESNode | Token */ ) /*: implies node is ChainExpression */ { return node.type === 'ChainExpression'; } function isClassBody(node /*: ESNode | Token */ ) /*: implies node is ClassBody */ { return node.type === 'ClassBody'; } function isClassDeclaration(node /*: ESNode | Token */ ) /*: implies node is ClassDeclaration */ { return node.type === 'ClassDeclaration'; } function isClassExpression(node /*: ESNode | Token */ ) /*: implies node is ClassExpression */ { return node.type === 'ClassExpression'; } function isClassImplements(node /*: ESNode | Token */ ) /*: implies node is ClassImplements */ { return node.type === 'ClassImplements'; } function isComponentDeclaration(node /*: ESNode | Token */ ) /*: implies node is ComponentDeclaration */ { return node.type === 'ComponentDeclaration'; } function isComponentParameter(node /*: ESNode | Token */ ) /*: implies node is ComponentParameter */ { return node.type === 'ComponentParameter'; } function isComponentTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is ComponentTypeAnnotation */ { return node.type === 'ComponentTypeAnnotation'; } function isComponentTypeParameter(node /*: ESNode | Token */ ) /*: implies node is ComponentTypeParameter */ { return node.type === 'ComponentTypeParameter'; } function isConditionalExpression(node /*: ESNode | Token */ ) /*: implies node is ConditionalExpression */ { return node.type === 'ConditionalExpression'; } function isConditionalTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is ConditionalTypeAnnotation */ { return node.type === 'ConditionalTypeAnnotation'; } function isContinueStatement(node /*: ESNode | Token */ ) /*: implies node is ContinueStatement */ { return node.type === 'ContinueStatement'; } function isDebuggerStatement(node /*: ESNode | Token */ ) /*: implies node is DebuggerStatement */ { return node.type === 'DebuggerStatement'; } function isDeclareClass(node /*: ESNode | Token */ ) /*: implies node is DeclareClass */ { return node.type === 'DeclareClass'; } function isDeclareComponent(node /*: ESNode | Token */ ) /*: implies node is DeclareComponent */ { return node.type === 'DeclareComponent'; } function isDeclaredPredicate(node /*: ESNode | Token */ ) /*: implies node is DeclaredPredicate */ { return node.type === 'DeclaredPredicate'; } function isDeclareEnum(node /*: ESNode | Token */ ) /*: implies node is DeclareEnum */ { return node.type === 'DeclareEnum'; } function isDeclareExportAllDeclaration(node /*: ESNode | Token */ ) /*: implies node is DeclareExportAllDeclaration */ { return node.type === 'DeclareExportAllDeclaration'; } function isDeclareExportDeclaration(node /*: ESNode | Token */ ) /*: implies node is DeclareExportDeclaration */ { return node.type === 'DeclareExportDeclaration'; } function isDeclareFunction(node /*: ESNode | Token */ ) /*: implies node is DeclareFunction */ { return node.type === 'DeclareFunction'; } function isDeclareHook(node /*: ESNode | Token */ ) /*: implies node is DeclareHook */ { return node.type === 'DeclareHook'; } function isDeclareInterface(node /*: ESNode | Token */ ) /*: implies node is DeclareInterface */ { return node.type === 'DeclareInterface'; } function isDeclareModule(node /*: ESNode | Token */ ) /*: implies node is DeclareModule */ { return node.type === 'DeclareModule'; } function isDeclareModuleExports(node /*: ESNode | Token */ ) /*: implies node is DeclareModuleExports */ { return node.type === 'DeclareModuleExports'; } function isDeclareNamespace(node /*: ESNode | Token */ ) /*: implies node is DeclareNamespace */ { return node.type === 'DeclareNamespace'; } function isDeclareOpaqueType(node /*: ESNode | Token */ ) /*: implies node is DeclareOpaqueType */ { return node.type === 'DeclareOpaqueType'; } function isDeclareTypeAlias(node /*: ESNode | Token */ ) /*: implies node is DeclareTypeAlias */ { return node.type === 'DeclareTypeAlias'; } function isDeclareVariable(node /*: ESNode | Token */ ) /*: implies node is DeclareVariable */ { return node.type === 'DeclareVariable'; } function isDoWhileStatement(node /*: ESNode | Token */ ) /*: implies node is DoWhileStatement */ { return node.type === 'DoWhileStatement'; } function isEmptyStatement(node /*: ESNode | Token */ ) /*: implies node is EmptyStatement */ { return node.type === 'EmptyStatement'; } function isEmptyTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is EmptyTypeAnnotation */ { return node.type === 'EmptyTypeAnnotation'; } function isEnumBigIntBody(node /*: ESNode | Token */ ) /*: implies node is EnumBigIntBody */ { return node.type === 'EnumBigIntBody'; } function isEnumBigIntMember(node /*: ESNode | Token */ ) /*: implies node is EnumBigIntMember */ { return node.type === 'EnumBigIntMember'; } function isEnumBooleanBody(node /*: ESNode | Token */ ) /*: implies node is EnumBooleanBody */ { return node.type === 'EnumBooleanBody'; } function isEnumBooleanMember(node /*: ESNode | Token */ ) /*: implies node is EnumBooleanMember */ { return node.type === 'EnumBooleanMember'; } function isEnumDeclaration(node /*: ESNode | Token */ ) /*: implies node is EnumDeclaration */ { return node.type === 'EnumDeclaration'; } function isEnumDefaultedMember(node /*: ESNode | Token */ ) /*: implies node is EnumDefaultedMember */ { return node.type === 'EnumDefaultedMember'; } function isEnumNumberBody(node /*: ESNode | Token */ ) /*: implies node is EnumNumberBody */ { return node.type === 'EnumNumberBody'; } function isEnumNumberMember(node /*: ESNode | Token */ ) /*: implies node is EnumNumberMember */ { return node.type === 'EnumNumberMember'; } function isEnumStringBody(node /*: ESNode | Token */ ) /*: implies node is EnumStringBody */ { return node.type === 'EnumStringBody'; } function isEnumStringMember(node /*: ESNode | Token */ ) /*: implies node is EnumStringMember */ { return node.type === 'EnumStringMember'; } function isEnumSymbolBody(node /*: ESNode | Token */ ) /*: implies node is EnumSymbolBody */ { return node.type === 'EnumSymbolBody'; } function isExistsTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is ExistsTypeAnnotation */ { return node.type === 'ExistsTypeAnnotation'; } function isExportAllDeclaration(node /*: ESNode | Token */ ) /*: implies node is ExportAllDeclaration */ { return node.type === 'ExportAllDeclaration'; } function isExportDefaultDeclaration(node /*: ESNode | Token */ ) /*: implies node is ExportDefaultDeclaration */ { return node.type === 'ExportDefaultDeclaration'; } function isExportNamedDeclaration(node /*: ESNode | Token */ ) /*: implies node is ExportNamedDeclaration */ { return node.type === 'ExportNamedDeclaration'; } function isExportSpecifier(node /*: ESNode | Token */ ) /*: implies node is ExportSpecifier */ { return node.type === 'ExportSpecifier'; } function isExpressionStatement(node /*: ESNode | Token */ ) /*: implies node is ExpressionStatement */ { return node.type === 'ExpressionStatement'; } function isForInStatement(node /*: ESNode | Token */ ) /*: implies node is ForInStatement */ { return node.type === 'ForInStatement'; } function isForOfStatement(node /*: ESNode | Token */ ) /*: implies node is ForOfStatement */ { return node.type === 'ForOfStatement'; } function isForStatement(node /*: ESNode | Token */ ) /*: implies node is ForStatement */ { return node.type === 'ForStatement'; } function isFunctionDeclaration(node /*: ESNode | Token */ ) /*: implies node is FunctionDeclaration */ { return node.type === 'FunctionDeclaration'; } function isFunctionExpression(node /*: ESNode | Token */ ) /*: implies node is FunctionExpression */ { return node.type === 'FunctionExpression'; } function isFunctionTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is FunctionTypeAnnotation */ { return node.type === 'FunctionTypeAnnotation'; } function isFunctionTypeParam(node /*: ESNode | Token */ ) /*: implies node is FunctionTypeParam */ { return node.type === 'FunctionTypeParam'; } function isGenericTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is GenericTypeAnnotation */ { return node.type === 'GenericTypeAnnotation'; } function isHookDeclaration(node /*: ESNode | Token */ ) /*: implies node is HookDeclaration */ { return node.type === 'HookDeclaration'; } function isHookTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is HookTypeAnnotation */ { return node.type === 'HookTypeAnnotation'; } function isIfStatement(node /*: ESNode | Token */ ) /*: implies node is IfStatement */ { return node.type === 'IfStatement'; } function isImportAttribute(node /*: ESNode | Token */ ) /*: implies node is ImportAttribute */ { return node.type === 'ImportAttribute'; } function isImportDeclaration(node /*: ESNode | Token */ ) /*: implies node is ImportDeclaration */ { return node.type === 'ImportDeclaration'; } function isImportDefaultSpecifier(node /*: ESNode | Token */ ) /*: implies node is ImportDefaultSpecifier */ { return node.type === 'ImportDefaultSpecifier'; } function isImportExpression(node /*: ESNode | Token */ ) /*: implies node is ImportExpression */ { return node.type === 'ImportExpression'; } function isImportNamespaceSpecifier(node /*: ESNode | Token */ ) /*: implies node is ImportNamespaceSpecifier */ { return node.type === 'ImportNamespaceSpecifier'; } function isImportSpecifier(node /*: ESNode | Token */ ) /*: implies node is ImportSpecifier */ { return node.type === 'ImportSpecifier'; } function isIndexedAccessType(node /*: ESNode | Token */ ) /*: implies node is IndexedAccessType */ { return node.type === 'IndexedAccessType'; } function isInferredPredicate(node /*: ESNode | Token */ ) /*: implies node is InferredPredicate */ { return node.type === 'InferredPredicate'; } function isInferTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is InferTypeAnnotation */ { return node.type === 'InferTypeAnnotation'; } function isInterfaceDeclaration(node /*: ESNode | Token */ ) /*: implies node is InterfaceDeclaration */ { return node.type === 'InterfaceDeclaration'; } function isInterfaceExtends(node /*: ESNode | Token */ ) /*: implies node is InterfaceExtends */ { return node.type === 'InterfaceExtends'; } function isInterfaceTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is InterfaceTypeAnnotation */ { return node.type === 'InterfaceTypeAnnotation'; } function isIntersectionTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is IntersectionTypeAnnotation */ { return node.type === 'IntersectionTypeAnnotation'; } function isJSXAttribute(node /*: ESNode | Token */ ) /*: implies node is JSXAttribute */ { return node.type === 'JSXAttribute'; } function isJSXClosingElement(node /*: ESNode | Token */ ) /*: implies node is JSXClosingElement */ { return node.type === 'JSXClosingElement'; } function isJSXClosingFragment(node /*: ESNode | Token */ ) /*: implies node is JSXClosingFragment */ { return node.type === 'JSXClosingFragment'; } function isJSXElement(node /*: ESNode | Token */ ) /*: implies node is JSXElement */ { return node.type === 'JSXElement'; } function isJSXEmptyExpression(node /*: ESNode | Token */ ) /*: implies node is JSXEmptyExpression */ { return node.type === 'JSXEmptyExpression'; } function isJSXExpressionContainer(node /*: ESNode | Token */ ) /*: implies node is JSXExpressionContainer */ { return node.type === 'JSXExpressionContainer'; } function isJSXFragment(node /*: ESNode | Token */ ) /*: implies node is JSXFragment */ { return node.type === 'JSXFragment'; } function isJSXMemberExpression(node /*: ESNode | Token */ ) /*: implies node is JSXMemberExpression */ { return node.type === 'JSXMemberExpression'; } function isJSXNamespacedName(node /*: ESNode | Token */ ) /*: implies node is JSXNamespacedName */ { return node.type === 'JSXNamespacedName'; } function isJSXOpeningElement(node /*: ESNode | Token */ ) /*: implies node is JSXOpeningElement */ { return node.type === 'JSXOpeningElement'; } function isJSXOpeningFragment(node /*: ESNode | Token */ ) /*: implies node is JSXOpeningFragment */ { return node.type === 'JSXOpeningFragment'; } function isJSXSpreadAttribute(node /*: ESNode | Token */ ) /*: implies node is JSXSpreadAttribute */ { return node.type === 'JSXSpreadAttribute'; } function isJSXSpreadChild(node /*: ESNode | Token */ ) /*: implies node is JSXSpreadChild */ { return node.type === 'JSXSpreadChild'; } function isKeyofTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is KeyofTypeAnnotation */ { return node.type === 'KeyofTypeAnnotation'; } function isLabeledStatement(node /*: ESNode | Token */ ) /*: implies node is LabeledStatement */ { return node.type === 'LabeledStatement'; } function isLogicalExpression(node /*: ESNode | Token */ ) /*: implies node is LogicalExpression */ { return node.type === 'LogicalExpression'; } function isMemberExpression(node /*: ESNode | Token */ ) /*: implies node is MemberExpression */ { return node.type === 'MemberExpression'; } function isMetaProperty(node /*: ESNode | Token */ ) /*: implies node is MetaProperty */ { return node.type === 'MetaProperty'; } function isMethodDefinition(node /*: ESNode | Token */ ) /*: implies node is MethodDefinition */ { return node.type === 'MethodDefinition'; } function isMixedTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is MixedTypeAnnotation */ { return node.type === 'MixedTypeAnnotation'; } function isNewExpression(node /*: ESNode | Token */ ) /*: implies node is NewExpression */ { return node.type === 'NewExpression'; } function isNullableTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is NullableTypeAnnotation */ { return node.type === 'NullableTypeAnnotation'; } function isNullLiteralTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is NullLiteralTypeAnnotation */ { return node.type === 'NullLiteralTypeAnnotation'; } function isNumberLiteralTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is NumberLiteralTypeAnnotation */ { return node.type === 'NumberLiteralTypeAnnotation'; } function isNumberTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is NumberTypeAnnotation */ { return node.type === 'NumberTypeAnnotation'; } function isObjectExpression(node /*: ESNode | Token */ ) /*: implies node is ObjectExpression */ { return node.type === 'ObjectExpression'; } function isObjectPattern(node /*: ESNode | Token */ ) /*: implies node is ObjectPattern */ { return node.type === 'ObjectPattern'; } function isObjectTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is ObjectTypeAnnotation */ { return node.type === 'ObjectTypeAnnotation'; } function isObjectTypeCallProperty(node /*: ESNode | Token */ ) /*: implies node is ObjectTypeCallProperty */ { return node.type === 'ObjectTypeCallProperty'; } function isObjectTypeIndexer(node /*: ESNode | Token */ ) /*: implies node is ObjectTypeIndexer */ { return node.type === 'ObjectTypeIndexer'; } function isObjectTypeInternalSlot(node /*: ESNode | Token */ ) /*: implies node is ObjectTypeInternalSlot */ { return node.type === 'ObjectTypeInternalSlot'; } function isObjectTypeMappedTypeProperty(node /*: ESNode | Token */ ) /*: implies node is ObjectTypeMappedTypeProperty */ { return node.type === 'ObjectTypeMappedTypeProperty'; } function isObjectTypeProperty(node /*: ESNode | Token */ ) /*: implies node is ObjectTypeProperty */ { return node.type === 'ObjectTypeProperty'; } function isObjectTypeSpreadProperty(node /*: ESNode | Token */ ) /*: implies node is ObjectTypeSpreadProperty */ { return node.type === 'ObjectTypeSpreadProperty'; } function isOpaqueType(node /*: ESNode | Token */ ) /*: implies node is OpaqueType */ { return node.type === 'OpaqueType'; } function isOptionalIndexedAccessType(node /*: ESNode | Token */ ) /*: implies node is OptionalIndexedAccessType */ { return node.type === 'OptionalIndexedAccessType'; } function isPrivateIdentifier(node /*: ESNode | Token */ ) /*: implies node is PrivateIdentifier */ { return node.type === 'PrivateIdentifier'; } function isProgram(node /*: ESNode | Token */ ) /*: implies node is Program */ { return node.type === 'Program'; } function isProperty(node /*: ESNode | Token */ ) /*: implies node is Property */ { return node.type === 'Property'; } function isPropertyDefinition(node /*: ESNode | Token */ ) /*: implies node is PropertyDefinition */ { return node.type === 'PropertyDefinition'; } function isQualifiedTypeIdentifier(node /*: ESNode | Token */ ) /*: implies node is QualifiedTypeIdentifier */ { return node.type === 'QualifiedTypeIdentifier'; } function isQualifiedTypeofIdentifier(node /*: ESNode | Token */ ) /*: implies node is QualifiedTypeofIdentifier */ { return node.type === 'QualifiedTypeofIdentifier'; } function isRestElement(node /*: ESNode | Token */ ) /*: implies node is RestElement */ { return node.type === 'RestElement'; } function isReturnStatement(node /*: ESNode | Token */ ) /*: implies node is ReturnStatement */ { return node.type === 'ReturnStatement'; } function isSequenceExpression(node /*: ESNode | Token */ ) /*: implies node is SequenceExpression */ { return node.type === 'SequenceExpression'; } function isSpreadElement(node /*: ESNode | Token */ ) /*: implies node is SpreadElement */ { return node.type === 'SpreadElement'; } function isStringLiteralTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is StringLiteralTypeAnnotation */ { return node.type === 'StringLiteralTypeAnnotation'; } function isStringTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is StringTypeAnnotation */ { return node.type === 'StringTypeAnnotation'; } function isSuper(node /*: ESNode | Token */ ) /*: implies node is Super */ { return node.type === 'Super'; } function isSwitchCase(node /*: ESNode | Token */ ) /*: implies node is SwitchCase */ { return node.type === 'SwitchCase'; } function isSwitchStatement(node /*: ESNode | Token */ ) /*: implies node is SwitchStatement */ { return node.type === 'SwitchStatement'; } function isSymbolTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is SymbolTypeAnnotation */ { return node.type === 'SymbolTypeAnnotation'; } function isTaggedTemplateExpression(node /*: ESNode | Token */ ) /*: implies node is TaggedTemplateExpression */ { return node.type === 'TaggedTemplateExpression'; } function isTemplateElement(node /*: ESNode | Token */ ) /*: implies node is TemplateElement */ { return node.type === 'TemplateElement'; } function isTemplateLiteral(node /*: ESNode | Token */ ) /*: implies node is TemplateLiteral */ { return node.type === 'TemplateLiteral'; } function isThisExpression(node /*: ESNode | Token */ ) /*: implies node is ThisExpression */ { return node.type === 'ThisExpression'; } function isThisTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is ThisTypeAnnotation */ { return node.type === 'ThisTypeAnnotation'; } function isThrowStatement(node /*: ESNode | Token */ ) /*: implies node is ThrowStatement */ { return node.type === 'ThrowStatement'; } function isTryStatement(node /*: ESNode | Token */ ) /*: implies node is TryStatement */ { return node.type === 'TryStatement'; } function isTupleTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is TupleTypeAnnotation */ { return node.type === 'TupleTypeAnnotation'; } function isTupleTypeLabeledElement(node /*: ESNode | Token */ ) /*: implies node is TupleTypeLabeledElement */ { return node.type === 'TupleTypeLabeledElement'; } function isTupleTypeSpreadElement(node /*: ESNode | Token */ ) /*: implies node is TupleTypeSpreadElement */ { return node.type === 'TupleTypeSpreadElement'; } function isTypeAlias(node /*: ESNode | Token */ ) /*: implies node is TypeAlias */ { return node.type === 'TypeAlias'; } function isTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is TypeAnnotation */ { return node.type === 'TypeAnnotation'; } function isTypeCastExpression(node /*: ESNode | Token */ ) /*: implies node is TypeCastExpression */ { return node.type === 'TypeCastExpression'; } function isTypeofTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is TypeofTypeAnnotation */ { return node.type === 'TypeofTypeAnnotation'; } function isTypeOperator(node /*: ESNode | Token */ ) /*: implies node is TypeOperator */ { return node.type === 'TypeOperator'; } function isTypeParameter(node /*: ESNode | Token */ ) /*: implies node is TypeParameter */ { return node.type === 'TypeParameter'; } function isTypeParameterDeclaration(node /*: ESNode | Token */ ) /*: implies node is TypeParameterDeclaration */ { return node.type === 'TypeParameterDeclaration'; } function isTypeParameterInstantiation(node /*: ESNode | Token */ ) /*: implies node is TypeParameterInstantiation */ { return node.type === 'TypeParameterInstantiation'; } function isTypePredicate(node /*: ESNode | Token */ ) /*: implies node is TypePredicate */ { return node.type === 'TypePredicate'; } function isUnaryExpression(node /*: ESNode | Token */ ) /*: implies node is UnaryExpression */ { return node.type === 'UnaryExpression'; } function isUnionTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is UnionTypeAnnotation */ { return node.type === 'UnionTypeAnnotation'; } function isUpdateExpression(node /*: ESNode | Token */ ) /*: implies node is UpdateExpression */ { return node.type === 'UpdateExpression'; } function isVariableDeclaration(node /*: ESNode | Token */ ) /*: implies node is VariableDeclaration */ { return node.type === 'VariableDeclaration'; } function isVariableDeclarator(node /*: ESNode | Token */ ) /*: implies node is VariableDeclarator */ { return node.type === 'VariableDeclarator'; } function isVariance(node /*: ESNode | Token */ ) /*: implies node is Variance */ { return node.type === 'Variance'; } function isVoidTypeAnnotation(node /*: ESNode | Token */ ) /*: implies node is VoidTypeAnnotation */ { return node.type === 'VoidTypeAnnotation'; } function isWhileStatement(node /*: ESNode | Token */ ) /*: implies node is WhileStatement */ { return node.type === 'WhileStatement'; } function isWithStatement(node /*: ESNode | Token */ ) /*: implies node is WithStatement */ { return node.type === 'WithStatement'; } function isYieldExpression(node /*: ESNode | Token */ ) /*: implies node is YieldExpression */ { return node.type === 'YieldExpression'; } function isLiteral(node /*: ESNode | Token */ ) /*: implies node is Literal */ { return node.type === 'Literal'; } function isLineComment(node /*: ESNode | Token */ ) /*: implies node is (MostTokens | LineComment) */ { return node.type === 'Line'; } function isBlockComment(node /*: ESNode | Token */ ) /*: implies node is (MostTokens | BlockComment) */ { return node.type === 'Block'; } function isMinusToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '-'; } function isPlusToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '+'; } function isLogicalNotToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '!'; } function isUnaryNegationToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '~'; } function isTypeOfToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'typeof'; } function isVoidToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'void'; } function isDeleteToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'delete'; } function isLooseEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '=='; } function isLooseNotEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '!='; } function isStrictEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '==='; } function isStrictNotEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '!=='; } function isLessThanToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '<'; } function isLessThanOrEqualToToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '<='; } function isGreaterThanToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '>'; } function isGreaterThanOrEqualToToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '>='; } function isBitwiseLeftShiftToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '<<'; } function isBitwiseRightShiftToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '>>'; } function isBitwiseUnsignedRightShiftToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '>>>'; } function isAsterixToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '*'; } function isForwardSlashToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '/'; } function isPercentToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '%'; } function isExponentiationToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '**'; } function isBitwiseORToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '|'; } function isBitwiseXORToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '^'; } function isBitwiseANDToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '&'; } function isInToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'in'; } function isInstanceOfToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'instanceof'; } function isLogicalORToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '||'; } function isLogicalANDToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '&&'; } function isNullishCoalesceToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '??'; } function isEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '='; } function isPlusEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '+='; } function isMinusEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '-='; } function isMultiplyEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '*='; } function isDivideEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '/='; } function isRemainderEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '%='; } function isExponentateEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '**='; } function isBitwiseLeftShiftEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '<<='; } function isBitwiseRightShiftEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '>>='; } function isBitwiseUnsignedRightShiftEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '>>>='; } function isBitwiseOREqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '|='; } function isBitwiseXOREqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '^='; } function isBitwiseANDEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '&='; } function isLogicalOREqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '||='; } function isLogicalANDEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '&&='; } function isNullishCoalesceEqualToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '??='; } function isIncrementToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '++'; } function isDecrementToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '--'; } function isUnionTypeToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '|'; } function isIntersectionTypeToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '&'; } function isBreakToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'break'; } function isCaseToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'case'; } function isCatchToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'catch'; } function isClassToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'class'; } function isConstToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'const'; } function isContinueToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'continue'; } function isDebuggerToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'debugger'; } function isDefaultToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'default'; } function isDoToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'do'; } function isElseToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'else'; } function isEnumToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'enum'; } function isExportToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'export'; } function isExtendsToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'extends'; } function isFinallyToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'finally'; } function isForToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'for'; } function isFunctionToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'function'; } function isIfToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'if'; } function isImplementsToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'implements'; } function isImportToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'import'; } function isInterfaceToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'interface'; } function isNewToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'new'; } function isReturnToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'return'; } function isStaticToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'static'; } function isSuperToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'super'; } function isSwitchToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'switch'; } function isThisToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'this'; } function isThrowToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'throw'; } function isTryToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'try'; } function isVarToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'var'; } function isWhileToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'while'; } function isWithToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'with'; } function isYieldToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Keyword' && node.value === 'yield'; } function isAsKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'as' || node.type === 'Keyword' && node.value === 'as'; } function isAsyncKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'async' || node.type === 'Keyword' && node.value === 'async'; } function isAwaitKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'await' || node.type === 'Keyword' && node.value === 'await'; } function isDeclareKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'declare' || node.type === 'Keyword' && node.value === 'declare'; } function isFromKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'from' || node.type === 'Keyword' && node.value === 'from'; } function isGetKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'get' || node.type === 'Keyword' && node.value === 'get'; } function isLetKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'let' || node.type === 'Keyword' && node.value === 'let'; } function isModuleKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'module' || node.type === 'Keyword' && node.value === 'module'; } function isOfKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'of' || node.type === 'Keyword' && node.value === 'of'; } function isSetKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'set' || node.type === 'Keyword' && node.value === 'set'; } function isTypeKeyword(node /*: ESNode | Token */ ) /*: implies node is (Identifier | MostTokens) */ { return node.type === 'Identifier' && node.name === 'type' || node.type === 'Keyword' && node.value === 'type'; } function isCommaToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === ','; } function isColonToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === ':'; } function isSemicolonToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === ';'; } function isDotToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '.'; } function isDotDotDotToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '...'; } function isOptionalChainToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '?.'; } function isQuestionMarkToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '?'; } function isOpeningParenthesisToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '('; } function isClosingParenthesisToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === ')'; } function isOpeningCurlyBracketToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '{'; } function isClosingCurlyBracketToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '}'; } function isOpeningAngleBracketToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '<'; } function isClosingAngleBracketToken(node /*: ESNode | Token */ ) /*: implies node is MostTokens */ { return node.type === 'Punctuator' && node.value === '>'; }