hermes-estree 0.5.0 → 0.8.0

package/dist/generated/predicates.js.flow

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