typescript 7.1.0-dev.20260813.1 → 7.1.0-dev.20260815.1

package/dist/ast/is.generated.js

@@ -3,108 +3,143 @@ import { SyntaxKind } from "#enums/syntaxKind";
 export function isToken(node) {
     return isTokenKind(node.kind);
 }
+isToken.Handle = isToken;
 export function isIdentifier(node) {
     return node.kind === SyntaxKind.Identifier;
 }
+isIdentifier.Handle = isIdentifier;
 export function isPrivateIdentifier(node) {
     return node.kind === SyntaxKind.PrivateIdentifier;
 }
+isPrivateIdentifier.Handle = isPrivateIdentifier;
 export function isQualifiedName(node) {
     return node.kind === SyntaxKind.QualifiedName;
 }
+isQualifiedName.Handle = isQualifiedName;
 export function isComputedPropertyName(node) {
     return node.kind === SyntaxKind.ComputedPropertyName;
 }
+isComputedPropertyName.Handle = isComputedPropertyName;
 export function isDecorator(node) {
     return node.kind === SyntaxKind.Decorator;
 }
+isDecorator.Handle = isDecorator;
 export function isEmptyStatement(node) {
     return node.kind === SyntaxKind.EmptyStatement;
 }
+isEmptyStatement.Handle = isEmptyStatement;
 export function isIfStatement(node) {
     return node.kind === SyntaxKind.IfStatement;
 }
+isIfStatement.Handle = isIfStatement;
 export function isDoStatement(node) {
     return node.kind === SyntaxKind.DoStatement;
 }
+isDoStatement.Handle = isDoStatement;
 export function isWhileStatement(node) {
     return node.kind === SyntaxKind.WhileStatement;
 }
+isWhileStatement.Handle = isWhileStatement;
 export function isForStatement(node) {
     return node.kind === SyntaxKind.ForStatement;
 }
+isForStatement.Handle = isForStatement;
 export function isBreakStatement(node) {
     return node.kind === SyntaxKind.BreakStatement;
 }
+isBreakStatement.Handle = isBreakStatement;
 export function isContinueStatement(node) {
     return node.kind === SyntaxKind.ContinueStatement;
 }
+isContinueStatement.Handle = isContinueStatement;
 export function isReturnStatement(node) {
     return node.kind === SyntaxKind.ReturnStatement;
 }
+isReturnStatement.Handle = isReturnStatement;
 export function isWithStatement(node) {
     return node.kind === SyntaxKind.WithStatement;
 }
+isWithStatement.Handle = isWithStatement;
 export function isSwitchStatement(node) {
     return node.kind === SyntaxKind.SwitchStatement;
 }
+isSwitchStatement.Handle = isSwitchStatement;
 export function isCaseBlock(node) {
     return node.kind === SyntaxKind.CaseBlock;
 }
+isCaseBlock.Handle = isCaseBlock;
 export function isThrowStatement(node) {
     return node.kind === SyntaxKind.ThrowStatement;
 }
+isThrowStatement.Handle = isThrowStatement;
 export function isTryStatement(node) {
     return node.kind === SyntaxKind.TryStatement;
 }
+isTryStatement.Handle = isTryStatement;
 export function isCatchClause(node) {
     return node.kind === SyntaxKind.CatchClause;
 }
+isCatchClause.Handle = isCatchClause;
 export function isDebuggerStatement(node) {
     return node.kind === SyntaxKind.DebuggerStatement;
 }
+isDebuggerStatement.Handle = isDebuggerStatement;
 export function isLabeledStatement(node) {
     return node.kind === SyntaxKind.LabeledStatement;
 }
+isLabeledStatement.Handle = isLabeledStatement;
 export function isExpressionStatement(node) {
     return node.kind === SyntaxKind.ExpressionStatement;
 }
+isExpressionStatement.Handle = isExpressionStatement;
 export function isBlock(node) {
     return node.kind === SyntaxKind.Block;
 }
+isBlock.Handle = isBlock;
 export function isVariableStatement(node) {
     return node.kind === SyntaxKind.VariableStatement;
 }
+isVariableStatement.Handle = isVariableStatement;
 export function isVariableDeclaration(node) {
     return node.kind === SyntaxKind.VariableDeclaration;
 }
+isVariableDeclaration.Handle = isVariableDeclaration;
 export function isVariableDeclarationList(node) {
     return node.kind === SyntaxKind.VariableDeclarationList;
 }
+isVariableDeclarationList.Handle = isVariableDeclarationList;
 export function isParameterDeclaration(node) {
     return node.kind === SyntaxKind.Parameter;
 }
+isParameterDeclaration.Handle = isParameterDeclaration;
 export function isBindingElement(node) {
     return node.kind === SyntaxKind.BindingElement;
 }
+isBindingElement.Handle = isBindingElement;
 export function isMissingDeclaration(node) {
     return node.kind === SyntaxKind.MissingDeclaration;
 }
+isMissingDeclaration.Handle = isMissingDeclaration;
 export function isFunctionDeclaration(node) {
     return node.kind === SyntaxKind.FunctionDeclaration;
 }
+isFunctionDeclaration.Handle = isFunctionDeclaration;
 export function isClassDeclaration(node) {
     return node.kind === SyntaxKind.ClassDeclaration;
 }
+isClassDeclaration.Handle = isClassDeclaration;
 export function isClassExpression(node) {
     return node.kind === SyntaxKind.ClassExpression;
 }
+isClassExpression.Handle = isClassExpression;
 export function isHeritageClause(node) {
     return node.kind === SyntaxKind.HeritageClause;
 }
+isHeritageClause.Handle = isHeritageClause;
 export function isInterfaceDeclaration(node) {
     return node.kind === SyntaxKind.InterfaceDeclaration;
 }
