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