hermes-estree 0.18.0 → 0.18.2

package/dist/generated/predicates.js

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