+isInterfaceDeclaration.Handle = isInterfaceDeclaration;
 export function isTypeAliasDeclaration(node) {
     switch (node.kind) {
         case SyntaxKind.TypeAliasDeclaration:
@@ -114,21 +149,27 @@ export function isTypeAliasDeclaration(node) {
             return false;
     }
 }
+isTypeAliasDeclaration.Handle = isTypeAliasDeclaration;
 export function isEnumMember(node) {
     return node.kind === SyntaxKind.EnumMember;
 }
+isEnumMember.Handle = isEnumMember;
 export function isEnumDeclaration(node) {
     return node.kind === SyntaxKind.EnumDeclaration;
 }
+isEnumDeclaration.Handle = isEnumDeclaration;
 export function isModuleBlock(node) {
     return node.kind === SyntaxKind.ModuleBlock;
 }
+isModuleBlock.Handle = isModuleBlock;
 export function isNotEmittedStatement(node) {
     return node.kind === SyntaxKind.NotEmittedStatement;
 }
+isNotEmittedStatement.Handle = isNotEmittedStatement;
 export function isNotEmittedTypeElement(node) {
     return node.kind === SyntaxKind.NotEmittedTypeElement;
 }
+isNotEmittedTypeElement.Handle = isNotEmittedTypeElement;
 export function isImportDeclaration(node) {
     switch (node.kind) {
         case SyntaxKind.ImportDeclaration:
@@ -138,660 +179,873 @@ export function isImportDeclaration(node) {
             return false;
     }
 }
+isImportDeclaration.Handle = isImportDeclaration;
 export function isExternalModuleReference(node) {
     return node.kind === SyntaxKind.ExternalModuleReference;
 }
+isExternalModuleReference.Handle = isExternalModuleReference;
 export function isNamespaceImport(node) {
     return node.kind === SyntaxKind.NamespaceImport;
 }
+isNamespaceImport.Handle = isNamespaceImport;
 export function isNamedImports(node) {
     return node.kind === SyntaxKind.NamedImports;
 }
+isNamedImports.Handle = isNamedImports;
 export function isExportAssignment(node) {
     return node.kind === SyntaxKind.ExportAssignment;
 }
+isExportAssignment.Handle = isExportAssignment;
 export function isNamespaceExportDeclaration(node) {
     return node.kind === SyntaxKind.NamespaceExportDeclaration;
 }
+isNamespaceExportDeclaration.Handle = isNamespaceExportDeclaration;
 export function isNamespaceExport(node) {
     return node.kind === SyntaxKind.NamespaceExport;
 }
+isNamespaceExport.Handle = isNamespaceExport;
 export function isNamedExports(node) {
     return node.kind === SyntaxKind.NamedExports;
 }
+isNamedExports.Handle = isNamedExports;
 export function isExportSpecifier(node) {
     return node.kind === SyntaxKind.ExportSpecifier;
 }
+isExportSpecifier.Handle = isExportSpecifier;
 export function isCallSignatureDeclaration(node) {
     return node.kind === SyntaxKind.CallSignature;
 }
+isCallSignatureDeclaration.Handle = isCallSignatureDeclaration;
 export function isConstructSignatureDeclaration(node) {
     return node.kind === SyntaxKind.ConstructSignature;
 }
+isConstructSignatureDeclaration.Handle = isConstructSignatureDeclaration;
 export function isConstructorDeclaration(node) {
     return node.kind === SyntaxKind.Constructor;
 }
+isConstructorDeclaration.Handle = isConstructorDeclaration;
 export function isGetAccessorDeclaration(node) {
     return node.kind === SyntaxKind.GetAccessor;
 }
+isGetAccessorDeclaration.Handle = isGetAccessorDeclaration;
 export function isSetAccessorDeclaration(node) {
     return node.kind === SyntaxKind.SetAccessor;
 }
+isSetAccessorDeclaration.Handle = isSetAccessorDeclaration;
 export function isIndexSignatureDeclaration(node) {
     return node.kind === SyntaxKind.IndexSignature;
 }
+isIndexSignatureDeclaration.Handle = isIndexSignatureDeclaration;
 export function isMethodSignatureDeclaration(node) {
     return node.kind === SyntaxKind.MethodSignature;
 }
+isMethodSignatureDeclaration.Handle = isMethodSignatureDeclaration;
 export function isMethodDeclaration(node) {
     return node.kind === SyntaxKind.MethodDeclaration;
 }
+isMethodDeclaration.Handle = isMethodDeclaration;
 export function isPropertySignatureDeclaration(node) {
     return node.kind === SyntaxKind.PropertySignature;
 }
+isPropertySignatureDeclaration.Handle = isPropertySignatureDeclaration;
 export function isPropertyDeclaration(node) {
     return node.kind === SyntaxKind.PropertyDeclaration;
 }
+isPropertyDeclaration.Handle = isPropertyDeclaration;
 export function isSemicolonClassElement(node) {
     return node.kind === SyntaxKind.SemicolonClassElement;
 }
+isSemicolonClassElement.Handle = isSemicolonClassElement;
 export function isClassStaticBlockDeclaration(node) {
     return node.kind === SyntaxKind.ClassStaticBlockDeclaration;
 }
+isClassStaticBlockDeclaration.Handle = isClassStaticBlockDeclaration;
 export function isOmittedExpression(node) {
     return node.kind === SyntaxKind.OmittedExpression;
 }
+isOmittedExpression.Handle = isOmittedExpression;
 export function isKeywordExpression(node) {
     return isKeywordExpressionKind(node.kind);
 }
+isKeywordExpression.Handle = isKeywordExpression;
 export function isStringLiteral(node) {
     return node.kind === SyntaxKind.StringLiteral;
 }
+isStringLiteral.Handle = isStringLiteral;
 export function isNumericLiteral(node) {
     return node.kind === SyntaxKind.NumericLiteral;
 }
+isNumericLiteral.Handle = isNumericLiteral;
 export function isBigIntLiteral(node) {
     return node.kind === SyntaxKind.BigIntLiteral;
 }
+isBigIntLiteral.Handle = isBigIntLiteral;
 export function isRegularExpressionLiteral(node) {
     return node.kind === SyntaxKind.RegularExpressionLiteral;
 }
+isRegularExpressionLiteral.Handle = isRegularExpressionLiteral;
 export function isNoSubstitutionTemplateLiteral(node) {
     return node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
 }
+isNoSubstitutionTemplateLiteral.Handle = isNoSubstitutionTemplateLiteral;
 export function isBinaryExpression(node) {
     return node.kind === SyntaxKind.BinaryExpression;
 }
+isBinaryExpression.Handle = isBinaryExpression;
 export function isPrefixUnaryExpression(node) {
     return node.kind === SyntaxKind.PrefixUnaryExpression;
 }
+isPrefixUnaryExpression.Handle = isPrefixUnaryExpression;
 export function isPostfixUnaryExpression(node) {
     return node.kind === SyntaxKind.PostfixUnaryExpression;
 }
+isPostfixUnaryExpression.Handle = isPostfixUnaryExpression;
 export function isYieldExpression(node) {
     return node.kind === SyntaxKind.YieldExpression;
 }
+isYieldExpression.Handle = isYieldExpression;
 export function isArrowFunction(node) {
     return node.kind === SyntaxKind.ArrowFunction;
 }
+isArrowFunction.Handle = isArrowFunction;
 export function isFunctionExpression(node) {
     return node.kind === SyntaxKind.FunctionExpression;
 }
+isFunctionExpression.Handle = isFunctionExpression;
 export function isAsExpression(node) {
     return node.kind === SyntaxKind.AsExpression;
 }
+isAsExpression.Handle = isAsExpression;
 export function isSatisfiesExpression(node) {
     return node.kind === SyntaxKind.SatisfiesExpression;
 }
+isSatisfiesExpression.Handle = isSatisfiesExpression;
 export function isConditionalExpression(node) {
     return node.kind === SyntaxKind.ConditionalExpression;
 }
+isConditionalExpression.Handle = isConditionalExpression;
 export function isPropertyAccessExpression(node) {
     return node.kind === SyntaxKind.PropertyAccessExpression;
 }
+isPropertyAccessExpression.Handle = isPropertyAccessExpression;
 export function isElementAccessExpression(node) {
     return node.kind === SyntaxKind.ElementAccessExpression;
 }
+isElementAccessExpression.Handle = isElementAccessExpression;
 export function isCallExpression(node) {
     return node.kind === SyntaxKind.CallExpression;
 }
+isCallExpression.Handle = isCallExpression;
 export function isNewExpression(node) {
     return node.kind === SyntaxKind.NewExpression;
 }
+isNewExpression.Handle = isNewExpression;
 export function isMetaProperty(node) {
     return node.kind === SyntaxKind.MetaProperty;
 }
+isMetaProperty.Handle = isMetaProperty;
 export function isNonNullExpression(node) {
     return node.kind === SyntaxKind.NonNullExpression;
 }
+isNonNullExpression.Handle = isNonNullExpression;
 export function isSpreadElement(node) {
     return node.kind === SyntaxKind.SpreadElement;
 }
+isSpreadElement.Handle = isSpreadElement;
 export function isTemplateExpression(node) {
     return node.kind === SyntaxKind.TemplateExpression;
 }
+isTemplateExpression.Handle = isTemplateExpression;
 export function isTemplateSpan(node) {
     return node.kind === SyntaxKind.TemplateSpan;
 }
+isTemplateSpan.Handle = isTemplateSpan;
 export function isTaggedTemplateExpression(node) {
     return node.kind === SyntaxKind.TaggedTemplateExpression;
 }
+isTaggedTemplateExpression.Handle = isTaggedTemplateExpression;
 export function isParenthesizedExpression(node) {
     return node.kind === SyntaxKind.ParenthesizedExpression;
 }
+isParenthesizedExpression.Handle = isParenthesizedExpression;
 export function isArrayLiteralExpression(node) {
     return node.kind === SyntaxKind.ArrayLiteralExpression;
 }
+isArrayLiteralExpression.Handle = isArrayLiteralExpression;
 export function isObjectLiteralExpression(node) {
     return node.kind === SyntaxKind.ObjectLiteralExpression;
 }
+isObjectLiteralExpression.Handle = isObjectLiteralExpression;
 export function isSpreadAssignment(node) {
     return node.kind === SyntaxKind.SpreadAssignment;
 }
+isSpreadAssignment.Handle = isSpreadAssignment;
 export function isPropertyAssignment(node) {
     return node.kind === SyntaxKind.PropertyAssignment;
 }
+isPropertyAssignment.Handle = isPropertyAssignment;
 export function isShorthandPropertyAssignment(node) {
     return node.kind === SyntaxKind.ShorthandPropertyAssignment;
 }
+isShorthandPropertyAssignment.Handle = isShorthandPropertyAssignment;
 export function isDeleteExpression(node) {
     return node.kind === SyntaxKind.DeleteExpression;
 }
+isDeleteExpression.Handle = isDeleteExpression;
 export function isTypeOfExpression(node) {
     return node.kind === SyntaxKind.TypeOfExpression;
 }
+isTypeOfExpression.Handle = isTypeOfExpression;
 export function isVoidExpression(node) {
     return node.kind === SyntaxKind.VoidExpression;
 }
+isVoidExpression.Handle = isVoidExpression;
 export function isAwaitExpression(node) {
     return node.kind === SyntaxKind.AwaitExpression;
 }
+isAwaitExpression.Handle = isAwaitExpression;
 export function isTypeAssertion(node) {
     return node.kind === SyntaxKind.TypeAssertionExpression;
 }
+isTypeAssertion.Handle = isTypeAssertion;
 export function isKeywordTypeNode(node) {
     return isKeywordTypeKind(node.kind);
 }
+isKeywordTypeNode.Handle = isKeywordTypeNode;
 export function isUnionTypeNode(node) {
     return node.kind === SyntaxKind.UnionType;
 }
+isUnionTypeNode.Handle = isUnionTypeNode;
 export function isIntersectionTypeNode(node) {
     return node.kind === SyntaxKind.IntersectionType;
 }
+isIntersectionTypeNode.Handle = isIntersectionTypeNode;
 export function isConditionalTypeNode(node) {
     return node.kind === SyntaxKind.ConditionalType;
 }
+isConditionalTypeNode.Handle = isConditionalTypeNode;
 export function isTypeOperatorNode(node) {
     return node.kind === SyntaxKind.TypeOperator;
 }
+isTypeOperatorNode.Handle = isTypeOperatorNode;
 export function isInferTypeNode(node) {
     return node.kind === SyntaxKind.InferType;
 }
+isInferTypeNode.Handle = isInferTypeNode;
 export function isArrayTypeNode(node) {
     return node.kind === SyntaxKind.ArrayType;
 }
+isArrayTypeNode.Handle = isArrayTypeNode;
 export function isIndexedAccessTypeNode(node) {
     return node.kind === SyntaxKind.IndexedAccessType;
 }
+isIndexedAccessTypeNode.Handle = isIndexedAccessTypeNode;
 export function isTypeReferenceNode(node) {
     return node.kind === SyntaxKind.TypeReference;
 }
+isTypeReferenceNode.Handle = isTypeReferenceNode;
 export function isExpressionWithTypeArguments(node) {
     return node.kind === SyntaxKind.ExpressionWithTypeArguments;
 }
+isExpressionWithTypeArguments.Handle = isExpressionWithTypeArguments;
 export function isLiteralTypeNode(node) {
     return node.kind === SyntaxKind.LiteralType;
 }
+isLiteralTypeNode.Handle = isLiteralTypeNode;
 export function isThisTypeNode(node) {
     return node.kind === SyntaxKind.ThisType;
 }
+isThisTypeNode.Handle = isThisTypeNode;
 export function isTypePredicateNode(node) {
     return node.kind === SyntaxKind.TypePredicate;
 }
+isTypePredicateNode.Handle = isTypePredicateNode;
 export function isImportAttribute(node) {
     return node.kind === SyntaxKind.ImportAttribute;
 }
+isImportAttribute.Handle = isImportAttribute;
 export function isImportAttributes(node) {
     return node.kind === SyntaxKind.ImportAttributes;
 }
+isImportAttributes.Handle = isImportAttributes;
 export function isTypeQueryNode(node) {
     return node.kind === SyntaxKind.TypeQuery;
 }
+isTypeQueryNode.Handle = isTypeQueryNode;
 export function isMappedTypeNode(node) {
     return node.kind === SyntaxKind.MappedType;
 }
+isMappedTypeNode.Handle = isMappedTypeNode;
 export function isTypeLiteralNode(node) {
     return node.kind === SyntaxKind.TypeLiteral;
 }
+isTypeLiteralNode.Handle = isTypeLiteralNode;
 export function isTupleTypeNode(node) {
     return node.kind === SyntaxKind.TupleType;
 }
+isTupleTypeNode.Handle = isTupleTypeNode;
 export function isNamedTupleMember(node) {
     return node.kind === SyntaxKind.NamedTupleMember;
 }
+isNamedTupleMember.Handle = isNamedTupleMember;
 export function isOptionalTypeNode(node) {
     return node.kind === SyntaxKind.OptionalType;
 }
+isOptionalTypeNode.Handle = isOptionalTypeNode;
 export function isRestTypeNode(node) {
     return node.kind === SyntaxKind.RestType;
 }
+isRestTypeNode.Handle = isRestTypeNode;
 export function isParenthesizedTypeNode(node) {
     return node.kind === SyntaxKind.ParenthesizedType;
 }
+isParenthesizedTypeNode.Handle = isParenthesizedTypeNode;
 export function isFunctionTypeNode(node) {
     return node.kind === SyntaxKind.FunctionType;
 }
+isFunctionTypeNode.Handle = isFunctionTypeNode;
 export function isConstructorTypeNode(node) {
     return node.kind === SyntaxKind.ConstructorType;
 }
+isConstructorTypeNode.Handle = isConstructorTypeNode;
 export function isTemplateHead(node) {
     return node.kind === SyntaxKind.TemplateHead;
 }
+isTemplateHead.Handle = isTemplateHead;
 export function isTemplateMiddle(node) {
     return node.kind === SyntaxKind.TemplateMiddle;
 }
+isTemplateMiddle.Handle = isTemplateMiddle;
 export function isTemplateTail(node) {
     return node.kind === SyntaxKind.TemplateTail;
 }
+isTemplateTail.Handle = isTemplateTail;
 export function isTemplateLiteralTypeNode(node) {
     return node.kind === SyntaxKind.TemplateLiteralType;
 }
+isTemplateLiteralTypeNode.Handle = isTemplateLiteralTypeNode;
 export function isTemplateLiteralTypeSpan(node) {
     return node.kind === SyntaxKind.TemplateLiteralTypeSpan;
 }
+isTemplateLiteralTypeSpan.Handle = isTemplateLiteralTypeSpan;
 export function isSyntheticExpression(node) {
     return node.kind === SyntaxKind.SyntheticExpression;
 }
+isSyntheticExpression.Handle = isSyntheticExpression;
 export function isPartiallyEmittedExpression(node) {
     return node.kind === SyntaxKind.PartiallyEmittedExpression;
 }
+isPartiallyEmittedExpression.Handle = isPartiallyEmittedExpression;
 export function isJsxElement(node) {
     return node.kind === SyntaxKind.JsxElement;
 }
+isJsxElement.Handle = isJsxElement;
 export function isJsxAttributes(node) {
     return node.kind === SyntaxKind.JsxAttributes;
 }
+isJsxAttributes.Handle = isJsxAttributes;
 export function isJsxNamespacedName(node) {
     return node.kind === SyntaxKind.JsxNamespacedName;
 }
+isJsxNamespacedName.Handle = isJsxNamespacedName;
 export function isJsxOpeningElement(node) {
     return node.kind === SyntaxKind.JsxOpeningElement;
 }
+isJsxOpeningElement.Handle = isJsxOpeningElement;
 export function isJsxSelfClosingElement(node) {
     return node.kind === SyntaxKind.JsxSelfClosingElement;
 }
+isJsxSelfClosingElement.Handle = isJsxSelfClosingElement;
 export function isJsxFragment(node) {
     return node.kind === SyntaxKind.JsxFragment;
 }
+isJsxFragment.Handle = isJsxFragment;
 export function isJsxOpeningFragment(node) {
     return node.kind === SyntaxKind.JsxOpeningFragment;
 }
+isJsxOpeningFragment.Handle = isJsxOpeningFragment;
 export function isJsxClosingFragment(node) {
     return node.kind === SyntaxKind.JsxClosingFragment;
 }
+isJsxClosingFragment.Handle = isJsxClosingFragment;
 export function isJsxAttribute(node) {
     return node.kind === SyntaxKind.JsxAttribute;
 }
+isJsxAttribute.Handle = isJsxAttribute;
 export function isJsxSpreadAttribute(node) {
     return node.kind === SyntaxKind.JsxSpreadAttribute;
 }
+isJsxSpreadAttribute.Handle = isJsxSpreadAttribute;
 export function isJsxClosingElement(node) {
     return node.kind === SyntaxKind.JsxClosingElement;
 }
+isJsxClosingElement.Handle = isJsxClosingElement;
 export function isJsxExpression(node) {
     return node.kind === SyntaxKind.JsxExpression;
 }
+isJsxExpression.Handle = isJsxExpression;
 export function isJsxText(node) {
     return node.kind === SyntaxKind.JsxText;
 }
+isJsxText.Handle = isJsxText;
 export function isSyntaxList(node) {
     return node.kind === SyntaxKind.SyntaxList;
 }
+isSyntaxList.Handle = isSyntaxList;
 export function isJSDoc(node) {
     return node.kind === SyntaxKind.JSDoc;
 }
+isJSDoc.Handle = isJSDoc;
 export function isJSDocTypeExpression(node) {
     return node.kind === SyntaxKind.JSDocTypeExpression;
 }
+isJSDocTypeExpression.Handle = isJSDocTypeExpression;
 export function isJSDocNonNullableType(node) {
     return node.kind === SyntaxKind.JSDocNonNullableType;
 }
+isJSDocNonNullableType.Handle = isJSDocNonNullableType;
 export function isJSDocNullableType(node) {
     return node.kind === SyntaxKind.JSDocNullableType;
 }
+isJSDocNullableType.Handle = isJSDocNullableType;
 export function isJSDocAllType(node) {
     return node.kind === SyntaxKind.JSDocAllType;
 }
+isJSDocAllType.Handle = isJSDocAllType;
 export function isJSDocVariadicType(node) {
     return node.kind === SyntaxKind.JSDocVariadicType;
 }
+isJSDocVariadicType.Handle = isJSDocVariadicType;
 export function isJSDocOptionalType(node) {
     return node.kind === SyntaxKind.JSDocOptionalType;
 }
+isJSDocOptionalType.Handle = isJSDocOptionalType;
 export function isJSDocTypeTag(node) {
     return node.kind === SyntaxKind.JSDocTypeTag;
 }
+isJSDocTypeTag.Handle = isJSDocTypeTag;
 export function isJSDocUnknownTag(node) {
     return node.kind === SyntaxKind.JSDocUnknownTag;
 }
+isJSDocUnknownTag.Handle = isJSDocUnknownTag;
 export function isJSDocTemplateTag(node) {
     return node.kind === SyntaxKind.JSDocTemplateTag;
 }
+isJSDocTemplateTag.Handle = isJSDocTemplateTag;
 export function isJSDocReturnTag(node) {
     return node.kind === SyntaxKind.JSDocReturnTag;
 }
+isJSDocReturnTag.Handle = isJSDocReturnTag;
 export function isJSDocPublicTag(node) {
     return node.kind === SyntaxKind.JSDocPublicTag;
 }
+isJSDocPublicTag.Handle = isJSDocPublicTag;
 export function isJSDocPrivateTag(node) {
     return node.kind === SyntaxKind.JSDocPrivateTag;
 }
+isJSDocPrivateTag.Handle = isJSDocPrivateTag;
 export function isJSDocProtectedTag(node) {
     return node.kind === SyntaxKind.JSDocProtectedTag;
 }
+isJSDocProtectedTag.Handle = isJSDocProtectedTag;
 export function isJSDocReadonlyTag(node) {
     return node.kind === SyntaxKind.JSDocReadonlyTag;
 }
+isJSDocReadonlyTag.Handle = isJSDocReadonlyTag;
 export function isJSDocOverrideTag(node) {
     return node.kind === SyntaxKind.JSDocOverrideTag;
 }
+isJSDocOverrideTag.Handle = isJSDocOverrideTag;
 export function isJSDocDeprecatedTag(node) {
     return node.kind === SyntaxKind.JSDocDeprecatedTag;
 }
+isJSDocDeprecatedTag.Handle = isJSDocDeprecatedTag;
 export function isJSDocSeeTag(node) {
     return node.kind === SyntaxKind.JSDocSeeTag;
 }
+isJSDocSeeTag.Handle = isJSDocSeeTag;
 export function isJSDocImplementsTag(node) {
     return node.kind === SyntaxKind.JSDocImplementsTag;
 }
+isJSDocImplementsTag.Handle = isJSDocImplementsTag;
 export function isJSDocAugmentsTag(node) {
     return node.kind === SyntaxKind.JSDocAugmentsTag;
 }
+isJSDocAugmentsTag.Handle = isJSDocAugmentsTag;
 export function isJSDocSatisfiesTag(node) {
     return node.kind === SyntaxKind.JSDocSatisfiesTag;
 }
+isJSDocSatisfiesTag.Handle = isJSDocSatisfiesTag;
 export function isJSDocThrowsTag(node) {
     return node.kind === SyntaxKind.JSDocThrowsTag;
 }
+isJSDocThrowsTag.Handle = isJSDocThrowsTag;
 export function isJSDocThisTag(node) {
     return node.kind === SyntaxKind.JSDocThisTag;
 }
+isJSDocThisTag.Handle = isJSDocThisTag;
 export function isJSDocImportTag(node) {
     return node.kind === SyntaxKind.JSDocImportTag;
 }
+isJSDocImportTag.Handle = isJSDocImportTag;
 export function isJSDocCallbackTag(node) {
     return node.kind === SyntaxKind.JSDocCallbackTag;
 }
+isJSDocCallbackTag.Handle = isJSDocCallbackTag;
 export function isJSDocOverloadTag(node) {
     return node.kind === SyntaxKind.JSDocOverloadTag;
 }
+isJSDocOverloadTag.Handle = isJSDocOverloadTag;
 export function isJSDocTypedefTag(node) {
     return node.kind === SyntaxKind.JSDocTypedefTag;
 }
+isJSDocTypedefTag.Handle = isJSDocTypedefTag;
 export function isJSDocSignature(node) {
     return node.kind === SyntaxKind.JSDocSignature;
 }
+isJSDocSignature.Handle = isJSDocSignature;
 export function isJSDocNameReference(node) {
     return node.kind === SyntaxKind.JSDocNameReference;
 }
+isJSDocNameReference.Handle = isJSDocNameReference;
 export function isSourceFile(node) {
     return node.kind === SyntaxKind.SourceFile;
 }
+isSourceFile.Handle = isSourceFile;
 export function isModuleDeclaration(node) {
     return node.kind === SyntaxKind.ModuleDeclaration;
 }
+isModuleDeclaration.Handle = isModuleDeclaration;
 export function isImportEqualsDeclaration(node) {
     return node.kind === SyntaxKind.ImportEqualsDeclaration;
 }
+isImportEqualsDeclaration.Handle = isImportEqualsDeclaration;
 export function isExportDeclaration(node) {
     return node.kind === SyntaxKind.ExportDeclaration;
 }
+isExportDeclaration.Handle = isExportDeclaration;
 export function isImportTypeNode(node) {
     return node.kind === SyntaxKind.ImportType;
 }
+isImportTypeNode.Handle = isImportTypeNode;
 export function isImportClause(node) {
     return node.kind === SyntaxKind.ImportClause;
 }
+isImportClause.Handle = isImportClause;
 export function isImportSpecifier(node) {
     return node.kind === SyntaxKind.ImportSpecifier;
 }
+isImportSpecifier.Handle = isImportSpecifier;
 export function isJSDocText(node) {
     return node.kind === SyntaxKind.JSDocText;
 }
+isJSDocText.Handle = isJSDocText;
 export function isJSDocLink(node) {
     return node.kind === SyntaxKind.JSDocLink;
 }
+isJSDocLink.Handle = isJSDocLink;
 export function isJSDocLinkPlain(node) {
     return node.kind === SyntaxKind.JSDocLinkPlain;
 }
+isJSDocLinkPlain.Handle = isJSDocLinkPlain;
 export function isJSDocLinkCode(node) {
     return node.kind === SyntaxKind.JSDocLinkCode;
 }
+isJSDocLinkCode.Handle = isJSDocLinkCode;
 export function isTypeParameterDeclaration(node) {
     return node.kind === SyntaxKind.TypeParameter;
 }
+isTypeParameterDeclaration.Handle = isTypeParameterDeclaration;
 export function isSyntheticReferenceExpression(node) {
     return node.kind === SyntaxKind.SyntheticReferenceExpression;
 }
+isSyntheticReferenceExpression.Handle = isSyntheticReferenceExpression;
 export function isJSDocTypeLiteral(node) {
     return node.kind === SyntaxKind.JSDocTypeLiteral;
 }
+isJSDocTypeLiteral.Handle = isJSDocTypeLiteral;
 export function isForInStatement(node) {
     return node.kind === SyntaxKind.ForInStatement;
 }
+isForInStatement.Handle = isForInStatement;
 export function isForOfStatement(node) {
     return node.kind === SyntaxKind.ForOfStatement;
 }
+isForOfStatement.Handle = isForOfStatement;
 export function isCaseClause(node) {
     return node.kind === SyntaxKind.CaseClause;
 }
+isCaseClause.Handle = isCaseClause;
 export function isDefaultClause(node) {
     return node.kind === SyntaxKind.DefaultClause;
 }
+isDefaultClause.Handle = isDefaultClause;
 export function isObjectBindingPattern(node) {
     return node.kind === SyntaxKind.ObjectBindingPattern;
 }
+isObjectBindingPattern.Handle = isObjectBindingPattern;
 export function isArrayBindingPattern(node) {
     return node.kind === SyntaxKind.ArrayBindingPattern;
 }
+isArrayBindingPattern.Handle = isArrayBindingPattern;
 export function isJSDocParameterTag(node) {
     return node.kind === SyntaxKind.JSDocParameterTag;
 }
+isJSDocParameterTag.Handle = isJSDocParameterTag;
 export function isJSDocPropertyTag(node) {
     return node.kind === SyntaxKind.JSDocPropertyTag;
 }
+isJSDocPropertyTag.Handle = isJSDocPropertyTag;
 export function isHeritageClauseElement(node) {
     return node.kind === SyntaxKind.ExpressionWithTypeArguments || node.kind === SyntaxKind.TypeReference;
 }
+isHeritageClauseElement.Handle = isHeritageClauseElement;
 export function isAccessExpression(node) {
     return node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression;
 }
+isAccessExpression.Handle = isAccessExpression;
 export function isDeclarationName(node) {
     const kind = node.kind;
     return kind === SyntaxKind.Identifier || kind === SyntaxKind.PrivateIdentifier || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.ComputedPropertyName || kind === SyntaxKind.ObjectBindingPattern || kind === SyntaxKind.ArrayBindingPattern || kind === SyntaxKind.ElementAccessExpression;
 }
+isDeclarationName.Handle = isDeclarationName;
 export function isModuleName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral;
 }
+isModuleName.Handle = isModuleName;
 export function isModuleExportName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral;
 }
