hermes-estree - npm Package Compare versions

Comparing version 0.18.0 to 0.18.1

1852

dist/generated/predicates.js

		@@ -8,3 +8,2 @@ /**
		*
		* @format
		* @generated
		@@ -24,2 +23,179 @@ */
		'use strict';
		/*::
		import type {
		ESNode,
		Token,
		Identifier,
		JSXIdentifier,
		JSXText,
		AnyTypeAnnotation,
		ArrayExpression,
		ArrayPattern,
		ArrayTypeAnnotation,
		ArrowFunctionExpression,
		AsExpression,
		AssignmentExpression,
		AssignmentPattern,
		AwaitExpression,
		BigIntLiteralTypeAnnotation,
		BigIntTypeAnnotation,
		BinaryExpression,
		BlockStatement,
		BooleanLiteralTypeAnnotation,
		BooleanTypeAnnotation,
		BreakStatement,
		CallExpression,
		CatchClause,
		ChainExpression,
		ClassBody,
		ClassDeclaration,
		ClassExpression,
		ClassImplements,
		ComponentDeclaration,
		ComponentParameter,
		ComponentTypeAnnotation,
		ComponentTypeParameter,
		ConditionalExpression,
		ConditionalTypeAnnotation,
		ContinueStatement,
		DebuggerStatement,
		DeclareClass,
		DeclareComponent,
		DeclaredPredicate,
		DeclareEnum,
		DeclareExportAllDeclaration,
		DeclareExportDeclaration,
		DeclareFunction,
		DeclareInterface,
		DeclareModule,
		DeclareModuleExports,
		DeclareOpaqueType,
		DeclareTypeAlias,
		DeclareVariable,
		DoWhileStatement,
		EmptyStatement,
		EmptyTypeAnnotation,
		EnumBooleanBody,
		EnumBooleanMember,
		EnumDeclaration,
		EnumDefaultedMember,
		EnumNumberBody,
		EnumNumberMember,
		EnumStringBody,
		EnumStringMember,
		EnumSymbolBody,
		ExistsTypeAnnotation,
		ExportAllDeclaration,
		ExportDefaultDeclaration,
		ExportNamedDeclaration,
		ExportSpecifier,
		ExpressionStatement,
		ForInStatement,
		ForOfStatement,
		ForStatement,
		FunctionDeclaration,
		FunctionExpression,
		FunctionTypeAnnotation,
		FunctionTypeParam,
		GenericTypeAnnotation,
		IfStatement,
		ImportAttribute,
		ImportDeclaration,
		ImportDefaultSpecifier,
		ImportExpression,
		ImportNamespaceSpecifier,
		ImportSpecifier,
		IndexedAccessType,
		InferredPredicate,
		InferTypeAnnotation,
		InterfaceDeclaration,
		InterfaceExtends,
		InterfaceTypeAnnotation,
		IntersectionTypeAnnotation,
		JSXAttribute,
		JSXClosingElement,
		JSXClosingFragment,
		JSXElement,
		JSXEmptyExpression,
		JSXExpressionContainer,
		JSXFragment,
		JSXMemberExpression,
		JSXNamespacedName,
		JSXOpeningElement,
		JSXOpeningFragment,
		JSXSpreadAttribute,
		JSXSpreadChild,
		KeyofTypeAnnotation,
		LabeledStatement,
		LogicalExpression,
		MemberExpression,
		MetaProperty,
		MethodDefinition,
		MixedTypeAnnotation,
		NewExpression,
		NullableTypeAnnotation,
		NullLiteralTypeAnnotation,
		NumberLiteralTypeAnnotation,
		NumberTypeAnnotation,
		ObjectExpression,
		ObjectPattern,
		ObjectTypeAnnotation,
		ObjectTypeCallProperty,
		ObjectTypeIndexer,
		ObjectTypeInternalSlot,
		ObjectTypeMappedTypeProperty,
		ObjectTypeProperty,
		ObjectTypeSpreadProperty,
		OpaqueType,
		OptionalIndexedAccessType,
		PrivateIdentifier,
		Property,
		PropertyDefinition,
		QualifiedTypeIdentifier,
		QualifiedTypeofIdentifier,
		RestElement,
		ReturnStatement,
		SequenceExpression,
		SpreadElement,
		StringLiteralTypeAnnotation,
		StringTypeAnnotation,
		Super,
		SwitchCase,
		SwitchStatement,
		SymbolTypeAnnotation,
		TaggedTemplateExpression,
		TemplateElement,
		TemplateLiteral,
		ThisExpression,
		ThisTypeAnnotation,
		ThrowStatement,
		TryStatement,
		TupleTypeAnnotation,
		TupleTypeLabeledElement,
		TupleTypeSpreadElement,
		TypeAlias,
		TypeAnnotation,
		TypeCastExpression,
		TypeofTypeAnnotation,
		TypeOperator,
		TypeParameter,
		TypeParameterDeclaration,
		TypeParameterInstantiation,
		TypePredicate,
		UnaryExpression,
		UnionTypeAnnotation,
		UpdateExpression,
		VariableDeclaration,
		VariableDeclarator,
		Variance,
		VoidTypeAnnotation,
		WhileStatement,
		WithStatement,
		YieldExpression,
		Literal,
		LineComment,
		BlockComment,
		MostTokens,
		} from 'hermes-estree';
		*/

		@@ -306,1104 +482,2208 @@ Object.defineProperty(exports, "__esModule", {

		function isAnyTypeAnnotation(node) {
		function isIdentifier(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier';
		}

		function isJSXIdentifier(node
		/: ESNode \| Token /
		)
		/: node is (JSXIdentifier \| MostTokens) /
		{
		return node.type === 'JSXIdentifier';
		}

		function isJSXText(node
		/: ESNode \| Token /
		)
		/: node is (JSXText \| MostTokens) /
		{
		return node.type === 'JSXText';
		}

		function isAnyTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is AnyTypeAnnotation /
		{
		return node.type === 'AnyTypeAnnotation';
		}

		function isArrayExpression(node) {
		function isArrayExpression(node
		/: ESNode \| Token /
		)
		/: node is ArrayExpression /
		{
		return node.type === 'ArrayExpression';
		}

		function isArrayPattern(node) {
		function isArrayPattern(node
		/: ESNode \| Token /
		)
		/: node is ArrayPattern /
		{
		return node.type === 'ArrayPattern';
		}

		function isArrayTypeAnnotation(node) {
		function isArrayTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is ArrayTypeAnnotation /
		{
		return node.type === 'ArrayTypeAnnotation';
		}

		function isArrowFunctionExpression(node) {
		function isArrowFunctionExpression(node
		/: ESNode \| Token /
		)
		/: node is ArrowFunctionExpression /
		{
		return node.type === 'ArrowFunctionExpression';
		}

		function isAsExpression(node) {
		function isAsExpression(node
		/: ESNode \| Token /
		)
		/: node is AsExpression /
		{
		return node.type === 'AsExpression';
		}

		function isAssignmentExpression(node) {
		function isAssignmentExpression(node
		/: ESNode \| Token /
		)
		/: node is AssignmentExpression /
		{
		return node.type === 'AssignmentExpression';
		}

		function isAssignmentPattern(node) {
		function isAssignmentPattern(node
		/: ESNode \| Token /
		)
		/: node is AssignmentPattern /
		{
		return node.type === 'AssignmentPattern';
		}

		function isAwaitExpression(node) {
		function isAwaitExpression(node
		/: ESNode \| Token /
		)
		/: node is AwaitExpression /
		{
		return node.type === 'AwaitExpression';
		}

		function isBigIntLiteralTypeAnnotation(node) {
		function isBigIntLiteralTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is BigIntLiteralTypeAnnotation /
		{
		return node.type === 'BigIntLiteralTypeAnnotation';
		}

		function isBigIntTypeAnnotation(node) {
		function isBigIntTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is BigIntTypeAnnotation /
		{
		return node.type === 'BigIntTypeAnnotation';
		}

		function isBinaryExpression(node) {
		function isBinaryExpression(node
		/: ESNode \| Token /
		)
		/: node is BinaryExpression /
		{
		return node.type === 'BinaryExpression';
		}

		function isBlockStatement(node) {
		function isBlockStatement(node
		/: ESNode \| Token /
		)
		/: node is BlockStatement /
		{
		return node.type === 'BlockStatement';
		}

		function isBooleanLiteralTypeAnnotation(node) {
		function isBooleanLiteralTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is BooleanLiteralTypeAnnotation /
		{
		return node.type === 'BooleanLiteralTypeAnnotation';
		}

		function isBooleanTypeAnnotation(node) {
		function isBooleanTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is BooleanTypeAnnotation /
		{
		return node.type === 'BooleanTypeAnnotation';
		}

		function isBreakStatement(node) {
		function isBreakStatement(node
		/: ESNode \| Token /
		)
		/: node is BreakStatement /
		{
		return node.type === 'BreakStatement';
		}

		function isCallExpression(node) {
		function isCallExpression(node
		/: ESNode \| Token /
		)
		/: node is CallExpression /
		{
		return node.type === 'CallExpression';
		}

		function isCatchClause(node) {
		function isCatchClause(node
		/: ESNode \| Token /
		)
		/: node is CatchClause /
		{
		return node.type === 'CatchClause';
		}

		function isChainExpression(node) {
		function isChainExpression(node
		/: ESNode \| Token /
		)
		/: node is ChainExpression /
		{
		return node.type === 'ChainExpression';
		}

		function isClassBody(node) {
		function isClassBody(node
		/: ESNode \| Token /
		)
		/: node is ClassBody /
		{
		return node.type === 'ClassBody';
		}

		function isClassDeclaration(node) {
		function isClassDeclaration(node
		/: ESNode \| Token /
		)
		/: node is ClassDeclaration /
		{
		return node.type === 'ClassDeclaration';
		}

		function isClassExpression(node) {
		function isClassExpression(node
		/: ESNode \| Token /
		)
		/: node is ClassExpression /
		{
		return node.type === 'ClassExpression';
		}

		function isClassImplements(node) {
		function isClassImplements(node
		/: ESNode \| Token /
		)
		/: node is ClassImplements /
		{
		return node.type === 'ClassImplements';
		}

		function isComponentDeclaration(node) {
		function isComponentDeclaration(node
		/: ESNode \| Token /
		)
		/: node is ComponentDeclaration /
		{
		return node.type === 'ComponentDeclaration';
		}

		function isComponentParameter(node) {
		function isComponentParameter(node
		/: ESNode \| Token /
		)
		/: node is ComponentParameter /
		{
		return node.type === 'ComponentParameter';
		}

		function isComponentTypeAnnotation(node) {
		function isComponentTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is ComponentTypeAnnotation /
		{
		return node.type === 'ComponentTypeAnnotation';
		}

		function isComponentTypeParameter(node) {
		function isComponentTypeParameter(node
		/: ESNode \| Token /
		)
		/: node is ComponentTypeParameter /
		{
		return node.type === 'ComponentTypeParameter';
		}

		function isConditionalExpression(node) {
		function isConditionalExpression(node
		/: ESNode \| Token /
		)
		/: node is ConditionalExpression /
		{
		return node.type === 'ConditionalExpression';
		}

		function isConditionalTypeAnnotation(node) {
		function isConditionalTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is ConditionalTypeAnnotation /
		{
		return node.type === 'ConditionalTypeAnnotation';
		}

		function isContinueStatement(node) {
		function isContinueStatement(node
		/: ESNode \| Token /
		)
		/: node is ContinueStatement /
		{
		return node.type === 'ContinueStatement';
		}

		function isDebuggerStatement(node) {
		function isDebuggerStatement(node
		/: ESNode \| Token /
		)
		/: node is DebuggerStatement /
		{
		return node.type === 'DebuggerStatement';
		}

		function isDeclareClass(node) {
		function isDeclareClass(node
		/: ESNode \| Token /
		)
		/: node is DeclareClass /
		{
		return node.type === 'DeclareClass';
		}

		function isDeclareComponent(node) {
		function isDeclareComponent(node
		/: ESNode \| Token /
		)
		/: node is DeclareComponent /
		{
		return node.type === 'DeclareComponent';
		}

		function isDeclaredPredicate(node) {
		function isDeclaredPredicate(node
		/: ESNode \| Token /
		)
		/: node is DeclaredPredicate /
		{
		return node.type === 'DeclaredPredicate';
		}

		function isDeclareEnum(node) {
		function isDeclareEnum(node
		/: ESNode \| Token /
		)
		/: node is DeclareEnum /
		{
		return node.type === 'DeclareEnum';
		}

		function isDeclareExportAllDeclaration(node) {
		function isDeclareExportAllDeclaration(node
		/: ESNode \| Token /
		)
		/: node is DeclareExportAllDeclaration /
		{
		return node.type === 'DeclareExportAllDeclaration';
		}

		function isDeclareExportDeclaration(node) {
		function isDeclareExportDeclaration(node
		/: ESNode \| Token /
		)
		/: node is DeclareExportDeclaration /
		{
		return node.type === 'DeclareExportDeclaration';
		}

		function isDeclareFunction(node) {
		function isDeclareFunction(node
		/: ESNode \| Token /
		)
		/: node is DeclareFunction /
		{
		return node.type === 'DeclareFunction';
		}

		function isDeclareInterface(node) {
		function isDeclareInterface(node
		/: ESNode \| Token /
		)
		/: node is DeclareInterface /
		{
		return node.type === 'DeclareInterface';
		}

		function isDeclareModule(node) {
		function isDeclareModule(node
		/: ESNode \| Token /
		)
		/: node is DeclareModule /
		{
		return node.type === 'DeclareModule';
		}

		function isDeclareModuleExports(node) {
		function isDeclareModuleExports(node
		/: ESNode \| Token /
		)
		/: node is DeclareModuleExports /
		{
		return node.type === 'DeclareModuleExports';
		}

		function isDeclareOpaqueType(node) {
		function isDeclareOpaqueType(node
		/: ESNode \| Token /
		)
		/: node is DeclareOpaqueType /
		{
		return node.type === 'DeclareOpaqueType';
		}

		function isDeclareTypeAlias(node) {
		function isDeclareTypeAlias(node
		/: ESNode \| Token /
		)
		/: node is DeclareTypeAlias /
		{
		return node.type === 'DeclareTypeAlias';
		}

		function isDeclareVariable(node) {
		function isDeclareVariable(node
		/: ESNode \| Token /
		)
		/: node is DeclareVariable /
		{
		return node.type === 'DeclareVariable';
		}

		function isDoWhileStatement(node) {
		function isDoWhileStatement(node
		/: ESNode \| Token /
		)
		/: node is DoWhileStatement /
		{
		return node.type === 'DoWhileStatement';
		}

		function isEmptyStatement(node) {
		function isEmptyStatement(node
		/: ESNode \| Token /
		)
		/: node is EmptyStatement /
		{
		return node.type === 'EmptyStatement';
		}

		function isEmptyTypeAnnotation(node) {
		function isEmptyTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is EmptyTypeAnnotation /
		{
		return node.type === 'EmptyTypeAnnotation';
		}

		function isEnumBooleanBody(node) {
		function isEnumBooleanBody(node
		/: ESNode \| Token /
		)
		/: node is EnumBooleanBody /
		{
		return node.type === 'EnumBooleanBody';
		}

		function isEnumBooleanMember(node) {
		function isEnumBooleanMember(node
		/: ESNode \| Token /
		)
		/: node is EnumBooleanMember /
		{
		return node.type === 'EnumBooleanMember';
		}

		function isEnumDeclaration(node) {
		function isEnumDeclaration(node
		/: ESNode \| Token /
		)
		/: node is EnumDeclaration /
		{
		return node.type === 'EnumDeclaration';
		}

		function isEnumDefaultedMember(node) {
		function isEnumDefaultedMember(node
		/: ESNode \| Token /
		)
		/: node is EnumDefaultedMember /
		{
		return node.type === 'EnumDefaultedMember';
		}

		function isEnumNumberBody(node) {
		function isEnumNumberBody(node
		/: ESNode \| Token /
		)
		/: node is EnumNumberBody /
		{
		return node.type === 'EnumNumberBody';
		}

		function isEnumNumberMember(node) {
		function isEnumNumberMember(node
		/: ESNode \| Token /
		)
		/: node is EnumNumberMember /
		{
		return node.type === 'EnumNumberMember';
		}

		function isEnumStringBody(node) {
		function isEnumStringBody(node
		/: ESNode \| Token /
		)
		/: node is EnumStringBody /
		{
		return node.type === 'EnumStringBody';
		}

		function isEnumStringMember(node) {
		function isEnumStringMember(node
		/: ESNode \| Token /
		)
		/: node is EnumStringMember /
		{
		return node.type === 'EnumStringMember';
		}

		function isEnumSymbolBody(node) {
		function isEnumSymbolBody(node
		/: ESNode \| Token /
		)
		/: node is EnumSymbolBody /
		{
		return node.type === 'EnumSymbolBody';
		}

		function isExistsTypeAnnotation(node) {
		function isExistsTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is ExistsTypeAnnotation /
		{
		return node.type === 'ExistsTypeAnnotation';
		}

		function isExportAllDeclaration(node) {
		function isExportAllDeclaration(node
		/: ESNode \| Token /
		)
		/: node is ExportAllDeclaration /
		{
		return node.type === 'ExportAllDeclaration';
		}

		function isExportDefaultDeclaration(node) {
		function isExportDefaultDeclaration(node
		/: ESNode \| Token /
		)
		/: node is ExportDefaultDeclaration /
		{
		return node.type === 'ExportDefaultDeclaration';
		}

		function isExportNamedDeclaration(node) {
		function isExportNamedDeclaration(node
		/: ESNode \| Token /
		)
		/: node is ExportNamedDeclaration /
		{
		return node.type === 'ExportNamedDeclaration';
		}

		function isExportSpecifier(node) {
		function isExportSpecifier(node
		/: ESNode \| Token /
		)
		/: node is ExportSpecifier /
		{
		return node.type === 'ExportSpecifier';
		}

		function isExpressionStatement(node) {
		function isExpressionStatement(node
		/: ESNode \| Token /
		)
		/: node is ExpressionStatement /
		{
		return node.type === 'ExpressionStatement';
		}

		function isForInStatement(node) {
		function isForInStatement(node
		/: ESNode \| Token /
		)
		/: node is ForInStatement /
		{
		return node.type === 'ForInStatement';
		}

		function isForOfStatement(node) {
		function isForOfStatement(node
		/: ESNode \| Token /
		)
		/: node is ForOfStatement /
		{
		return node.type === 'ForOfStatement';
		}

		function isForStatement(node) {
		function isForStatement(node
		/: ESNode \| Token /
		)
		/: node is ForStatement /
		{
		return node.type === 'ForStatement';
		}

		function isFunctionDeclaration(node) {
		function isFunctionDeclaration(node
		/: ESNode \| Token /
		)
		/: node is FunctionDeclaration /
		{
		return node.type === 'FunctionDeclaration';
		}

		function isFunctionExpression(node) {
		function isFunctionExpression(node
		/: ESNode \| Token /
		)
		/: node is FunctionExpression /
		{
		return node.type === 'FunctionExpression';
		}

		function isFunctionTypeAnnotation(node) {
		function isFunctionTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is FunctionTypeAnnotation /
		{
		return node.type === 'FunctionTypeAnnotation';
		}

		function isFunctionTypeParam(node) {
		function isFunctionTypeParam(node
		/: ESNode \| Token /
		)
		/: node is FunctionTypeParam /
		{
		return node.type === 'FunctionTypeParam';
		}

		function isGenericTypeAnnotation(node) {
		function isGenericTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is GenericTypeAnnotation /
		{
		return node.type === 'GenericTypeAnnotation';
		}

		function isIdentifier(node) {
		return node.type === 'Identifier';
		}

		function isIfStatement(node) {
		function isIfStatement(node
		/: ESNode \| Token /
		)
		/: node is IfStatement /
		{
		return node.type === 'IfStatement';
		}

		function isImportAttribute(node) {
		function isImportAttribute(node
		/: ESNode \| Token /
		)
		/: node is ImportAttribute /
		{
		return node.type === 'ImportAttribute';
		}

		function isImportDeclaration(node) {
		function isImportDeclaration(node
		/: ESNode \| Token /
		)
		/: node is ImportDeclaration /
		{
		return node.type === 'ImportDeclaration';
		}

		function isImportDefaultSpecifier(node) {
		function isImportDefaultSpecifier(node
		/: ESNode \| Token /
		)
		/: node is ImportDefaultSpecifier /
		{
		return node.type === 'ImportDefaultSpecifier';
		}

		function isImportExpression(node) {
		function isImportExpression(node
		/: ESNode \| Token /
		)
		/: node is ImportExpression /
		{
		return node.type === 'ImportExpression';
		}

		function isImportNamespaceSpecifier(node) {
		function isImportNamespaceSpecifier(node
		/: ESNode \| Token /
		)
		/: node is ImportNamespaceSpecifier /
		{
		return node.type === 'ImportNamespaceSpecifier';
		}

		function isImportSpecifier(node) {
		function isImportSpecifier(node
		/: ESNode \| Token /
		)
		/: node is ImportSpecifier /
		{
		return node.type === 'ImportSpecifier';
		}

		function isIndexedAccessType(node) {
		function isIndexedAccessType(node
		/: ESNode \| Token /
		)
		/: node is IndexedAccessType /
		{
		return node.type === 'IndexedAccessType';
		}

		function isInferredPredicate(node) {
		function isInferredPredicate(node
		/: ESNode \| Token /
		)
		/: node is InferredPredicate /
		{
		return node.type === 'InferredPredicate';
		}

		function isInferTypeAnnotation(node) {
		function isInferTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is InferTypeAnnotation /
		{
		return node.type === 'InferTypeAnnotation';
		}

		function isInterfaceDeclaration(node) {
		function isInterfaceDeclaration(node
		/: ESNode \| Token /
		)
		/: node is InterfaceDeclaration /
		{
		return node.type === 'InterfaceDeclaration';
		}

		function isInterfaceExtends(node) {
		function isInterfaceExtends(node
		/: ESNode \| Token /
		)
		/: node is InterfaceExtends /
		{
		return node.type === 'InterfaceExtends';
		}

		function isInterfaceTypeAnnotation(node) {
		function isInterfaceTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is InterfaceTypeAnnotation /
		{
		return node.type === 'InterfaceTypeAnnotation';
		}

		function isIntersectionTypeAnnotation(node) {
		function isIntersectionTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is IntersectionTypeAnnotation /
		{
		return node.type === 'IntersectionTypeAnnotation';
		}

		function isJSXAttribute(node) {
		function isJSXAttribute(node
		/: ESNode \| Token /
		)
		/: node is JSXAttribute /
		{
		return node.type === 'JSXAttribute';
		}

		function isJSXClosingElement(node) {
		function isJSXClosingElement(node
		/: ESNode \| Token /
		)
		/: node is JSXClosingElement /
		{
		return node.type === 'JSXClosingElement';
		}

		function isJSXClosingFragment(node) {
		function isJSXClosingFragment(node
		/: ESNode \| Token /
		)
		/: node is JSXClosingFragment /
		{
		return node.type === 'JSXClosingFragment';
		}

		function isJSXElement(node) {
		function isJSXElement(node
		/: ESNode \| Token /
		)
		/: node is JSXElement /
		{
		return node.type === 'JSXElement';
		}

		function isJSXEmptyExpression(node) {
		function isJSXEmptyExpression(node
		/: ESNode \| Token /
		)
		/: node is JSXEmptyExpression /
		{
		return node.type === 'JSXEmptyExpression';
		}

		function isJSXExpressionContainer(node) {
		function isJSXExpressionContainer(node
		/: ESNode \| Token /
		)
		/: node is JSXExpressionContainer /
		{
		return node.type === 'JSXExpressionContainer';
		}

		function isJSXFragment(node) {
		function isJSXFragment(node
		/: ESNode \| Token /
		)
		/: node is JSXFragment /
		{
		return node.type === 'JSXFragment';
		}

		function isJSXIdentifier(node) {
		return node.type === 'JSXIdentifier';
		}

		function isJSXMemberExpression(node) {
		function isJSXMemberExpression(node
		/: ESNode \| Token /
		)
		/: node is JSXMemberExpression /
		{
		return node.type === 'JSXMemberExpression';
		}

		function isJSXNamespacedName(node) {
		function isJSXNamespacedName(node
		/: ESNode \| Token /
		)
		/: node is JSXNamespacedName /
		{
		return node.type === 'JSXNamespacedName';
		}

		function isJSXOpeningElement(node) {
		function isJSXOpeningElement(node
		/: ESNode \| Token /
		)
		/: node is JSXOpeningElement /
		{
		return node.type === 'JSXOpeningElement';
		}

		function isJSXOpeningFragment(node) {
		function isJSXOpeningFragment(node
		/: ESNode \| Token /
		)
		/: node is JSXOpeningFragment /
		{
		return node.type === 'JSXOpeningFragment';
		}

		function isJSXSpreadAttribute(node) {
		function isJSXSpreadAttribute(node
		/: ESNode \| Token /
		)
		/: node is JSXSpreadAttribute /
		{
		return node.type === 'JSXSpreadAttribute';
		}

		function isJSXSpreadChild(node) {
		function isJSXSpreadChild(node
		/: ESNode \| Token /
		)
		/: node is JSXSpreadChild /
		{
		return node.type === 'JSXSpreadChild';
		}

		function isJSXText(node) {
		return node.type === 'JSXText';
		}

		function isKeyofTypeAnnotation(node) {
		function isKeyofTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is KeyofTypeAnnotation /
		{
		return node.type === 'KeyofTypeAnnotation';
		}

		function isLabeledStatement(node) {
		function isLabeledStatement(node
		/: ESNode \| Token /
		)
		/: node is LabeledStatement /
		{
		return node.type === 'LabeledStatement';
		}

		function isLogicalExpression(node) {
		function isLogicalExpression(node
		/: ESNode \| Token /
		)
		/: node is LogicalExpression /
		{
		return node.type === 'LogicalExpression';
		}

		function isMemberExpression(node) {
		function isMemberExpression(node
		/: ESNode \| Token /
		)
		/: node is MemberExpression /
		{
		return node.type === 'MemberExpression';
		}

		function isMetaProperty(node) {
		function isMetaProperty(node
		/: ESNode \| Token /
		)
		/: node is MetaProperty /
		{
		return node.type === 'MetaProperty';
		}

		function isMethodDefinition(node) {
		function isMethodDefinition(node
		/: ESNode \| Token /
		)
		/: node is MethodDefinition /
		{
		return node.type === 'MethodDefinition';
		}

		function isMixedTypeAnnotation(node) {
		function isMixedTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is MixedTypeAnnotation /
		{
		return node.type === 'MixedTypeAnnotation';
		}

		function isNewExpression(node) {
		function isNewExpression(node
		/: ESNode \| Token /
		)
		/: node is NewExpression /
		{
		return node.type === 'NewExpression';
		}

		function isNullableTypeAnnotation(node) {
		function isNullableTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is NullableTypeAnnotation /
		{
		return node.type === 'NullableTypeAnnotation';
		}

		function isNullLiteralTypeAnnotation(node) {
		function isNullLiteralTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is NullLiteralTypeAnnotation /
		{
		return node.type === 'NullLiteralTypeAnnotation';
		}

		function isNumberLiteralTypeAnnotation(node) {
		function isNumberLiteralTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is NumberLiteralTypeAnnotation /
		{
		return node.type === 'NumberLiteralTypeAnnotation';
		}

		function isNumberTypeAnnotation(node) {
		function isNumberTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is NumberTypeAnnotation /
		{
		return node.type === 'NumberTypeAnnotation';
		}

		function isObjectExpression(node) {
		function isObjectExpression(node
		/: ESNode \| Token /
		)
		/: node is ObjectExpression /
		{
		return node.type === 'ObjectExpression';
		}

		function isObjectPattern(node) {
		function isObjectPattern(node
		/: ESNode \| Token /
		)
		/: node is ObjectPattern /
		{
		return node.type === 'ObjectPattern';
		}

		function isObjectTypeAnnotation(node) {
		function isObjectTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is ObjectTypeAnnotation /
		{
		return node.type === 'ObjectTypeAnnotation';
		}

		function isObjectTypeCallProperty(node) {
		function isObjectTypeCallProperty(node
		/: ESNode \| Token /
		)
		/: node is ObjectTypeCallProperty /
		{
		return node.type === 'ObjectTypeCallProperty';
		}

		function isObjectTypeIndexer(node) {
		function isObjectTypeIndexer(node
		/: ESNode \| Token /
		)
		/: node is ObjectTypeIndexer /
		{
		return node.type === 'ObjectTypeIndexer';
		}

		function isObjectTypeInternalSlot(node) {
		function isObjectTypeInternalSlot(node
		/: ESNode \| Token /
		)
		/: node is ObjectTypeInternalSlot /
		{
		return node.type === 'ObjectTypeInternalSlot';
		}

		function isObjectTypeMappedTypeProperty(node) {
		function isObjectTypeMappedTypeProperty(node
		/: ESNode \| Token /
		)
		/: node is ObjectTypeMappedTypeProperty /
		{
		return node.type === 'ObjectTypeMappedTypeProperty';
		}

		function isObjectTypeProperty(node) {
		function isObjectTypeProperty(node
		/: ESNode \| Token /
		)
		/: node is ObjectTypeProperty /
		{
		return node.type === 'ObjectTypeProperty';
		}

		function isObjectTypeSpreadProperty(node) {
		function isObjectTypeSpreadProperty(node
		/: ESNode \| Token /
		)
		/: node is ObjectTypeSpreadProperty /
		{
		return node.type === 'ObjectTypeSpreadProperty';
		}

		function isOpaqueType(node) {
		function isOpaqueType(node
		/: ESNode \| Token /
		)
		/: node is OpaqueType /
		{
		return node.type === 'OpaqueType';
		}

		function isOptionalIndexedAccessType(node) {
		function isOptionalIndexedAccessType(node
		/: ESNode \| Token /
		)
		/: node is OptionalIndexedAccessType /
		{
		return node.type === 'OptionalIndexedAccessType';
		}

		function isPrivateIdentifier(node) {
		function isPrivateIdentifier(node
		/: ESNode \| Token /
		)
		/: node is PrivateIdentifier /
		{
		return node.type === 'PrivateIdentifier';
		}

		function isProperty(node) {
		function isProperty(node
		/: ESNode \| Token /
		)
		/: node is Property /
		{
		return node.type === 'Property';
		}

		function isPropertyDefinition(node) {
		function isPropertyDefinition(node
		/: ESNode \| Token /
		)
		/: node is PropertyDefinition /
		{
		return node.type === 'PropertyDefinition';
		}

		function isQualifiedTypeIdentifier(node) {
		function isQualifiedTypeIdentifier(node
		/: ESNode \| Token /
		)
		/: node is QualifiedTypeIdentifier /
		{
		return node.type === 'QualifiedTypeIdentifier';
		}

		function isQualifiedTypeofIdentifier(node) {
		function isQualifiedTypeofIdentifier(node
		/: ESNode \| Token /
		)
		/: node is QualifiedTypeofIdentifier /
		{
		return node.type === 'QualifiedTypeofIdentifier';
		}

		function isRestElement(node) {
		function isRestElement(node
		/: ESNode \| Token /
		)
		/: node is RestElement /
		{
		return node.type === 'RestElement';
		}

		function isReturnStatement(node) {
		function isReturnStatement(node
		/: ESNode \| Token /
		)
		/: node is ReturnStatement /
		{
		return node.type === 'ReturnStatement';
		}

		function isSequenceExpression(node) {
		function isSequenceExpression(node
		/: ESNode \| Token /
		)
		/: node is SequenceExpression /
		{
		return node.type === 'SequenceExpression';
		}

		function isSpreadElement(node) {
		function isSpreadElement(node
		/: ESNode \| Token /
		)
		/: node is SpreadElement /
		{
		return node.type === 'SpreadElement';
		}

		function isStringLiteralTypeAnnotation(node) {
		function isStringLiteralTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is StringLiteralTypeAnnotation /
		{
		return node.type === 'StringLiteralTypeAnnotation';
		}

		function isStringTypeAnnotation(node) {
		function isStringTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is StringTypeAnnotation /
		{
		return node.type === 'StringTypeAnnotation';
		}

		function isSuper(node) {
		function isSuper(node
		/: ESNode \| Token /
		)
		/: node is Super /
		{
		return node.type === 'Super';
		}

		function isSwitchCase(node) {
		function isSwitchCase(node
		/: ESNode \| Token /
		)
		/: node is SwitchCase /
		{
		return node.type === 'SwitchCase';
		}

		function isSwitchStatement(node) {
		function isSwitchStatement(node
		/: ESNode \| Token /
		)
		/: node is SwitchStatement /
		{
		return node.type === 'SwitchStatement';
		}

		function isSymbolTypeAnnotation(node) {
		function isSymbolTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is SymbolTypeAnnotation /
		{
		return node.type === 'SymbolTypeAnnotation';
		}

		function isTaggedTemplateExpression(node) {
		function isTaggedTemplateExpression(node
		/: ESNode \| Token /
		)
		/: node is TaggedTemplateExpression /
		{
		return node.type === 'TaggedTemplateExpression';
		}

		function isTemplateElement(node) {
		function isTemplateElement(node
		/: ESNode \| Token /
		)
		/: node is TemplateElement /
		{
		return node.type === 'TemplateElement';
		}

		function isTemplateLiteral(node) {
		function isTemplateLiteral(node
		/: ESNode \| Token /
		)
		/: node is TemplateLiteral /
		{
		return node.type === 'TemplateLiteral';
		}

		function isThisExpression(node) {
		function isThisExpression(node
		/: ESNode \| Token /
		)
		/: node is ThisExpression /
		{
		return node.type === 'ThisExpression';
		}

		function isThisTypeAnnotation(node) {
		function isThisTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is ThisTypeAnnotation /
		{
		return node.type === 'ThisTypeAnnotation';
		}

		function isThrowStatement(node) {
		function isThrowStatement(node
		/: ESNode \| Token /
		)
		/: node is ThrowStatement /
		{
		return node.type === 'ThrowStatement';
		}

		function isTryStatement(node) {
		function isTryStatement(node
		/: ESNode \| Token /
		)
		/: node is TryStatement /
		{
		return node.type === 'TryStatement';
		}

		function isTupleTypeAnnotation(node) {
		function isTupleTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is TupleTypeAnnotation /
		{
		return node.type === 'TupleTypeAnnotation';
		}

		function isTupleTypeLabeledElement(node) {
		function isTupleTypeLabeledElement(node
		/: ESNode \| Token /
		)
		/: node is TupleTypeLabeledElement /
		{
		return node.type === 'TupleTypeLabeledElement';
		}

		function isTupleTypeSpreadElement(node) {
		function isTupleTypeSpreadElement(node
		/: ESNode \| Token /
		)
		/: node is TupleTypeSpreadElement /
		{
		return node.type === 'TupleTypeSpreadElement';
		}

		function isTypeAlias(node) {
		function isTypeAlias(node
		/: ESNode \| Token /
		)
		/: node is TypeAlias /
		{
		return node.type === 'TypeAlias';
		}

		function isTypeAnnotation(node) {
		function isTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is TypeAnnotation /
		{
		return node.type === 'TypeAnnotation';
		}

		function isTypeCastExpression(node) {
		function isTypeCastExpression(node
		/: ESNode \| Token /
		)
		/: node is TypeCastExpression /
		{
		return node.type === 'TypeCastExpression';
		}

		function isTypeofTypeAnnotation(node) {
		function isTypeofTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is TypeofTypeAnnotation /
		{
		return node.type === 'TypeofTypeAnnotation';
		}

		function isTypeOperator(node) {
		function isTypeOperator(node
		/: ESNode \| Token /
		)
		/: node is TypeOperator /
		{
		return node.type === 'TypeOperator';
		}

		function isTypeParameter(node) {
		function isTypeParameter(node
		/: ESNode \| Token /
		)
		/: node is TypeParameter /
		{
		return node.type === 'TypeParameter';
		}

		function isTypeParameterDeclaration(node) {
		function isTypeParameterDeclaration(node
		/: ESNode \| Token /
		)
		/: node is TypeParameterDeclaration /
		{
		return node.type === 'TypeParameterDeclaration';
		}

		function isTypeParameterInstantiation(node) {
		function isTypeParameterInstantiation(node
		/: ESNode \| Token /
		)
		/: node is TypeParameterInstantiation /
		{
		return node.type === 'TypeParameterInstantiation';
		}

		function isTypePredicate(node) {
		function isTypePredicate(node
		/: ESNode \| Token /
		)
		/: node is TypePredicate /
		{
		return node.type === 'TypePredicate';
		}

		function isUnaryExpression(node) {
		function isUnaryExpression(node
		/: ESNode \| Token /
		)
		/: node is UnaryExpression /
		{
		return node.type === 'UnaryExpression';
		}

		function isUnionTypeAnnotation(node) {
		function isUnionTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is UnionTypeAnnotation /
		{
		return node.type === 'UnionTypeAnnotation';
		}

		function isUpdateExpression(node) {
		function isUpdateExpression(node
		/: ESNode \| Token /
		)
		/: node is UpdateExpression /
		{
		return node.type === 'UpdateExpression';
		}

		function isVariableDeclaration(node) {
		function isVariableDeclaration(node
		/: ESNode \| Token /
		)
		/: node is VariableDeclaration /
		{
		return node.type === 'VariableDeclaration';
		}

		function isVariableDeclarator(node) {
		function isVariableDeclarator(node
		/: ESNode \| Token /
		)
		/: node is VariableDeclarator /
		{
		return node.type === 'VariableDeclarator';
		}

		function isVariance(node) {
		function isVariance(node
		/: ESNode \| Token /
		)
		/: node is Variance /
		{
		return node.type === 'Variance';
		}

		function isVoidTypeAnnotation(node) {
		function isVoidTypeAnnotation(node
		/: ESNode \| Token /
		)
		/: node is VoidTypeAnnotation /
		{
		return node.type === 'VoidTypeAnnotation';
		}

		function isWhileStatement(node) {
		function isWhileStatement(node
		/: ESNode \| Token /
		)
		/: node is WhileStatement /
		{
		return node.type === 'WhileStatement';
		}

		function isWithStatement(node) {
		function isWithStatement(node
		/: ESNode \| Token /
		)
		/: node is WithStatement /
		{
		return node.type === 'WithStatement';
		}

		function isYieldExpression(node) {
		function isYieldExpression(node
		/: ESNode \| Token /
		)
		/: node is YieldExpression /
		{
		return node.type === 'YieldExpression';
		}

		function isLiteral(node) {
		function isLiteral(node
		/: ESNode \| Token /
		)
		/: node is Literal /
		{
		return node.type === 'Literal';
		}

		function isLineComment(node) {
		function isLineComment(node
		/: ESNode \| Token /
		)
		/: node is (MostTokens \| LineComment) /
		{
		return node.type === 'Line';
		}

		function isBlockComment(node) {
		function isBlockComment(node
		/: ESNode \| Token /
		)
		/: node is (MostTokens \| BlockComment) /
		{
		return node.type === 'Block';
		}

		function isMinusToken(node) {
		function isMinusToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '-';
		}

		function isPlusToken(node) {
		function isPlusToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '+';
		}

		function isLogicalNotToken(node) {
		function isLogicalNotToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '!';
		}

		function isUnaryNegationToken(node) {
		function isUnaryNegationToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '~';
		}

		function isTypeOfToken(node) {
		function isTypeOfToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'typeof';
		}

		function isVoidToken(node) {
		function isVoidToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'void';
		}

		function isDeleteToken(node) {
		function isDeleteToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'delete';
		}

		function isLooseEqualToken(node) {
		function isLooseEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '==';
		}

		function isLooseNotEqualToken(node) {
		function isLooseNotEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '!=';
		}

		function isStrictEqualToken(node) {
		function isStrictEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '===';
		}

		function isStrictNotEqualToken(node) {
		function isStrictNotEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '!==';
		}

		function isLessThanToken(node) {
		function isLessThanToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '<';
		}

		function isLessThanOrEqualToToken(node) {
		function isLessThanOrEqualToToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '<=';
		}

		function isGreaterThanToken(node) {
		function isGreaterThanToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '>';
		}

		function isGreaterThanOrEqualToToken(node) {
		function isGreaterThanOrEqualToToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '>=';
		}

		function isBitwiseLeftShiftToken(node) {
		function isBitwiseLeftShiftToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '<<';
		}

		function isBitwiseRightShiftToken(node) {
		function isBitwiseRightShiftToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '>>';
		}

		function isBitwiseUnsignedRightShiftToken(node) {
		function isBitwiseUnsignedRightShiftToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '>>>';
		}

		function isAsterixToken(node) {
		function isAsterixToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '*';
		}

		function isForwardSlashToken(node) {
		function isForwardSlashToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '/';
		}

		function isPercentToken(node) {
		function isPercentToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '%';
		}

		function isExponentiationToken(node) {
		function isExponentiationToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '**';
		}

		function isBitwiseORToken(node) {
		function isBitwiseORToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '\|';
		}

		function isBitwiseXORToken(node) {
		function isBitwiseXORToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '^';
		}

		function isBitwiseANDToken(node) {
		function isBitwiseANDToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '&';
		}

		function isInToken(node) {
		function isInToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'in';
		}

		function isInstanceOfToken(node) {
		function isInstanceOfToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'instanceof';
		}

		function isLogicalORToken(node) {
		function isLogicalORToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '\|\|';
		}

		function isLogicalANDToken(node) {
		function isLogicalANDToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '&&';
		}

		function isNullishCoalesceToken(node) {
		function isNullishCoalesceToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '??';
		}

		function isEqualToken(node) {
		function isEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '=';
		}

		function isPlusEqualToken(node) {
		function isPlusEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '+=';
		}

		function isMinusEqualToken(node) {
		function isMinusEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '-=';
		}

		function isMultiplyEqualToken(node) {
		function isMultiplyEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '*=';
		}

		function isDivideEqualToken(node) {
		function isDivideEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '/=';
		}

		function isRemainderEqualToken(node) {
		function isRemainderEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '%=';
		}

		function isExponentateEqualToken(node) {
		function isExponentateEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '**=';
		}

		function isBitwiseLeftShiftEqualToken(node) {
		function isBitwiseLeftShiftEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '<<=';
		}

		function isBitwiseRightShiftEqualToken(node) {
		function isBitwiseRightShiftEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '>>=';
		}

		function isBitwiseUnsignedRightShiftEqualToken(node) {
		function isBitwiseUnsignedRightShiftEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '>>>=';
		}

		function isBitwiseOREqualToken(node) {
		function isBitwiseOREqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '\|=';
		}

		function isBitwiseXOREqualToken(node) {
		function isBitwiseXOREqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '^=';
		}

		function isBitwiseANDEqualToken(node) {
		function isBitwiseANDEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '&=';
		}

		function isLogicalOREqualToken(node) {
		function isLogicalOREqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '\|\|=';
		}

		function isLogicalANDEqualToken(node) {
		function isLogicalANDEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '&&=';
		}

		function isNullishCoalesceEqualToken(node) {
		function isNullishCoalesceEqualToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '??=';
		}

		function isIncrementToken(node) {
		function isIncrementToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '++';
		}

		function isDecrementToken(node) {
		function isDecrementToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '--';
		}

		function isUnionTypeToken(node) {
		function isUnionTypeToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '\|';
		}

		function isIntersectionTypeToken(node) {
		function isIntersectionTypeToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '&';
		}

		function isBreakToken(node) {
		function isBreakToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'break';
		}

		function isCaseToken(node) {
		function isCaseToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'case';
		}

		function isCatchToken(node) {
		function isCatchToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'catch';
		}

		function isClassToken(node) {
		function isClassToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'class';
		}

		function isConstToken(node) {
		function isConstToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'const';
		}

		function isContinueToken(node) {
		function isContinueToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'continue';
		}

		function isDebuggerToken(node) {
		function isDebuggerToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'debugger';
		}

		function isDefaultToken(node) {
		function isDefaultToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'default';
		}

		function isDoToken(node) {
		function isDoToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'do';
		}

		function isElseToken(node) {
		function isElseToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'else';
		}

		function isEnumToken(node) {
		function isEnumToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'enum';
		}

		function isExportToken(node) {
		function isExportToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'export';
		}

		function isExtendsToken(node) {
		function isExtendsToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'extends';
		}

		function isFinallyToken(node) {
		function isFinallyToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'finally';
		}

		function isForToken(node) {
		function isForToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'for';
		}

		function isFunctionToken(node) {
		function isFunctionToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'function';
		}

		function isIfToken(node) {
		function isIfToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'if';
		}

		function isImplementsToken(node) {
		function isImplementsToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'implements';
		}

		function isImportToken(node) {
		function isImportToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'import';
		}

		function isInterfaceToken(node) {
		function isInterfaceToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'interface';
		}

		function isNewToken(node) {
		function isNewToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'new';
		}

		function isReturnToken(node) {
		function isReturnToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'return';
		}

		function isStaticToken(node) {
		function isStaticToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'static';
		}

		function isSuperToken(node) {
		function isSuperToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'super';
		}

		function isSwitchToken(node) {
		function isSwitchToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'switch';
		}

		function isThisToken(node) {
		function isThisToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'this';
		}

		function isThrowToken(node) {
		function isThrowToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'throw';
		}

		function isTryToken(node) {
		function isTryToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'try';
		}

		function isVarToken(node) {
		function isVarToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'var';
		}

		function isWhileToken(node) {
		function isWhileToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'while';
		}

		function isWithToken(node) {
		function isWithToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'with';
		}

		function isYieldToken(node) {
		function isYieldToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Keyword' && node.value === 'yield';
		}

		function isAsKeyword(node) {
		function isAsKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'as' \|\| node.type === 'Keyword' && node.value === 'as';
		}

		function isAsyncKeyword(node) {
		function isAsyncKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'async' \|\| node.type === 'Keyword' && node.value === 'async';
		}

		function isAwaitKeyword(node) {
		function isAwaitKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'await' \|\| node.type === 'Keyword' && node.value === 'await';
		}

		function isDeclareKeyword(node) {
		function isDeclareKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'declare' \|\| node.type === 'Keyword' && node.value === 'declare';
		}

		function isFromKeyword(node) {
		function isFromKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'from' \|\| node.type === 'Keyword' && node.value === 'from';
		}

		function isGetKeyword(node) {
		function isGetKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'get' \|\| node.type === 'Keyword' && node.value === 'get';
		}

		function isLetKeyword(node) {
		function isLetKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'let' \|\| node.type === 'Keyword' && node.value === 'let';
		}

		function isModuleKeyword(node) {
		function isModuleKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'module' \|\| node.type === 'Keyword' && node.value === 'module';
		}

		function isOfKeyword(node) {
		function isOfKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'of' \|\| node.type === 'Keyword' && node.value === 'of';
		}

		function isSetKeyword(node) {
		function isSetKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'set' \|\| node.type === 'Keyword' && node.value === 'set';
		}

		function isTypeKeyword(node) {
		function isTypeKeyword(node
		/: ESNode \| Token /
		)
		/: node is (Identifier \| MostTokens) /
		{
		return node.type === 'Identifier' && node.name === 'type' \|\| node.type === 'Keyword' && node.value === 'type';
		}

		function isCommaToken(node) {
		function isCommaToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === ',';
		}

		function isColonToken(node) {
		function isColonToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === ':';
		}

		function isSemicolonToken(node) {
		function isSemicolonToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === ';';
		}

		function isDotToken(node) {
		function isDotToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '.';
		}

		function isDotDotDotToken(node) {
		function isDotDotDotToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '...';
		}

		function isOptionalChainToken(node) {
		function isOptionalChainToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '?.';
		}

		function isQuestionMarkToken(node) {
		function isQuestionMarkToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '?';
		}

		function isOpeningParenthesisToken(node) {
		function isOpeningParenthesisToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '(';
		}

		function isClosingParenthesisToken(node) {
		function isClosingParenthesisToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === ')';
		}

		function isOpeningCurlyBracketToken(node) {
		function isOpeningCurlyBracketToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '{';
		}

		function isClosingCurlyBracketToken(node) {
		function isClosingCurlyBracketToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '}';
		}

		function isOpeningAngleBracketToken(node) {
		function isOpeningAngleBracketToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '<';
		}

		function isClosingAngleBracketToken(node) {
		function isClosingAngleBracketToken(node
		/: ESNode \| Token /
		)
		/: node is MostTokens /
		{
		return node.type === 'Punctuator' && node.value === '>';
		}

package.json

		{
		"name": "hermes-estree",
		"version": "0.18.0",
		"version": "0.18.1",
		"description": "Flow types for the Flow-ESTree spec produced by the hermes parser",
		@@ -5,0 +5,0 @@ "main": "dist/index.js",

dist/generated/predicates.js.flow

Sorry, the diff of this file is not supported yet

hermes-estree - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics