@signpostmarv/ts-assert 0.1.0--beta → 0.1.1--develop

package/generated/assertions.js

@@ -1,1037 +0,0 @@
-import ts from "typescript";
-import assert from "node:assert/strict";
-export function isAccessor(node, message = "node is not a AccessorDeclaration") {
-    assert.equal(ts.isAccessor(node), true, message);
-}
-export function isArrayBindingElement(node, message = "node is not a ArrayBindingElement") {
-    assert.equal(ts.isArrayBindingElement(node), true, message);
-}
-export function isArrayBindingPattern(node, message = "node is not a ArrayBindingPattern") {
-    assert.equal(ts.isArrayBindingPattern(node), true, message);
-}
-export function isArrayLiteralExpression(node, message = "node is not a ArrayLiteralExpression") {
-    assert.equal(ts.isArrayLiteralExpression(node), true, message);
-}
-export function isArrayTypeNode(node, message = "node is not a ArrayTypeNode") {
-    assert.equal(ts.isArrayTypeNode(node), true, message);
-}
-export function isArrowFunction(node, message = "node is not a ArrowFunction") {
-    assert.equal(ts.isArrowFunction(node), true, message);
-}
-export function isAsExpression(node, message = "node is not a AsExpression") {
-    assert.equal(ts.isAsExpression(node), true, message);
-}
-export function isAssertionExpression(node, message = "node is not a AssertionExpression") {
-    assert.equal(ts.isAssertionExpression(node), true, message);
-}
-export function isAssertsKeyword(node, message = "node is not a AssertsKeyword") {
-    assert.equal(ts.isAssertsKeyword(node), true, message);
-}
-export function isAsteriskToken(node, message = "node is not a AsteriskToken") {
-    assert.equal(ts.isAsteriskToken(node), true, message);
-}
-export function isAutoAccessorPropertyDeclaration(node, message = "node is not a AutoAccessorPropertyDeclaration") {
-    assert.equal(ts.isAutoAccessorPropertyDeclaration(node), true, message);
-}
-export function isAwaitExpression(node, message = "node is not a AwaitExpression") {
-    assert.equal(ts.isAwaitExpression(node), true, message);
-}
-export function isAwaitKeyword(node, message = "node is not a AwaitKeyword") {
-    assert.equal(ts.isAwaitKeyword(node), true, message);
-}
-export function isBigIntLiteral(node, message = "node is not a BigIntLiteral") {
-    assert.equal(ts.isBigIntLiteral(node), true, message);
-}
-export function isBinaryExpression(node, message = "node is not a BinaryExpression") {
-    assert.equal(ts.isBinaryExpression(node), true, message);
-}
-export function isBinaryOperatorToken(node, message = "node is not a BinaryOperatorToken") {
-    assert.equal(ts.isBinaryOperatorToken(node), true, message);
-}
-export function isBindingElement(node, message = "node is not a BindingElement") {
-    assert.equal(ts.isBindingElement(node), true, message);
-}
-export function isBindingName(node, message = "node is not a BindingName") {
-    assert.equal(ts.isBindingName(node), true, message);
-}
-export function isBlock(node, message = "node is not a Block") {
-    assert.equal(ts.isBlock(node), true, message);
-}
-export function isBreakOrContinueStatement(node, message = "node is not a BreakOrContinueStatement") {
-    assert.equal(ts.isBreakOrContinueStatement(node), true, message);
-}
-export function isBreakStatement(node, message = "node is not a BreakStatement") {
-    assert.equal(ts.isBreakStatement(node), true, message);
-}
-export function isBundle(node, message = "node is not a Bundle") {
-    assert.equal(ts.isBundle(node), true, message);
-}
-export function isCallChain(node, message = "node is not a CallChain") {
-    assert.equal(ts.isCallChain(node), true, message);
-}
-export function isCallExpression(node, message = "node is not a CallExpression") {
-    assert.equal(ts.isCallExpression(node), true, message);
-}
-export function isCallLikeExpression(node, message = "node is not a CallLikeExpression") {
-    assert.equal(ts.isCallLikeExpression(node), true, message);
-}
-export function isCallSignatureDeclaration(node, message = "node is not a CallSignatureDeclaration") {
-    assert.equal(ts.isCallSignatureDeclaration(node), true, message);
-}
-export function isCaseBlock(node, message = "node is not a CaseBlock") {
-    assert.equal(ts.isCaseBlock(node), true, message);
-}
-export function isCaseClause(node, message = "node is not a CaseClause") {
-    assert.equal(ts.isCaseClause(node), true, message);
-}
-export function isCaseOrDefaultClause(node, message = "node is not a CaseOrDefaultClause") {
-    assert.equal(ts.isCaseOrDefaultClause(node), true, message);
-}
-export function isCatchClause(node, message = "node is not a CatchClause") {
-    assert.equal(ts.isCatchClause(node), true, message);
-}
-export function isClassDeclaration(node, message = "node is not a ClassDeclaration") {
-    assert.equal(ts.isClassDeclaration(node), true, message);
-}
-export function isClassElement(node, message = "node is not a ClassElement") {
-    assert.equal(ts.isClassElement(node), true, message);
-}
-export function isClassExpression(node, message = "node is not a ClassExpression") {
-    assert.equal(ts.isClassExpression(node), true, message);
-}
-export function isClassLike(node, message = "node is not a ClassLikeDeclaration") {
-    assert.equal(ts.isClassLike(node), true, message);
-}
-export function isClassStaticBlockDeclaration(node, message = "node is not a ClassStaticBlockDeclaration") {
-    assert.equal(ts.isClassStaticBlockDeclaration(node), true, message);
-}
-export function isColonToken(node, message = "node is not a ColonToken") {
-    assert.equal(ts.isColonToken(node), true, message);
-}
-export function isCommaListExpression(node, message = "node is not a CommaListExpression") {
-    assert.equal(ts.isCommaListExpression(node), true, message);
-}
-export function isComputedPropertyName(node, message = "node is not a ComputedPropertyName") {
-    assert.equal(ts.isComputedPropertyName(node), true, message);
-}
-export function isConciseBody(node, message = "node is not a ConciseBody") {
-    assert.equal(ts.isConciseBody(node), true, message);
-}
-export function isConditionalExpression(node, message = "node is not a ConditionalExpression") {
-    assert.equal(ts.isConditionalExpression(node), true, message);
-}
-export function isConditionalTypeNode(node, message = "node is not a ConditionalTypeNode") {
-    assert.equal(ts.isConditionalTypeNode(node), true, message);
-}
-export function isConstructorDeclaration(node, message = "node is not a ConstructorDeclaration") {
-    assert.equal(ts.isConstructorDeclaration(node), true, message);
-}
-export function isConstructorTypeNode(node, message = "node is not a ConstructorTypeNode") {
-    assert.equal(ts.isConstructorTypeNode(node), true, message);
-}
-export function isConstructSignatureDeclaration(node, message = "node is not a ConstructSignatureDeclaration") {
-    assert.equal(ts.isConstructSignatureDeclaration(node), true, message);
-}
-export function isContinueStatement(node, message = "node is not a ContinueStatement") {
-    assert.equal(ts.isContinueStatement(node), true, message);
-}
-export function isDebuggerStatement(node, message = "node is not a DebuggerStatement") {
-    assert.equal(ts.isDebuggerStatement(node), true, message);
-}
-export function isDeclarationStatement(node, message = "node is not a DeclarationStatement") {
-    assert.equal(ts.isDeclarationStatement(node), true, message);
-}
-export function isDecorator(node, message = "node is not a Decorator") {
-    assert.equal(ts.isDecorator(node), true, message);
-}
-export function isDefaultClause(node, message = "node is not a DefaultClause") {
-    assert.equal(ts.isDefaultClause(node), true, message);
-}
-export function isDeleteExpression(node, message = "node is not a DeleteExpression") {
-    assert.equal(ts.isDeleteExpression(node), true, message);
-}
-export function isDoStatement(node, message = "node is not a DoStatement") {
-    assert.equal(ts.isDoStatement(node), true, message);
-}
-export function isDotDotDotToken(node, message = "node is not a DotDotDotToken") {
-    assert.equal(ts.isDotDotDotToken(node), true, message);
-}
-export function isElementAccessChain(node, message = "node is not a ElementAccessChain") {
-    assert.equal(ts.isElementAccessChain(node), true, message);
-}
-export function isElementAccessExpression(node, message = "node is not a ElementAccessExpression") {
-    assert.equal(ts.isElementAccessExpression(node), true, message);
-}
-export function isEmptyBindingPattern(node, message = "node is not a BindingPattern") {
-    assert.equal(ts.isEmptyBindingPattern(node), true, message);
-}
-export function isEmptyStatement(node, message = "node is not a EmptyStatement") {
-    assert.equal(ts.isEmptyStatement(node), true, message);
-}
-export function isEntityName(node, message = "node is not a EntityName") {
-    assert.equal(ts.isEntityName(node), true, message);
-}
-export function isEnumDeclaration(node, message = "node is not a EnumDeclaration") {
-    assert.equal(ts.isEnumDeclaration(node), true, message);
-}
-export function isEnumMember(node, message = "node is not a EnumMember") {
-    assert.equal(ts.isEnumMember(node), true, message);
-}
-export function isEqualsGreaterThanToken(node, message = "node is not a EqualsGreaterThanToken") {
-    assert.equal(ts.isEqualsGreaterThanToken(node), true, message);
-}
-export function isExclamationToken(node, message = "node is not a ExclamationToken") {
-    assert.equal(ts.isExclamationToken(node), true, message);
-}
-export function isExportAssignment(node, message = "node is not a ExportAssignment") {
-    assert.equal(ts.isExportAssignment(node), true, message);
-}
-export function isExportDeclaration(node, message = "node is not a ExportDeclaration") {
-    assert.equal(ts.isExportDeclaration(node), true, message);
-}
-export function isExportSpecifier(node, message = "node is not a ExportSpecifier") {
-    assert.equal(ts.isExportSpecifier(node), true, message);
-}
-export function isExpression(node, message = "node is not a Expression") {
-    assert.equal(ts.isExpression(node), true, message);
-}
-export function isExpressionStatement(node, message = "node is not a ExpressionStatement") {
-    assert.equal(ts.isExpressionStatement(node), true, message);
-}
-export function isExpressionWithTypeArguments(node, message = "node is not a ExpressionWithTypeArguments") {
-    assert.equal(ts.isExpressionWithTypeArguments(node), true, message);
-}
-export function isExternalModuleReference(node, message = "node is not a ExternalModuleReference") {
-    assert.equal(ts.isExternalModuleReference(node), true, message);
-}
-export function isForInitializer(node, message = "node is not a ForInitializer") {
-    assert.equal(ts.isForInitializer(node), true, message);
-}
-export function isForInStatement(node, message = "node is not a ForInStatement") {
-    assert.equal(ts.isForInStatement(node), true, message);
-}
-export function isForOfStatement(node, message = "node is not a ForOfStatement") {
-    assert.equal(ts.isForOfStatement(node), true, message);
-}
-export function isForStatement(node, message = "node is not a ForStatement") {
-    assert.equal(ts.isForStatement(node), true, message);
-}
-export function isFunctionDeclaration(node, message = "node is not a FunctionDeclaration") {
-    assert.equal(ts.isFunctionDeclaration(node), true, message);
-}
-export function isFunctionExpression(node, message = "node is not a FunctionExpression") {
-    assert.equal(ts.isFunctionExpression(node), true, message);
-}
-export function isFunctionTypeNode(node, message = "node is not a FunctionTypeNode") {
-    assert.equal(ts.isFunctionTypeNode(node), true, message);
-}
-export function isGetAccessor(node, message = "node is not a GetAccessorDeclaration") {
-    assert.equal(ts.isGetAccessor(node), true, message);
-}
-export function isGetAccessorDeclaration(node, message = "node is not a GetAccessorDeclaration") {
-    assert.equal(ts.isGetAccessorDeclaration(node), true, message);
-}
-export function isHeritageClause(node, message = "node is not a HeritageClause") {
-    assert.equal(ts.isHeritageClause(node), true, message);
-}
-export function isIdentifier(node, message = "node is not a Identifier") {
-    assert.equal(ts.isIdentifier(node), true, message);
-}
-export function isIfStatement(node, message = "node is not a IfStatement") {
-    assert.equal(ts.isIfStatement(node), true, message);
-}
-export function isImportAttribute(node, message = "node is not a ImportAttribute") {
-    assert.equal(ts.isImportAttribute(node), true, message);
-}
-export function isImportAttributeName(node, message = "node is not a ImportAttributeName") {
-    assert.equal(ts.isImportAttributeName(node), true, message);
-}
-export function isImportAttributes(node, message = "node is not a ImportAttributes") {
-    assert.equal(ts.isImportAttributes(node), true, message);
-}
-export function isImportClause(node, message = "node is not a ImportClause") {
-    assert.equal(ts.isImportClause(node), true, message);
-}
-export function isImportDeclaration(node, message = "node is not a ImportDeclaration") {
-    assert.equal(ts.isImportDeclaration(node), true, message);
-}
-export function isImportEqualsDeclaration(node, message = "node is not a ImportEqualsDeclaration") {
-    assert.equal(ts.isImportEqualsDeclaration(node), true, message);
-}
-export function isImportSpecifier(node, message = "node is not a ImportSpecifier") {
-    assert.equal(ts.isImportSpecifier(node), true, message);
-}
-export function isImportTypeNode(node, message = "node is not a ImportTypeNode") {
-    assert.equal(ts.isImportTypeNode(node), true, message);
-}
-export function isIndexedAccessTypeNode(node, message = "node is not a IndexedAccessTypeNode") {
-    assert.equal(ts.isIndexedAccessTypeNode(node), true, message);
-}
-export function isIndexSignatureDeclaration(node, message = "node is not a IndexSignatureDeclaration") {
-    assert.equal(ts.isIndexSignatureDeclaration(node), true, message);
-}
-export function isInferTypeNode(node, message = "node is not a InferTypeNode") {
-    assert.equal(ts.isInferTypeNode(node), true, message);
-}
-export function isInterfaceDeclaration(node, message = "node is not a InterfaceDeclaration") {
-    assert.equal(ts.isInterfaceDeclaration(node), true, message);
-}
-export function isIntersectionTypeNode(node, message = "node is not a IntersectionTypeNode") {
-    assert.equal(ts.isIntersectionTypeNode(node), true, message);
-}
-export function isJSDoc(node, message = "node is not a JSDoc") {
-    assert.equal(ts.isJSDoc(node), true, message);
-}
-export function isJSDocAllType(node, message = "node is not a JSDocAllType") {
-    assert.equal(ts.isJSDocAllType(node), true, message);
-}
-export function isJSDocAugmentsTag(node, message = "node is not a JSDocAugmentsTag") {
-    assert.equal(ts.isJSDocAugmentsTag(node), true, message);
-}
-export function isJSDocAuthorTag(node, message = "node is not a JSDocAuthorTag") {
-    assert.equal(ts.isJSDocAuthorTag(node), true, message);
-}
-export function isJSDocCallbackTag(node, message = "node is not a JSDocCallbackTag") {
-    assert.equal(ts.isJSDocCallbackTag(node), true, message);
-}
-export function isJSDocClassTag(node, message = "node is not a JSDocClassTag") {
-    assert.equal(ts.isJSDocClassTag(node), true, message);
-}
-export function isJSDocDeprecatedTag(node, message = "node is not a JSDocDeprecatedTag") {
-    assert.equal(ts.isJSDocDeprecatedTag(node), true, message);
-}
-export function isJSDocEnumTag(node, message = "node is not a JSDocEnumTag") {
-    assert.equal(ts.isJSDocEnumTag(node), true, message);
-}
-export function isJSDocFunctionType(node, message = "node is not a JSDocFunctionType") {
-    assert.equal(ts.isJSDocFunctionType(node), true, message);
-}
-export function isJSDocImplementsTag(node, message = "node is not a JSDocImplementsTag") {
-    assert.equal(ts.isJSDocImplementsTag(node), true, message);
-}
-export function isJSDocLink(node, message = "node is not a JSDocLink") {
-    assert.equal(ts.isJSDocLink(node), true, message);
-}
-export function isJSDocLinkCode(node, message = "node is not a JSDocLinkCode") {
-    assert.equal(ts.isJSDocLinkCode(node), true, message);
-}
-export function isJSDocLinkPlain(node, message = "node is not a JSDocLinkPlain") {
-    assert.equal(ts.isJSDocLinkPlain(node), true, message);
-}
-export function isJSDocMemberName(node, message = "node is not a JSDocMemberName") {
-    assert.equal(ts.isJSDocMemberName(node), true, message);
-}
-export function isJSDocNamepathType(node, message = "node is not a JSDocNamepathType") {
-    assert.equal(ts.isJSDocNamepathType(node), true, message);
-}
-export function isJSDocNameReference(node, message = "node is not a JSDocNameReference") {
-    assert.equal(ts.isJSDocNameReference(node), true, message);
-}
-export function isJSDocNonNullableType(node, message = "node is not a JSDocNonNullableType") {
-    assert.equal(ts.isJSDocNonNullableType(node), true, message);
-}
-export function isJSDocNullableType(node, message = "node is not a JSDocNullableType") {
-    assert.equal(ts.isJSDocNullableType(node), true, message);
-}
-export function isJSDocOptionalType(node, message = "node is not a JSDocOptionalType") {
-    assert.equal(ts.isJSDocOptionalType(node), true, message);
-}
-export function isJSDocOverloadTag(node, message = "node is not a JSDocOverloadTag") {
-    assert.equal(ts.isJSDocOverloadTag(node), true, message);
-}
-export function isJSDocOverrideTag(node, message = "node is not a JSDocOverrideTag") {
-    assert.equal(ts.isJSDocOverrideTag(node), true, message);
-}
-export function isJSDocParameterTag(node, message = "node is not a JSDocParameterTag") {
-    assert.equal(ts.isJSDocParameterTag(node), true, message);
-}
-export function isJSDocPrivateTag(node, message = "node is not a JSDocPrivateTag") {
-    assert.equal(ts.isJSDocPrivateTag(node), true, message);
-}
-export function isJSDocPropertyLikeTag(node, message = "node is not a JSDocPropertyLikeTag") {
-    assert.equal(ts.isJSDocPropertyLikeTag(node), true, message);
-}
-export function isJSDocPropertyTag(node, message = "node is not a JSDocPropertyTag") {
-    assert.equal(ts.isJSDocPropertyTag(node), true, message);
-}
-export function isJSDocProtectedTag(node, message = "node is not a JSDocProtectedTag") {
-    assert.equal(ts.isJSDocProtectedTag(node), true, message);
-}
-export function isJSDocPublicTag(node, message = "node is not a JSDocPublicTag") {
-    assert.equal(ts.isJSDocPublicTag(node), true, message);
-}
-export function isJSDocReadonlyTag(node, message = "node is not a JSDocReadonlyTag") {
-    assert.equal(ts.isJSDocReadonlyTag(node), true, message);
-}
-export function isJSDocReturnTag(node, message = "node is not a JSDocReturnTag") {
-    assert.equal(ts.isJSDocReturnTag(node), true, message);
-}
-export function isJSDocSatisfiesTag(node, message = "node is not a JSDocSatisfiesTag") {
-    assert.equal(ts.isJSDocSatisfiesTag(node), true, message);
-}
-export function isJSDocSeeTag(node, message = "node is not a JSDocSeeTag") {
-    assert.equal(ts.isJSDocSeeTag(node), true, message);
-}
-export function isJSDocSignature(node, message = "node is not a JSDocSignature") {
-    assert.equal(ts.isJSDocSignature(node), true, message);
-}
-export function isJSDocTemplateTag(node, message = "node is not a JSDocTemplateTag") {
-    assert.equal(ts.isJSDocTemplateTag(node), true, message);
-}
-export function isJSDocThisTag(node, message = "node is not a JSDocThisTag") {
-    assert.equal(ts.isJSDocThisTag(node), true, message);
-}
-export function isJSDocThrowsTag(node, message = "node is not a JSDocThrowsTag") {
-    assert.equal(ts.isJSDocThrowsTag(node), true, message);
-}
-export function isJSDocTypedefTag(node, message = "node is not a JSDocTypedefTag") {
-    assert.equal(ts.isJSDocTypedefTag(node), true, message);
-}
-export function isJSDocTypeExpression(node, message = "node is not a JSDocTypeExpression") {
-    assert.equal(ts.isJSDocTypeExpression(node), true, message);
-}
-export function isJSDocTypeLiteral(node, message = "node is not a JSDocTypeLiteral") {
-    assert.equal(ts.isJSDocTypeLiteral(node), true, message);
-}
-export function isJSDocTypeTag(node, message = "node is not a JSDocTypeTag") {
-    assert.equal(ts.isJSDocTypeTag(node), true, message);
-}
-export function isJSDocUnknownTag(node, message = "node is not a JSDocUnknownTag") {
-    assert.equal(ts.isJSDocUnknownTag(node), true, message);
-}
-export function isJSDocUnknownType(node, message = "node is not a JSDocUnknownType") {
-    assert.equal(ts.isJSDocUnknownType(node), true, message);
-}
-export function isJSDocVariadicType(node, message = "node is not a JSDocVariadicType") {
-    assert.equal(ts.isJSDocVariadicType(node), true, message);
-}
-export function isJsxAttribute(node, message = "node is not a JsxAttribute") {
-    assert.equal(ts.isJsxAttribute(node), true, message);
-}
-export function isJsxAttributeLike(node, message = "node is not a JsxAttributeLike") {
-    assert.equal(ts.isJsxAttributeLike(node), true, message);
-}
-export function isJsxAttributes(node, message = "node is not a JsxAttributes") {
-    assert.equal(ts.isJsxAttributes(node), true, message);
-}
-export function isJsxChild(node, message = "node is not a JsxChild") {
-    assert.equal(ts.isJsxChild(node), true, message);
-}
-export function isJsxClosingElement(node, message = "node is not a JsxClosingElement") {
-    assert.equal(ts.isJsxClosingElement(node), true, message);
-}
-export function isJsxClosingFragment(node, message = "node is not a JsxClosingFragment") {
-    assert.equal(ts.isJsxClosingFragment(node), true, message);
-}
-export function isJsxElement(node, message = "node is not a JsxElement") {
-    assert.equal(ts.isJsxElement(node), true, message);
-}
-export function isJsxExpression(node, message = "node is not a JsxExpression") {
-    assert.equal(ts.isJsxExpression(node), true, message);
-}
-export function isJsxFragment(node, message = "node is not a JsxFragment") {
-    assert.equal(ts.isJsxFragment(node), true, message);
-}
-export function isJsxNamespacedName(node, message = "node is not a JsxNamespacedName") {
-    assert.equal(ts.isJsxNamespacedName(node), true, message);
-}
-export function isJsxOpeningElement(node, message = "node is not a JsxOpeningElement") {
-    assert.equal(ts.isJsxOpeningElement(node), true, message);
-}
-export function isJsxOpeningFragment(node, message = "node is not a JsxOpeningFragment") {
-    assert.equal(ts.isJsxOpeningFragment(node), true, message);
-}
-export function isJsxOpeningLikeElement(node, message = "node is not a JsxOpeningLikeElement") {
-    assert.equal(ts.isJsxOpeningLikeElement(node), true, message);
-}
-export function isJsxSelfClosingElement(node, message = "node is not a JsxSelfClosingElement") {
-    assert.equal(ts.isJsxSelfClosingElement(node), true, message);
-}
-export function isJsxSpreadAttribute(node, message = "node is not a JsxSpreadAttribute") {
-    assert.equal(ts.isJsxSpreadAttribute(node), true, message);
-}
-export function isJsxTagNameExpression(node, message = "node is not a JsxTagNameExpression") {
-    assert.equal(ts.isJsxTagNameExpression(node), true, message);
-}
-export function isJsxText(node, message = "node is not a JsxText") {
-    assert.equal(ts.isJsxText(node), true, message);
-}
-export function isLabeledStatement(node, message = "node is not a LabeledStatement") {
-    assert.equal(ts.isLabeledStatement(node), true, message);
-}
-export function isLeftHandSideExpression(node, message = "node is not a LeftHandSideExpression") {
-    assert.equal(ts.isLeftHandSideExpression(node), true, message);
-}
-export function isLiteralExpression(node, message = "node is not a LiteralExpression") {
-    assert.equal(ts.isLiteralExpression(node), true, message);
-}
-export function isLiteralTypeNode(node, message = "node is not a LiteralTypeNode") {
-    assert.equal(ts.isLiteralTypeNode(node), true, message);
-}
-export function isMappedTypeNode(node, message = "node is not a MappedTypeNode") {
-    assert.equal(ts.isMappedTypeNode(node), true, message);
-}
-export function isMemberName(node, message = "node is not a MemberName") {
-    assert.equal(ts.isMemberName(node), true, message);
-}
-export function isMetaProperty(node, message = "node is not a MetaProperty") {
-    assert.equal(ts.isMetaProperty(node), true, message);
-}
-export function isMethodDeclaration(node, message = "node is not a MethodDeclaration") {
-    assert.equal(ts.isMethodDeclaration(node), true, message);
-}
-export function isMethodSignature(node, message = "node is not a MethodSignature") {
-    assert.equal(ts.isMethodSignature(node), true, message);
-}
-export function isMinusToken(node, message = "node is not a MinusToken") {
-    assert.equal(ts.isMinusToken(node), true, message);
-}
-export function isMissingDeclaration(node, message = "node is not a MissingDeclaration") {
-    assert.equal(ts.isMissingDeclaration(node), true, message);
-}
-export function isModifier(node, message = "node is not a Modifier") {
-    assert.equal(ts.isModifier(node), true, message);
-}
-export function isModifierLike(node, message = "node is not a ModifierLike") {
-    assert.equal(ts.isModifierLike(node), true, message);
-}
-export function isModuleBlock(node, message = "node is not a ModuleBlock") {
-    assert.equal(ts.isModuleBlock(node), true, message);
-}
-export function isModuleBody(node, message = "node is not a ModuleBody") {
-    assert.equal(ts.isModuleBody(node), true, message);
-}
-export function isModuleDeclaration(node, message = "node is not a ModuleDeclaration") {
-    assert.equal(ts.isModuleDeclaration(node), true, message);
-}
-export function isModuleName(node, message = "node is not a ModuleName") {
-    assert.equal(ts.isModuleName(node), true, message);
-}
-export function isModuleReference(node, message = "node is not a ModuleReference") {
-    assert.equal(ts.isModuleReference(node), true, message);
-}
-export function isNamedExportBindings(node, message = "node is not a NamedExportBindings") {
-    assert.equal(ts.isNamedExportBindings(node), true, message);
-}
-export function isNamedExports(node, message = "node is not a NamedExports") {
-    assert.equal(ts.isNamedExports(node), true, message);
-}
-export function isNamedImportBindings(node, message = "node is not a NamedImportBindings") {
-    assert.equal(ts.isNamedImportBindings(node), true, message);
-}
-export function isNamedImports(node, message = "node is not a NamedImports") {
-    assert.equal(ts.isNamedImports(node), true, message);
-}
-export function isNamedTupleMember(node, message = "node is not a NamedTupleMember") {
-    assert.equal(ts.isNamedTupleMember(node), true, message);
-}
-export function isNamespaceExport(node, message = "node is not a NamespaceExport") {
-    assert.equal(ts.isNamespaceExport(node), true, message);
-}
-export function isNamespaceExportDeclaration(node, message = "node is not a NamespaceExportDeclaration") {
-    assert.equal(ts.isNamespaceExportDeclaration(node), true, message);
-}
-export function isNamespaceImport(node, message = "node is not a NamespaceImport") {
-    assert.equal(ts.isNamespaceImport(node), true, message);
-}
-export function isNewExpression(node, message = "node is not a NewExpression") {
-    assert.equal(ts.isNewExpression(node), true, message);
-}
-export function isNonNullChain(node, message = "node is not a NonNullChain") {
-    assert.equal(ts.isNonNullChain(node), true, message);
-}
-export function isNonNullExpression(node, message = "node is not a NonNullExpression") {
-    assert.equal(ts.isNonNullExpression(node), true, message);
-}
-export function isNoSubstitutionTemplateLiteral(node, message = "node is not a NoSubstitutionTemplateLiteral") {
-    assert.equal(ts.isNoSubstitutionTemplateLiteral(node), true, message);
-}
-export function isNotEmittedStatement(node, message = "node is not a NotEmittedStatement") {
-    assert.equal(ts.isNotEmittedStatement(node), true, message);
-}
-export function isNumericLiteral(node, message = "node is not a NumericLiteral") {
-    assert.equal(ts.isNumericLiteral(node), true, message);
-}
-export function isObjectBindingPattern(node, message = "node is not a ObjectBindingPattern") {
-    assert.equal(ts.isObjectBindingPattern(node), true, message);
-}
-export function isObjectLiteralElement(node, message = "node is not a ObjectLiteralElement") {
-    assert.equal(ts.isObjectLiteralElement(node), true, message);
-}
-export function isObjectLiteralElementLike(node, message = "node is not a ObjectLiteralElementLike") {
-    assert.equal(ts.isObjectLiteralElementLike(node), true, message);
-}
-export function isObjectLiteralExpression(node, message = "node is not a ObjectLiteralExpression") {
-    assert.equal(ts.isObjectLiteralExpression(node), true, message);
-}
-export function isOmittedExpression(node, message = "node is not a OmittedExpression") {
-    assert.equal(ts.isOmittedExpression(node), true, message);
-}
-export function isOptionalTypeNode(node, message = "node is not a OptionalTypeNode") {
-    assert.equal(ts.isOptionalTypeNode(node), true, message);
-}
-export function isParameter(node, message = "node is not a ParameterDeclaration") {
-    assert.equal(ts.isParameter(node), true, message);
-}
-export function isParenthesizedExpression(node, message = "node is not a ParenthesizedExpression") {
-    assert.equal(ts.isParenthesizedExpression(node), true, message);
-}
-export function isParenthesizedTypeNode(node, message = "node is not a ParenthesizedTypeNode") {
-    assert.equal(ts.isParenthesizedTypeNode(node), true, message);
-}
-export function isPartiallyEmittedExpression(node, message = "node is not a PartiallyEmittedExpression") {
-    assert.equal(ts.isPartiallyEmittedExpression(node), true, message);
-}
-export function isPlusToken(node, message = "node is not a PlusToken") {
-    assert.equal(ts.isPlusToken(node), true, message);
-}
-export function isPostfixUnaryExpression(node, message = "node is not a PostfixUnaryExpression") {
-    assert.equal(ts.isPostfixUnaryExpression(node), true, message);
-}
-export function isPrefixUnaryExpression(node, message = "node is not a PrefixUnaryExpression") {
-    assert.equal(ts.isPrefixUnaryExpression(node), true, message);
-}
-export function isPrivateIdentifier(node, message = "node is not a PrivateIdentifier") {
-    assert.equal(ts.isPrivateIdentifier(node), true, message);
-}
-export function isPropertyAccessChain(node, message = "node is not a PropertyAccessChain") {
-    assert.equal(ts.isPropertyAccessChain(node), true, message);
-}
-export function isPropertyAccessExpression(node, message = "node is not a PropertyAccessExpression") {
-    assert.equal(ts.isPropertyAccessExpression(node), true, message);
-}
-export function isPropertyAssignment(node, message = "node is not a PropertyAssignment") {
-    assert.equal(ts.isPropertyAssignment(node), true, message);
-}
-export function isPropertyDeclaration(node, message = "node is not a PropertyDeclaration") {
-    assert.equal(ts.isPropertyDeclaration(node), true, message);
-}
-export function isPropertyName(node, message = "node is not a PropertyName") {
-    assert.equal(ts.isPropertyName(node), true, message);
-}
-export function isPropertySignature(node, message = "node is not a PropertySignature") {
-    assert.equal(ts.isPropertySignature(node), true, message);
-}
-export function isQualifiedName(node, message = "node is not a QualifiedName") {
-    assert.equal(ts.isQualifiedName(node), true, message);
-}
-export function isQuestionDotToken(node, message = "node is not a QuestionDotToken") {
-    assert.equal(ts.isQuestionDotToken(node), true, message);
-}
-export function isQuestionToken(node, message = "node is not a QuestionToken") {
-    assert.equal(ts.isQuestionToken(node), true, message);
-}
-export function isRegularExpressionLiteral(node, message = "node is not a RegularExpressionLiteral") {
-    assert.equal(ts.isRegularExpressionLiteral(node), true, message);
-}
-export function isRestTypeNode(node, message = "node is not a RestTypeNode") {
-    assert.equal(ts.isRestTypeNode(node), true, message);
-}
-export function isReturnStatement(node, message = "node is not a ReturnStatement") {
-    assert.equal(ts.isReturnStatement(node), true, message);
-}
-export function isSatisfiesExpression(node, message = "node is not a SatisfiesExpression") {
-    assert.equal(ts.isSatisfiesExpression(node), true, message);
-}
-export function isSemicolonClassElement(node, message = "node is not a SemicolonClassElement") {
-    assert.equal(ts.isSemicolonClassElement(node), true, message);
-}
-export function isSetAccessor(node, message = "node is not a SetAccessorDeclaration") {
-    assert.equal(ts.isSetAccessor(node), true, message);
-}
-export function isSetAccessorDeclaration(node, message = "node is not a SetAccessorDeclaration") {
-    assert.equal(ts.isSetAccessorDeclaration(node), true, message);
-}
-export function isShorthandPropertyAssignment(node, message = "node is not a ShorthandPropertyAssignment") {
-    assert.equal(ts.isShorthandPropertyAssignment(node), true, message);
-}
-export function isSourceFile(node, message = "node is not a SourceFile") {
-    assert.equal(ts.isSourceFile(node), true, message);
-}
-export function isSpreadAssignment(node, message = "node is not a SpreadAssignment") {
-    assert.equal(ts.isSpreadAssignment(node), true, message);
-}
-export function isSpreadElement(node, message = "node is not a SpreadElement") {
-    assert.equal(ts.isSpreadElement(node), true, message);
-}
-export function isStatement(node, message = "node is not a Statement") {
-    assert.equal(ts.isStatement(node), true, message);
-}
-export function isStringLiteral(node, message = "node is not a StringLiteral") {
-    assert.equal(ts.isStringLiteral(node), true, message);
-}
-export function isSwitchStatement(node, message = "node is not a SwitchStatement") {
-    assert.equal(ts.isSwitchStatement(node), true, message);
-}
-export function isSyntheticExpression(node, message = "node is not a SyntheticExpression") {
-    assert.equal(ts.isSyntheticExpression(node), true, message);
-}
-export function isTaggedTemplateExpression(node, message = "node is not a TaggedTemplateExpression") {
-    assert.equal(ts.isTaggedTemplateExpression(node), true, message);
-}
-export function isTemplateExpression(node, message = "node is not a TemplateExpression") {
-    assert.equal(ts.isTemplateExpression(node), true, message);
-}
-export function isTemplateHead(node, message = "node is not a TemplateHead") {
-    assert.equal(ts.isTemplateHead(node), true, message);
-}
-export function isTemplateLiteral(node, message = "node is not a TemplateLiteral") {
-    assert.equal(ts.isTemplateLiteral(node), true, message);
-}
-export function isTemplateLiteralToken(node, message = "node is not a TemplateLiteralToken") {
-    assert.equal(ts.isTemplateLiteralToken(node), true, message);
-}
-export function isTemplateLiteralTypeNode(node, message = "node is not a TemplateLiteralTypeNode") {
-    assert.equal(ts.isTemplateLiteralTypeNode(node), true, message);
-}
-export function isTemplateLiteralTypeSpan(node, message = "node is not a TemplateLiteralTypeSpan") {
-    assert.equal(ts.isTemplateLiteralTypeSpan(node), true, message);
-}
-export function isTemplateMiddle(node, message = "node is not a TemplateMiddle") {
-    assert.equal(ts.isTemplateMiddle(node), true, message);
-}
-export function isTemplateSpan(node, message = "node is not a TemplateSpan") {
-    assert.equal(ts.isTemplateSpan(node), true, message);
-}
-export function isTemplateTail(node, message = "node is not a TemplateTail") {
-    assert.equal(ts.isTemplateTail(node), true, message);
-}
-export function isThisTypeNode(node, message = "node is not a ThisTypeNode") {
-    assert.equal(ts.isThisTypeNode(node), true, message);
-}
-export function isThrowStatement(node, message = "node is not a ThrowStatement") {
-    assert.equal(ts.isThrowStatement(node), true, message);
-}
-export function isTryStatement(node, message = "node is not a TryStatement") {
-    assert.equal(ts.isTryStatement(node), true, message);
-}
-export function isTupleTypeNode(node, message = "node is not a TupleTypeNode") {
-    assert.equal(ts.isTupleTypeNode(node), true, message);
-}
-export function isTypeAliasDeclaration(node, message = "node is not a TypeAliasDeclaration") {
-    assert.equal(ts.isTypeAliasDeclaration(node), true, message);
-}
-export function isTypeAssertionExpression(node, message = "node is not a TypeAssertion") {
-    assert.equal(ts.isTypeAssertionExpression(node), true, message);
-}
-export function isTypeElement(node, message = "node is not a TypeElement") {
-    assert.equal(ts.isTypeElement(node), true, message);
-}
-export function isTypeLiteralNode(node, message = "node is not a TypeLiteralNode") {
-    assert.equal(ts.isTypeLiteralNode(node), true, message);
-}
-export function isTypeNode(node, message = "node is not a TypeNode") {
-    assert.equal(ts.isTypeNode(node), true, message);
-}
-export function isTypeOfExpression(node, message = "node is not a TypeOfExpression") {
-    assert.equal(ts.isTypeOfExpression(node), true, message);
-}
-export function isTypeOnlyExportDeclaration(node, message = "node is not a TypeOnlyExportDeclaration") {
-    assert.equal(ts.isTypeOnlyExportDeclaration(node), true, message);
-}
-export function isTypeOnlyImportDeclaration(node, message = "node is not a TypeOnlyImportDeclaration") {
-    assert.equal(ts.isTypeOnlyImportDeclaration(node), true, message);
-}
-export function isTypeOnlyImportOrExportDeclaration(node, message = "node is not a TypeOnlyAliasDeclaration") {
-    assert.equal(ts.isTypeOnlyImportOrExportDeclaration(node), true, message);
-}
-export function isTypeOperatorNode(node, message = "node is not a TypeOperatorNode") {
-    assert.equal(ts.isTypeOperatorNode(node), true, message);
-}
-export function isTypeParameterDeclaration(node, message = "node is not a TypeParameterDeclaration") {
-    assert.equal(ts.isTypeParameterDeclaration(node), true, message);
-}
-export function isTypePredicateNode(node, message = "node is not a TypePredicateNode") {
-    assert.equal(ts.isTypePredicateNode(node), true, message);
-}
-export function isTypeQueryNode(node, message = "node is not a TypeQueryNode") {
-    assert.equal(ts.isTypeQueryNode(node), true, message);
-}
-export function isTypeReferenceNode(node, message = "node is not a TypeReferenceNode") {
-    assert.equal(ts.isTypeReferenceNode(node), true, message);
-}
-export function isUnionTypeNode(node, message = "node is not a UnionTypeNode") {
-    assert.equal(ts.isUnionTypeNode(node), true, message);
-}
-export function isVariableDeclaration(node, message = "node is not a VariableDeclaration") {
-    assert.equal(ts.isVariableDeclaration(node), true, message);
-}
-export function isVariableDeclarationList(node, message = "node is not a VariableDeclarationList") {
-    assert.equal(ts.isVariableDeclarationList(node), true, message);
-}
-export function isVariableStatement(node, message = "node is not a VariableStatement") {
-    assert.equal(ts.isVariableStatement(node), true, message);
-}
-export function isVoidExpression(node, message = "node is not a VoidExpression") {
-    assert.equal(ts.isVoidExpression(node), true, message);
-}
-export function isWhileStatement(node, message = "node is not a WhileStatement") {
-    assert.equal(ts.isWhileStatement(node), true, message);
-}
-export function isWithStatement(node, message = "node is not a WithStatement") {
-    assert.equal(ts.isWithStatement(node), true, message);
-}
-export function isYieldExpression(node, message = "node is not a YieldExpression") {
-    assert.equal(ts.isYieldExpression(node), true, message);
-}
-export default {
-    isAccessor,
-    isArrayBindingElement,
-    isArrayBindingPattern,
-    isArrayLiteralExpression,
-    isArrayTypeNode,
-    isArrowFunction,
-    isAsExpression,
-    isAssertionExpression,
-    isAssertsKeyword,
-    isAsteriskToken,
-    isAutoAccessorPropertyDeclaration,
-    isAwaitExpression,
-    isAwaitKeyword,
-    isBigIntLiteral,
-    isBinaryExpression,
-    isBinaryOperatorToken,
-    isBindingElement,
-    isBindingName,
-    isBlock,
-    isBreakOrContinueStatement,
-    isBreakStatement,
-    isBundle,
-    isCallChain,
-    isCallExpression,
-    isCallLikeExpression,
-    isCallSignatureDeclaration,
-    isCaseBlock,
-    isCaseClause,
-    isCaseOrDefaultClause,
-    isCatchClause,
-    isClassDeclaration,
-    isClassElement,
-    isClassExpression,
-    isClassLike,
-    isClassStaticBlockDeclaration,
-    isColonToken,
-    isCommaListExpression,
-    isComputedPropertyName,
-    isConciseBody,
-    isConditionalExpression,
-    isConditionalTypeNode,
-    isConstructorDeclaration,
-    isConstructorTypeNode,
-    isConstructSignatureDeclaration,
-    isContinueStatement,
-    isDebuggerStatement,
-    isDeclarationStatement,
-    isDecorator,
-    isDefaultClause,
-    isDeleteExpression,
-    isDoStatement,
-    isDotDotDotToken,
-    isElementAccessChain,
-    isElementAccessExpression,
-    isEmptyBindingPattern,
-    isEmptyStatement,
-    isEntityName,
-    isEnumDeclaration,
-    isEnumMember,
-    isEqualsGreaterThanToken,
-    isExclamationToken,
-    isExportAssignment,
-    isExportDeclaration,
-    isExportSpecifier,
-    isExpression,
-    isExpressionStatement,
-    isExpressionWithTypeArguments,
-    isExternalModuleReference,
-    isForInitializer,
-    isForInStatement,
-    isForOfStatement,
-    isForStatement,
-    isFunctionDeclaration,
-    isFunctionExpression,
-    isFunctionTypeNode,
-    isGetAccessor,
-    isGetAccessorDeclaration,
-    isHeritageClause,
-    isIdentifier,
-    isIfStatement,
-    isImportAttribute,
-    isImportAttributeName,
-    isImportAttributes,
-    isImportClause,
-    isImportDeclaration,
-    isImportEqualsDeclaration,
-    isImportSpecifier,
-    isImportTypeNode,
-    isIndexedAccessTypeNode,
-    isIndexSignatureDeclaration,
-    isInferTypeNode,
-    isInterfaceDeclaration,
-    isIntersectionTypeNode,
-    isJSDoc,
-    isJSDocAllType,
-    isJSDocAugmentsTag,
-    isJSDocAuthorTag,
-    isJSDocCallbackTag,
-    isJSDocClassTag,
-    isJSDocDeprecatedTag,
-    isJSDocEnumTag,
-    isJSDocFunctionType,
-    isJSDocImplementsTag,
-    isJSDocLink,
-    isJSDocLinkCode,
-    isJSDocLinkPlain,
-    isJSDocMemberName,
-    isJSDocNamepathType,
-    isJSDocNameReference,
-    isJSDocNonNullableType,
-    isJSDocNullableType,
-    isJSDocOptionalType,
-    isJSDocOverloadTag,
-    isJSDocOverrideTag,
-    isJSDocParameterTag,
-    isJSDocPrivateTag,
-    isJSDocPropertyLikeTag,
-    isJSDocPropertyTag,
-    isJSDocProtectedTag,
-    isJSDocPublicTag,
-    isJSDocReadonlyTag,
-    isJSDocReturnTag,
-    isJSDocSatisfiesTag,
-    isJSDocSeeTag,
-    isJSDocSignature,
-    isJSDocTemplateTag,
-    isJSDocThisTag,
-    isJSDocThrowsTag,
-    isJSDocTypedefTag,
-    isJSDocTypeExpression,
-    isJSDocTypeLiteral,
-    isJSDocTypeTag,
-    isJSDocUnknownTag,
-    isJSDocUnknownType,
-    isJSDocVariadicType,
-    isJsxAttribute,
-    isJsxAttributeLike,
-    isJsxAttributes,
-    isJsxChild,
-    isJsxClosingElement,
-    isJsxClosingFragment,
-    isJsxElement,
-    isJsxExpression,
-    isJsxFragment,
-    isJsxNamespacedName,
-    isJsxOpeningElement,
-    isJsxOpeningFragment,
-    isJsxOpeningLikeElement,
-    isJsxSelfClosingElement,
-    isJsxSpreadAttribute,
-    isJsxTagNameExpression,
-    isJsxText,
-    isLabeledStatement,
-    isLeftHandSideExpression,
-    isLiteralExpression,
-    isLiteralTypeNode,
-    isMappedTypeNode,
-    isMemberName,
-    isMetaProperty,
-    isMethodDeclaration,
-    isMethodSignature,
-    isMinusToken,
-    isMissingDeclaration,
-    isModifier,
-    isModifierLike,
-    isModuleBlock,
-    isModuleBody,
-    isModuleDeclaration,
-    isModuleName,
-    isModuleReference,
-    isNamedExportBindings,
-    isNamedExports,
-    isNamedImportBindings,
-    isNamedImports,
-    isNamedTupleMember,
-    isNamespaceExport,
-    isNamespaceExportDeclaration,
-    isNamespaceImport,
-    isNewExpression,
-    isNonNullChain,
-    isNonNullExpression,
-    isNoSubstitutionTemplateLiteral,
-    isNotEmittedStatement,
-    isNumericLiteral,
-    isObjectBindingPattern,
-    isObjectLiteralElement,
-    isObjectLiteralElementLike,
-    isObjectLiteralExpression,
-    isOmittedExpression,
-    isOptionalTypeNode,
-    isParameter,
-    isParenthesizedExpression,
-    isParenthesizedTypeNode,
-    isPartiallyEmittedExpression,
-    isPlusToken,
-    isPostfixUnaryExpression,
-    isPrefixUnaryExpression,
-    isPrivateIdentifier,
-    isPropertyAccessChain,
-    isPropertyAccessExpression,
-    isPropertyAssignment,
-    isPropertyDeclaration,
-    isPropertyName,
-    isPropertySignature,
-    isQualifiedName,
-    isQuestionDotToken,
-    isQuestionToken,
-    isRegularExpressionLiteral,
-    isRestTypeNode,
-    isReturnStatement,
-    isSatisfiesExpression,
-    isSemicolonClassElement,
-    isSetAccessor,
-    isSetAccessorDeclaration,
-    isShorthandPropertyAssignment,
-    isSourceFile,
-    isSpreadAssignment,
-    isSpreadElement,
-    isStatement,
-    isStringLiteral,
-    isSwitchStatement,
-    isSyntheticExpression,
-    isTaggedTemplateExpression,
-    isTemplateExpression,
-    isTemplateHead,
-    isTemplateLiteral,
-    isTemplateLiteralToken,
-    isTemplateLiteralTypeNode,
-    isTemplateLiteralTypeSpan,
-    isTemplateMiddle,
-    isTemplateSpan,
-    isTemplateTail,
-    isThisTypeNode,
-    isThrowStatement,
-    isTryStatement,
-    isTupleTypeNode,
-    isTypeAliasDeclaration,
-    isTypeAssertionExpression,
-    isTypeElement,
-    isTypeLiteralNode,
-    isTypeNode,
-    isTypeOfExpression,
-    isTypeOnlyExportDeclaration,
-    isTypeOnlyImportDeclaration,
-    isTypeOnlyImportOrExportDeclaration,
-    isTypeOperatorNode,
-    isTypeParameterDeclaration,
-    isTypePredicateNode,
-    isTypeQueryNode,
-    isTypeReferenceNode,
-    isUnionTypeNode,
-    isVariableDeclaration,
-    isVariableDeclarationList,
-    isVariableStatement,
-    isVoidExpression,
-    isWhileStatement,
-    isWithStatement,
-    isYieldExpression,
-};
-//# sourceMappingURL=assertions.js.map