+isModuleExportName.Handle = isModuleExportName;
 export function isPropertyName(node) {
     const kind = node.kind;
     return kind === SyntaxKind.Identifier || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.ComputedPropertyName || kind === SyntaxKind.PrivateIdentifier || kind === SyntaxKind.BigIntLiteral;
 }
+isPropertyName.Handle = isPropertyName;
 export function isModuleBody(node) {
     return node.kind === SyntaxKind.ModuleBlock || node.kind === SyntaxKind.ModuleDeclaration;
 }
+isModuleBody.Handle = isModuleBody;
 export function isJSDocFullName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ModuleDeclaration;
 }
+isJSDocFullName.Handle = isJSDocFullName;
 export function isModuleReference(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.ExternalModuleReference;
 }
+isModuleReference.Handle = isModuleReference;
 export function isNamedImportBindings(node) {
     return node.kind === SyntaxKind.NamespaceImport || node.kind === SyntaxKind.NamedImports;
 }
+isNamedImportBindings.Handle = isNamedImportBindings;
 export function isNamedExportBindings(node) {
     return node.kind === SyntaxKind.NamespaceExport || node.kind === SyntaxKind.NamedExports;
 }
+isNamedExportBindings.Handle = isNamedExportBindings;
 export function isMemberName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier;
 }
