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