jiuyiUniapp/service/node_modules/hermes-estree/dist/generated/predicates.js

2774 lines
61 KiB
JavaScript
Raw Normal View History

2025-02-13 09:59:20 +08:00
/**
* 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 === '>';
}