+isMemberName.Handle = isMemberName;
 export function isEntityName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName;
 }
+isEntityName.Handle = isEntityName;
 export function isBindingName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern;
 }
+isBindingName.Handle = isBindingName;
 export function isModifierLike(node) {
     const kind = node.kind;
     return kind === SyntaxKind.AbstractKeyword || kind === SyntaxKind.AccessorKeyword || kind === SyntaxKind.AsyncKeyword || kind === SyntaxKind.ConstKeyword || kind === SyntaxKind.DeclareKeyword || kind === SyntaxKind.DefaultKeyword || kind === SyntaxKind.ExportKeyword || kind === SyntaxKind.InKeyword || kind === SyntaxKind.PrivateKeyword || kind === SyntaxKind.ProtectedKeyword || kind === SyntaxKind.PublicKeyword || kind === SyntaxKind.ReadonlyKeyword || kind === SyntaxKind.OutKeyword || kind === SyntaxKind.OverrideKeyword || kind === SyntaxKind.StaticKeyword || kind === SyntaxKind.Decorator;
 }
+isModifierLike.Handle = isModifierLike;
 export function isJsxChild(node) {
     const kind = node.kind;
     return kind === SyntaxKind.JsxText || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment;
 }
+isJsxChild.Handle = isJsxChild;
 export function isJsxAttributeLike(node) {
     return node.kind === SyntaxKind.JsxAttribute || node.kind === SyntaxKind.JsxSpreadAttribute;
 }
+isJsxAttributeLike.Handle = isJsxAttributeLike;
 export function isJsxAttributeName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.JsxNamespacedName;
 }
+isJsxAttributeName.Handle = isJsxAttributeName;
 export function isJsxAttributeValue(node) {
     const kind = node.kind;
     return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment;
 }
+isJsxAttributeValue.Handle = isJsxAttributeValue;
 export function isClassLikeDeclaration(node) {
     return node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression;
 }
+isClassLikeDeclaration.Handle = isClassLikeDeclaration;
 export function isAccessorDeclaration(node) {
     return node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor;
 }
+isAccessorDeclaration.Handle = isAccessorDeclaration;
 export function isLiteralLikeNode(node) {
     const kind = node.kind;
     return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail || kind === SyntaxKind.JsxText;
 }
+isLiteralLikeNode.Handle = isLiteralLikeNode;
 export function isLiteralExpression(node) {
     const kind = node.kind;
     return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
 }
+isLiteralExpression.Handle = isLiteralExpression;
 export function isUnionOrIntersectionTypeNode(node) {
     return node.kind === SyntaxKind.UnionType || node.kind === SyntaxKind.IntersectionType;
 }
+isUnionOrIntersectionTypeNode.Handle = isUnionOrIntersectionTypeNode;
 export function isTemplateLiteralLikeNode(node) {
     const kind = node.kind;
     return isPseudoLiteralKind(kind);
 }
+isTemplateLiteralLikeNode.Handle = isTemplateLiteralLikeNode;
 export function isTemplateMiddleOrTail(node) {
     return node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail;
 }
+isTemplateMiddleOrTail.Handle = isTemplateMiddleOrTail;
 export function isTemplateLiteral(node) {
     return node.kind === SyntaxKind.TemplateExpression || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
 }
+isTemplateLiteral.Handle = isTemplateLiteral;
 export function isTypePredicateParameterName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisType;
 }
+isTypePredicateParameterName.Handle = isTypePredicateParameterName;
 export function isImportAttributeName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral;
 }
+isImportAttributeName.Handle = isImportAttributeName;
 export function isJSDocComment(node) {
     const kind = node.kind;
     return kind === SyntaxKind.JSDocText || kind === SyntaxKind.JSDocLink || kind === SyntaxKind.JSDocLinkCode || kind === SyntaxKind.JSDocLinkPlain;
 }
+isJSDocComment.Handle = isJSDocComment;
 export function isSignatureDeclaration(node) {
     const kind = node.kind;
     return kind === SyntaxKind.CallSignature || kind === SyntaxKind.ConstructSignature || kind === SyntaxKind.MethodSignature || kind === SyntaxKind.IndexSignature || kind === SyntaxKind.FunctionType || kind === SyntaxKind.ConstructorType || kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.Constructor || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction;
 }
+isSignatureDeclaration.Handle = isSignatureDeclaration;
 export function isStringLiteralLikeNode(node) {
     return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
 }
+isStringLiteralLikeNode.Handle = isStringLiteralLikeNode;
 export function isNumericOrStringLikeLiteral(node) {
     return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.NumericLiteral;
 }
+isNumericOrStringLikeLiteral.Handle = isNumericOrStringLikeLiteral;
 export function isObjectLiteralLikeNode(node) {
     return node.kind === SyntaxKind.ObjectLiteralExpression || node.kind === SyntaxKind.ObjectBindingPattern;
 }
+isObjectLiteralLikeNode.Handle = isObjectLiteralLikeNode;
 export function isObjectTypeDeclaration(node) {
     const kind = node.kind;
     return kind === SyntaxKind.ClassDeclaration || kind === SyntaxKind.ClassExpression || kind === SyntaxKind.InterfaceDeclaration || kind === SyntaxKind.TypeLiteral;
 }
+isObjectTypeDeclaration.Handle = isObjectTypeDeclaration;
 export function isJsxOpeningLikeElement(node) {
     return node.kind === SyntaxKind.JsxOpeningElement || node.kind === SyntaxKind.JsxSelfClosingElement;
 }
+isJsxOpeningLikeElement.Handle = isJsxOpeningLikeElement;
 export function isNamedImportsOrExports(node) {
     return node.kind === SyntaxKind.NamedImports || node.kind === SyntaxKind.NamedExports;
 }
+isNamedImportsOrExports.Handle = isNamedImportsOrExports;
 export function isBreakOrContinueStatement(node) {
     return node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement;
 }
+isBreakOrContinueStatement.Handle = isBreakOrContinueStatement;
 export function isCallLikeExpression(node) {
     const kind = node.kind;
     return kind === SyntaxKind.CallExpression || kind === SyntaxKind.NewExpression || kind === SyntaxKind.TaggedTemplateExpression || kind === SyntaxKind.Decorator || kind === SyntaxKind.JsxOpeningElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.BinaryExpression;
 }
+isCallLikeExpression.Handle = isCallLikeExpression;
 export function isFunctionLikeDeclaration(node) {
     const kind = node.kind;
     return kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor || kind === SyntaxKind.Constructor || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction;
 }
+isFunctionLikeDeclaration.Handle = isFunctionLikeDeclaration;
 export function isVariableOrParameterDeclaration(node) {
     return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.Parameter;
 }
+isVariableOrParameterDeclaration.Handle = isVariableOrParameterDeclaration;
 export function isVariableOrPropertyDeclaration(node) {
     return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.PropertyDeclaration;
 }
+isVariableOrPropertyDeclaration.Handle = isVariableOrPropertyDeclaration;
 export function isCallOrNewExpression(node) {
     return node.kind === SyntaxKind.CallExpression || node.kind === SyntaxKind.NewExpression;
 }
+isCallOrNewExpression.Handle = isCallOrNewExpression;
 export function isImportClauseOrBindingPattern(node) {
     return node.kind === SyntaxKind.ImportClause || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern;
 }
+isImportClauseOrBindingPattern.Handle = isImportClauseOrBindingPattern;
 export function isAnyImportSyntax(node) {
     return node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.JSImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration;
 }
+isAnyImportSyntax.Handle = isAnyImportSyntax;
 export function isArrayBindingElement(node) {
     return node.kind === SyntaxKind.BindingElement || node.kind === SyntaxKind.OmittedExpression;
 }
+isArrayBindingElement.Handle = isArrayBindingElement;
 export function isAssertionExpression(node) {
     return node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression;
 }
+isAssertionExpression.Handle = isAssertionExpression;
 export function isBooleanLiteral(node) {
     return node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword;
 }
+isBooleanLiteral.Handle = isBooleanLiteral;
 export function isDestructuringAssignment(node) {
     return node.kind === SyntaxKind.BinaryExpression;
 }
+isDestructuringAssignment.Handle = isDestructuringAssignment;
 export function isLiteralToken(node) {
     const kind = node.kind;
     return kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxText || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
 }
+isLiteralToken.Handle = isLiteralToken;
 export function isModifier(node) {
     const kind = node.kind;
     return isModifierKind(kind);
 }
+isModifier.Handle = isModifier;
 export function isObjectLiteralElementLike(node) {
     const kind = node.kind;
     return kind === SyntaxKind.PropertyAssignment || kind === SyntaxKind.ShorthandPropertyAssignment || kind === SyntaxKind.SpreadAssignment || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor;
 }
+isObjectLiteralElementLike.Handle = isObjectLiteralElementLike;
 export function isPropertyNameLiteral(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NumericLiteral;
 }
+isPropertyNameLiteral.Handle = isPropertyNameLiteral;
 export function isPseudoLiteralToken(node) {
     const kind = node.kind;
     return isPseudoLiteralKind(kind);
 }
+isPseudoLiteralToken.Handle = isPseudoLiteralToken;
 export function isTemplateLiteralToken(node) {
     const kind = node.kind;
     return kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail;
 }
+isTemplateLiteralToken.Handle = isTemplateLiteralToken;
 export function isArrayDestructuringAssignment(node) {
     return node.kind === SyntaxKind.BinaryExpression;
 }
+isArrayDestructuringAssignment.Handle = isArrayDestructuringAssignment;
 export function isObjectDestructuringAssignment(node) {
     return node.kind === SyntaxKind.BinaryExpression;
 }
+isObjectDestructuringAssignment.Handle = isObjectDestructuringAssignment;
 export function isFunctionBody(node) {
     return node.kind === SyntaxKind.Block;
 }
+isFunctionBody.Handle = isFunctionBody;
 export function isTriviaKind(kind) {
     return kind === SyntaxKind.SingleLineCommentTrivia
         || kind === SyntaxKind.MultiLineCommentTrivia
@@ -989,118 +1243,157 @@ export function isJSDocNodeKind(kind) {
 export function isEndOfFile(node) {
     return node.kind === SyntaxKind.EndOfFile;
 }
+isEndOfFile.Handle = isEndOfFile;
 export function isDotToken(node) {
     return node.kind === SyntaxKind.DotToken;
 }
+isDotToken.Handle = isDotToken;
 export function isDotDotDotToken(node) {
     return node.kind === SyntaxKind.DotDotDotToken;
 }
+isDotDotDotToken.Handle = isDotDotDotToken;
 export function isQuestionToken(node) {
     return node.kind === SyntaxKind.QuestionToken;
 }
+isQuestionToken.Handle = isQuestionToken;
 export function isExclamationToken(node) {
     return node.kind === SyntaxKind.ExclamationToken;
 }
+isExclamationToken.Handle = isExclamationToken;
 export function isColonToken(node) {
     return node.kind === SyntaxKind.ColonToken;
 }
+isColonToken.Handle = isColonToken;
 export function isEqualsToken(node) {
     return node.kind === SyntaxKind.EqualsToken;
 }
+isEqualsToken.Handle = isEqualsToken;
 export function isAsteriskToken(node) {
     return node.kind === SyntaxKind.AsteriskToken;
 }
+isAsteriskToken.Handle = isAsteriskToken;
 export function isEqualsGreaterThanToken(node) {
     return node.kind === SyntaxKind.EqualsGreaterThanToken;
 }
+isEqualsGreaterThanToken.Handle = isEqualsGreaterThanToken;
 export function isPlusToken(node) {
     return node.kind === SyntaxKind.PlusToken;
 }
+isPlusToken.Handle = isPlusToken;
 export function isMinusToken(node) {
     return node.kind === SyntaxKind.MinusToken;
 }
+isMinusToken.Handle = isMinusToken;
 export function isQuestionDotToken(node) {
     return node.kind === SyntaxKind.QuestionDotToken;
 }
+isQuestionDotToken.Handle = isQuestionDotToken;
 export function isAssertsKeyword(node) {
     return node.kind === SyntaxKind.AssertsKeyword;
 }
+isAssertsKeyword.Handle = isAssertsKeyword;
 export function isAssertKeyword(node) {
     return node.kind === SyntaxKind.AssertKeyword;
 }
+isAssertKeyword.Handle = isAssertKeyword;
 export function isAwaitKeyword(node) {
     return node.kind === SyntaxKind.AwaitKeyword;
 }
+isAwaitKeyword.Handle = isAwaitKeyword;
 export function isCaseKeyword(node) {
     return node.kind === SyntaxKind.CaseKeyword;
 }
+isCaseKeyword.Handle = isCaseKeyword;
 export function isAbstractKeyword(node) {
     return node.kind === SyntaxKind.AbstractKeyword;
 }
+isAbstractKeyword.Handle = isAbstractKeyword;
 export function isAccessorKeyword(node) {
     return node.kind === SyntaxKind.AccessorKeyword;
 }
+isAccessorKeyword.Handle = isAccessorKeyword;
 export function isAsyncKeyword(node) {
     return node.kind === SyntaxKind.AsyncKeyword;
 }
+isAsyncKeyword.Handle = isAsyncKeyword;
 export function isConstKeyword(node) {
     return node.kind === SyntaxKind.ConstKeyword;
 }
+isConstKeyword.Handle = isConstKeyword;
 export function isDeclareKeyword(node) {
     return node.kind === SyntaxKind.DeclareKeyword;
 }
+isDeclareKeyword.Handle = isDeclareKeyword;
 export function isDefaultKeyword(node) {
     return node.kind === SyntaxKind.DefaultKeyword;
 }
+isDefaultKeyword.Handle = isDefaultKeyword;
 export function isExportKeyword(node) {
     return node.kind === SyntaxKind.ExportKeyword;
 }
+isExportKeyword.Handle = isExportKeyword;
 export function isInKeyword(node) {
     return node.kind === SyntaxKind.InKeyword;
 }
+isInKeyword.Handle = isInKeyword;
 export function isPrivateKeyword(node) {
     return node.kind === SyntaxKind.PrivateKeyword;
 }
+isPrivateKeyword.Handle = isPrivateKeyword;
 export function isProtectedKeyword(node) {
     return node.kind === SyntaxKind.ProtectedKeyword;
 }
+isProtectedKeyword.Handle = isProtectedKeyword;
 export function isPublicKeyword(node) {
     return node.kind === SyntaxKind.PublicKeyword;
 }
+isPublicKeyword.Handle = isPublicKeyword;
 export function isReadonlyKeyword(node) {
     return node.kind === SyntaxKind.ReadonlyKeyword;
 }
+isReadonlyKeyword.Handle = isReadonlyKeyword;
 export function isOutKeyword(node) {
     return node.kind === SyntaxKind.OutKeyword;
 }
+isOutKeyword.Handle = isOutKeyword;
 export function isOverrideKeyword(node) {
     return node.kind === SyntaxKind.OverrideKeyword;
 }
+isOverrideKeyword.Handle = isOverrideKeyword;
 export function isStaticKeyword(node) {
     return node.kind === SyntaxKind.StaticKeyword;
 }
+isStaticKeyword.Handle = isStaticKeyword;
 export function isBinaryOperatorToken(node) {
     return isBinaryOperator(node.kind);
 }
+isBinaryOperatorToken.Handle = isBinaryOperatorToken;
 export function isAssignmentOperatorToken(node) {
     return isAssignmentOperator(node.kind);
 }
+isAssignmentOperatorToken.Handle = isAssignmentOperatorToken;
 export function isNullLiteral(node) {
     return node.kind === SyntaxKind.NullKeyword;
 }
+isNullLiteral.Handle = isNullLiteral;
 export function isTrueLiteral(node) {
     return node.kind === SyntaxKind.TrueKeyword;
 }
+isTrueLiteral.Handle = isTrueLiteral;
 export function isFalseLiteral(node) {
     return node.kind === SyntaxKind.FalseKeyword;
 }
+isFalseLiteral.Handle = isFalseLiteral;
 export function isThisExpression(node) {
     return node.kind === SyntaxKind.ThisKeyword;
 }
+isThisExpression.Handle = isThisExpression;
 export function isSuperExpression(node) {
     return node.kind === SyntaxKind.SuperKeyword;
 }
+isSuperExpression.Handle = isSuperExpression;
 export function isImportExpression(node) {
     return node.kind === SyntaxKind.ImportKeyword;
 }
+isImportExpression.Handle = isImportExpression;
 //# sourceMappingURL=is.generated.js.map