| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.assertArrayExpression = assertArrayExpression; |
| exports.assertAssignmentExpression = assertAssignmentExpression; |
| exports.assertBinaryExpression = assertBinaryExpression; |
| exports.assertInterpreterDirective = assertInterpreterDirective; |
| exports.assertDirective = assertDirective; |
| exports.assertDirectiveLiteral = assertDirectiveLiteral; |
| exports.assertBlockStatement = assertBlockStatement; |
| exports.assertBreakStatement = assertBreakStatement; |
| exports.assertCallExpression = assertCallExpression; |
| exports.assertCatchClause = assertCatchClause; |
| exports.assertConditionalExpression = assertConditionalExpression; |
| exports.assertContinueStatement = assertContinueStatement; |
| exports.assertDebuggerStatement = assertDebuggerStatement; |
| exports.assertDoWhileStatement = assertDoWhileStatement; |
| exports.assertEmptyStatement = assertEmptyStatement; |
| exports.assertExpressionStatement = assertExpressionStatement; |
| exports.assertFile = assertFile; |
| exports.assertForInStatement = assertForInStatement; |
| exports.assertForStatement = assertForStatement; |
| exports.assertFunctionDeclaration = assertFunctionDeclaration; |
| exports.assertFunctionExpression = assertFunctionExpression; |
| exports.assertIdentifier = assertIdentifier; |
| exports.assertIfStatement = assertIfStatement; |
| exports.assertLabeledStatement = assertLabeledStatement; |
| exports.assertStringLiteral = assertStringLiteral; |
| exports.assertNumericLiteral = assertNumericLiteral; |
| exports.assertNullLiteral = assertNullLiteral; |
| exports.assertBooleanLiteral = assertBooleanLiteral; |
| exports.assertRegExpLiteral = assertRegExpLiteral; |
| exports.assertLogicalExpression = assertLogicalExpression; |
| exports.assertMemberExpression = assertMemberExpression; |
| exports.assertNewExpression = assertNewExpression; |
| exports.assertProgram = assertProgram; |
| exports.assertObjectExpression = assertObjectExpression; |
| exports.assertObjectMethod = assertObjectMethod; |
| exports.assertObjectProperty = assertObjectProperty; |
| exports.assertRestElement = assertRestElement; |
| exports.assertReturnStatement = assertReturnStatement; |
| exports.assertSequenceExpression = assertSequenceExpression; |
| exports.assertParenthesizedExpression = assertParenthesizedExpression; |
| exports.assertSwitchCase = assertSwitchCase; |
| exports.assertSwitchStatement = assertSwitchStatement; |
| exports.assertThisExpression = assertThisExpression; |
| exports.assertThrowStatement = assertThrowStatement; |
| exports.assertTryStatement = assertTryStatement; |
| exports.assertUnaryExpression = assertUnaryExpression; |
| exports.assertUpdateExpression = assertUpdateExpression; |
| exports.assertVariableDeclaration = assertVariableDeclaration; |
| exports.assertVariableDeclarator = assertVariableDeclarator; |
| exports.assertWhileStatement = assertWhileStatement; |
| exports.assertWithStatement = assertWithStatement; |
| exports.assertAssignmentPattern = assertAssignmentPattern; |
| exports.assertArrayPattern = assertArrayPattern; |
| exports.assertArrowFunctionExpression = assertArrowFunctionExpression; |
| exports.assertClassBody = assertClassBody; |
| exports.assertClassDeclaration = assertClassDeclaration; |
| exports.assertClassExpression = assertClassExpression; |
| exports.assertExportAllDeclaration = assertExportAllDeclaration; |
| exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration; |
| exports.assertExportNamedDeclaration = assertExportNamedDeclaration; |
| exports.assertExportSpecifier = assertExportSpecifier; |
| exports.assertForOfStatement = assertForOfStatement; |
| exports.assertImportDeclaration = assertImportDeclaration; |
| exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier; |
| exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier; |
| exports.assertImportSpecifier = assertImportSpecifier; |
| exports.assertMetaProperty = assertMetaProperty; |
| exports.assertClassMethod = assertClassMethod; |
| exports.assertObjectPattern = assertObjectPattern; |
| exports.assertSpreadElement = assertSpreadElement; |
| exports.assertSuper = assertSuper; |
| exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression; |
| exports.assertTemplateElement = assertTemplateElement; |
| exports.assertTemplateLiteral = assertTemplateLiteral; |
| exports.assertYieldExpression = assertYieldExpression; |
| exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation; |
| exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation; |
| exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation; |
| exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation; |
| exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation; |
| exports.assertClassImplements = assertClassImplements; |
| exports.assertDeclareClass = assertDeclareClass; |
| exports.assertDeclareFunction = assertDeclareFunction; |
| exports.assertDeclareInterface = assertDeclareInterface; |
| exports.assertDeclareModule = assertDeclareModule; |
| exports.assertDeclareModuleExports = assertDeclareModuleExports; |
| exports.assertDeclareTypeAlias = assertDeclareTypeAlias; |
| exports.assertDeclareOpaqueType = assertDeclareOpaqueType; |
| exports.assertDeclareVariable = assertDeclareVariable; |
| exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration; |
| exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration; |
| exports.assertDeclaredPredicate = assertDeclaredPredicate; |
| exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation; |
| exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation; |
| exports.assertFunctionTypeParam = assertFunctionTypeParam; |
| exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation; |
| exports.assertInferredPredicate = assertInferredPredicate; |
| exports.assertInterfaceExtends = assertInterfaceExtends; |
| exports.assertInterfaceDeclaration = assertInterfaceDeclaration; |
| exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation; |
| exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation; |
| exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation; |
| exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation; |
| exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation; |
| exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation; |
| exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation; |
| exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation; |
| exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot; |
| exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty; |
| exports.assertObjectTypeIndexer = assertObjectTypeIndexer; |
| exports.assertObjectTypeProperty = assertObjectTypeProperty; |
| exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty; |
| exports.assertOpaqueType = assertOpaqueType; |
| exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier; |
| exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation; |
| exports.assertStringTypeAnnotation = assertStringTypeAnnotation; |
| exports.assertThisTypeAnnotation = assertThisTypeAnnotation; |
| exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation; |
| exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation; |
| exports.assertTypeAlias = assertTypeAlias; |
| exports.assertTypeAnnotation = assertTypeAnnotation; |
| exports.assertTypeCastExpression = assertTypeCastExpression; |
| exports.assertTypeParameter = assertTypeParameter; |
| exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration; |
| exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation; |
| exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation; |
| exports.assertVariance = assertVariance; |
| exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation; |
| exports.assertJSXAttribute = assertJSXAttribute; |
| exports.assertJSXClosingElement = assertJSXClosingElement; |
| exports.assertJSXElement = assertJSXElement; |
| exports.assertJSXEmptyExpression = assertJSXEmptyExpression; |
| exports.assertJSXExpressionContainer = assertJSXExpressionContainer; |
| exports.assertJSXSpreadChild = assertJSXSpreadChild; |
| exports.assertJSXIdentifier = assertJSXIdentifier; |
| exports.assertJSXMemberExpression = assertJSXMemberExpression; |
| exports.assertJSXNamespacedName = assertJSXNamespacedName; |
| exports.assertJSXOpeningElement = assertJSXOpeningElement; |
| exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute; |
| exports.assertJSXText = assertJSXText; |
| exports.assertJSXFragment = assertJSXFragment; |
| exports.assertJSXOpeningFragment = assertJSXOpeningFragment; |
| exports.assertJSXClosingFragment = assertJSXClosingFragment; |
| exports.assertNoop = assertNoop; |
| exports.assertPlaceholder = assertPlaceholder; |
| exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier; |
| exports.assertArgumentPlaceholder = assertArgumentPlaceholder; |
| exports.assertAwaitExpression = assertAwaitExpression; |
| exports.assertBindExpression = assertBindExpression; |
| exports.assertClassProperty = assertClassProperty; |
| exports.assertOptionalMemberExpression = assertOptionalMemberExpression; |
| exports.assertPipelineTopicExpression = assertPipelineTopicExpression; |
| exports.assertPipelineBareFunction = assertPipelineBareFunction; |
| exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference; |
| exports.assertOptionalCallExpression = assertOptionalCallExpression; |
| exports.assertClassPrivateProperty = assertClassPrivateProperty; |
| exports.assertClassPrivateMethod = assertClassPrivateMethod; |
| exports.assertImport = assertImport; |
| exports.assertDecorator = assertDecorator; |
| exports.assertDoExpression = assertDoExpression; |
| exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier; |
| exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier; |
| exports.assertPrivateName = assertPrivateName; |
| exports.assertBigIntLiteral = assertBigIntLiteral; |
| exports.assertTSParameterProperty = assertTSParameterProperty; |
| exports.assertTSDeclareFunction = assertTSDeclareFunction; |
| exports.assertTSDeclareMethod = assertTSDeclareMethod; |
| exports.assertTSQualifiedName = assertTSQualifiedName; |
| exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration; |
| exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration; |
| exports.assertTSPropertySignature = assertTSPropertySignature; |
| exports.assertTSMethodSignature = assertTSMethodSignature; |
| exports.assertTSIndexSignature = assertTSIndexSignature; |
| exports.assertTSAnyKeyword = assertTSAnyKeyword; |
| exports.assertTSBooleanKeyword = assertTSBooleanKeyword; |
| exports.assertTSBigIntKeyword = assertTSBigIntKeyword; |
| exports.assertTSNeverKeyword = assertTSNeverKeyword; |
| exports.assertTSNullKeyword = assertTSNullKeyword; |
| exports.assertTSNumberKeyword = assertTSNumberKeyword; |
| exports.assertTSObjectKeyword = assertTSObjectKeyword; |
| exports.assertTSStringKeyword = assertTSStringKeyword; |
| exports.assertTSSymbolKeyword = assertTSSymbolKeyword; |
| exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword; |
| exports.assertTSUnknownKeyword = assertTSUnknownKeyword; |
| exports.assertTSVoidKeyword = assertTSVoidKeyword; |
| exports.assertTSThisType = assertTSThisType; |
| exports.assertTSFunctionType = assertTSFunctionType; |
| exports.assertTSConstructorType = assertTSConstructorType; |
| exports.assertTSTypeReference = assertTSTypeReference; |
| exports.assertTSTypePredicate = assertTSTypePredicate; |
| exports.assertTSTypeQuery = assertTSTypeQuery; |
| exports.assertTSTypeLiteral = assertTSTypeLiteral; |
| exports.assertTSArrayType = assertTSArrayType; |
| exports.assertTSTupleType = assertTSTupleType; |
| exports.assertTSOptionalType = assertTSOptionalType; |
| exports.assertTSRestType = assertTSRestType; |
| exports.assertTSUnionType = assertTSUnionType; |
| exports.assertTSIntersectionType = assertTSIntersectionType; |
| exports.assertTSConditionalType = assertTSConditionalType; |
| exports.assertTSInferType = assertTSInferType; |
| exports.assertTSParenthesizedType = assertTSParenthesizedType; |
| exports.assertTSTypeOperator = assertTSTypeOperator; |
| exports.assertTSIndexedAccessType = assertTSIndexedAccessType; |
| exports.assertTSMappedType = assertTSMappedType; |
| exports.assertTSLiteralType = assertTSLiteralType; |
| exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments; |
| exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration; |
| exports.assertTSInterfaceBody = assertTSInterfaceBody; |
| exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration; |
| exports.assertTSAsExpression = assertTSAsExpression; |
| exports.assertTSTypeAssertion = assertTSTypeAssertion; |
| exports.assertTSEnumDeclaration = assertTSEnumDeclaration; |
| exports.assertTSEnumMember = assertTSEnumMember; |
| exports.assertTSModuleDeclaration = assertTSModuleDeclaration; |
| exports.assertTSModuleBlock = assertTSModuleBlock; |
| exports.assertTSImportType = assertTSImportType; |
| exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration; |
| exports.assertTSExternalModuleReference = assertTSExternalModuleReference; |
| exports.assertTSNonNullExpression = assertTSNonNullExpression; |
| exports.assertTSExportAssignment = assertTSExportAssignment; |
| exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration; |
| exports.assertTSTypeAnnotation = assertTSTypeAnnotation; |
| exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation; |
| exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration; |
| exports.assertTSTypeParameter = assertTSTypeParameter; |
| exports.assertExpression = assertExpression; |
| exports.assertBinary = assertBinary; |
| exports.assertScopable = assertScopable; |
| exports.assertBlockParent = assertBlockParent; |
| exports.assertBlock = assertBlock; |
| exports.assertStatement = assertStatement; |
| exports.assertTerminatorless = assertTerminatorless; |
| exports.assertCompletionStatement = assertCompletionStatement; |
| exports.assertConditional = assertConditional; |
| exports.assertLoop = assertLoop; |
| exports.assertWhile = assertWhile; |
| exports.assertExpressionWrapper = assertExpressionWrapper; |
| exports.assertFor = assertFor; |
| exports.assertForXStatement = assertForXStatement; |
| exports.assertFunction = assertFunction; |
| exports.assertFunctionParent = assertFunctionParent; |
| exports.assertPureish = assertPureish; |
| exports.assertDeclaration = assertDeclaration; |
| exports.assertPatternLike = assertPatternLike; |
| exports.assertLVal = assertLVal; |
| exports.assertTSEntityName = assertTSEntityName; |
| exports.assertLiteral = assertLiteral; |
| exports.assertImmutable = assertImmutable; |
| exports.assertUserWhitespacable = assertUserWhitespacable; |
| exports.assertMethod = assertMethod; |
| exports.assertObjectMember = assertObjectMember; |
| exports.assertProperty = assertProperty; |
| exports.assertUnaryLike = assertUnaryLike; |
| exports.assertPattern = assertPattern; |
| exports.assertClass = assertClass; |
| exports.assertModuleDeclaration = assertModuleDeclaration; |
| exports.assertExportDeclaration = assertExportDeclaration; |
| exports.assertModuleSpecifier = assertModuleSpecifier; |
| exports.assertFlow = assertFlow; |
| exports.assertFlowType = assertFlowType; |
| exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation; |
| exports.assertFlowDeclaration = assertFlowDeclaration; |
| exports.assertFlowPredicate = assertFlowPredicate; |
| exports.assertJSX = assertJSX; |
| exports.assertPrivate = assertPrivate; |
| exports.assertTSTypeElement = assertTSTypeElement; |
| exports.assertTSType = assertTSType; |
| exports.assertNumberLiteral = assertNumberLiteral; |
| exports.assertRegexLiteral = assertRegexLiteral; |
| exports.assertRestProperty = assertRestProperty; |
| exports.assertSpreadProperty = assertSpreadProperty; |
| |
| var _is = _interopRequireDefault(require("../../validators/is")); |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| function assert(type, node, opts) { |
| if (!(0, _is.default)(type, node, opts)) { |
| throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, ` + `but instead got "${node.type}".`); |
| } |
| } |
| |
| function assertArrayExpression(node, opts = {}) { |
| assert("ArrayExpression", node, opts); |
| } |
| |
| function assertAssignmentExpression(node, opts = {}) { |
| assert("AssignmentExpression", node, opts); |
| } |
| |
| function assertBinaryExpression(node, opts = {}) { |
| assert("BinaryExpression", node, opts); |
| } |
| |
| function assertInterpreterDirective(node, opts = {}) { |
| assert("InterpreterDirective", node, opts); |
| } |
| |
| function assertDirective(node, opts = {}) { |
| assert("Directive", node, opts); |
| } |
| |
| function assertDirectiveLiteral(node, opts = {}) { |
| assert("DirectiveLiteral", node, opts); |
| } |
| |
| function assertBlockStatement(node, opts = {}) { |
| assert("BlockStatement", node, opts); |
| } |
| |
| function assertBreakStatement(node, opts = {}) { |
| assert("BreakStatement", node, opts); |
| } |
| |
| function assertCallExpression(node, opts = {}) { |
| assert("CallExpression", node, opts); |
| } |
| |
| function assertCatchClause(node, opts = {}) { |
| assert("CatchClause", node, opts); |
| } |
| |
| function assertConditionalExpression(node, opts = {}) { |
| assert("ConditionalExpression", node, opts); |
| } |
| |
| function assertContinueStatement(node, opts = {}) { |
| assert("ContinueStatement", node, opts); |
| } |
| |
| function assertDebuggerStatement(node, opts = {}) { |
| assert("DebuggerStatement", node, opts); |
| } |
| |
| function assertDoWhileStatement(node, opts = {}) { |
| assert("DoWhileStatement", node, opts); |
| } |
| |
| function assertEmptyStatement(node, opts = {}) { |
| assert("EmptyStatement", node, opts); |
| } |
| |
| function assertExpressionStatement(node, opts = {}) { |
| assert("ExpressionStatement", node, opts); |
| } |
| |
| function assertFile(node, opts = {}) { |
| assert("File", node, opts); |
| } |
| |
| function assertForInStatement(node, opts = {}) { |
| assert("ForInStatement", node, opts); |
| } |
| |
| function assertForStatement(node, opts = {}) { |
| assert("ForStatement", node, opts); |
| } |
| |
| function assertFunctionDeclaration(node, opts = {}) { |
| assert("FunctionDeclaration", node, opts); |
| } |
| |
| function assertFunctionExpression(node, opts = {}) { |
| assert("FunctionExpression", node, opts); |
| } |
| |
| function assertIdentifier(node, opts = {}) { |
| assert("Identifier", node, opts); |
| } |
| |
| function assertIfStatement(node, opts = {}) { |
| assert("IfStatement", node, opts); |
| } |
| |
| function assertLabeledStatement(node, opts = {}) { |
| assert("LabeledStatement", node, opts); |
| } |
| |
| function assertStringLiteral(node, opts = {}) { |
| assert("StringLiteral", node, opts); |
| } |
| |
| function assertNumericLiteral(node, opts = {}) { |
| assert("NumericLiteral", node, opts); |
| } |
| |
| function assertNullLiteral(node, opts = {}) { |
| assert("NullLiteral", node, opts); |
| } |
| |
| function assertBooleanLiteral(node, opts = {}) { |
| assert("BooleanLiteral", node, opts); |
| } |
| |
| function assertRegExpLiteral(node, opts = {}) { |
| assert("RegExpLiteral", node, opts); |
| } |
| |
| function assertLogicalExpression(node, opts = {}) { |
| assert("LogicalExpression", node, opts); |
| } |
| |
| function assertMemberExpression(node, opts = {}) { |
| assert("MemberExpression", node, opts); |
| } |
| |
| function assertNewExpression(node, opts = {}) { |
| assert("NewExpression", node, opts); |
| } |
| |
| function assertProgram(node, opts = {}) { |
| assert("Program", node, opts); |
| } |
| |
| function assertObjectExpression(node, opts = {}) { |
| assert("ObjectExpression", node, opts); |
| } |
| |
| function assertObjectMethod(node, opts = {}) { |
| assert("ObjectMethod", node, opts); |
| } |
| |
| function assertObjectProperty(node, opts = {}) { |
| assert("ObjectProperty", node, opts); |
| } |
| |
| function assertRestElement(node, opts = {}) { |
| assert("RestElement", node, opts); |
| } |
| |
| function assertReturnStatement(node, opts = {}) { |
| assert("ReturnStatement", node, opts); |
| } |
| |
| function assertSequenceExpression(node, opts = {}) { |
| assert("SequenceExpression", node, opts); |
| } |
| |
| function assertParenthesizedExpression(node, opts = {}) { |
| assert("ParenthesizedExpression", node, opts); |
| } |
| |
| function assertSwitchCase(node, opts = {}) { |
| assert("SwitchCase", node, opts); |
| } |
| |
| function assertSwitchStatement(node, opts = {}) { |
| assert("SwitchStatement", node, opts); |
| } |
| |
| function assertThisExpression(node, opts = {}) { |
| assert("ThisExpression", node, opts); |
| } |
| |
| function assertThrowStatement(node, opts = {}) { |
| assert("ThrowStatement", node, opts); |
| } |
| |
| function assertTryStatement(node, opts = {}) { |
| assert("TryStatement", node, opts); |
| } |
| |
| function assertUnaryExpression(node, opts = {}) { |
| assert("UnaryExpression", node, opts); |
| } |
| |
| function assertUpdateExpression(node, opts = {}) { |
| assert("UpdateExpression", node, opts); |
| } |
| |
| function assertVariableDeclaration(node, opts = {}) { |
| assert("VariableDeclaration", node, opts); |
| } |
| |
| function assertVariableDeclarator(node, opts = {}) { |
| assert("VariableDeclarator", node, opts); |
| } |
| |
| function assertWhileStatement(node, opts = {}) { |
| assert("WhileStatement", node, opts); |
| } |
| |
| function assertWithStatement(node, opts = {}) { |
| assert("WithStatement", node, opts); |
| } |
| |
| function assertAssignmentPattern(node, opts = {}) { |
| assert("AssignmentPattern", node, opts); |
| } |
| |
| function assertArrayPattern(node, opts = {}) { |
| assert("ArrayPattern", node, opts); |
| } |
| |
| function assertArrowFunctionExpression(node, opts = {}) { |
| assert("ArrowFunctionExpression", node, opts); |
| } |
| |
| function assertClassBody(node, opts = {}) { |
| assert("ClassBody", node, opts); |
| } |
| |
| function assertClassDeclaration(node, opts = {}) { |
| assert("ClassDeclaration", node, opts); |
| } |
| |
| function assertClassExpression(node, opts = {}) { |
| assert("ClassExpression", node, opts); |
| } |
| |
| function assertExportAllDeclaration(node, opts = {}) { |
| assert("ExportAllDeclaration", node, opts); |
| } |
| |
| function assertExportDefaultDeclaration(node, opts = {}) { |
| assert("ExportDefaultDeclaration", node, opts); |
| } |
| |
| function assertExportNamedDeclaration(node, opts = {}) { |
| assert("ExportNamedDeclaration", node, opts); |
| } |
| |
| function assertExportSpecifier(node, opts = {}) { |
| assert("ExportSpecifier", node, opts); |
| } |
| |
| function assertForOfStatement(node, opts = {}) { |
| assert("ForOfStatement", node, opts); |
| } |
| |
| function assertImportDeclaration(node, opts = {}) { |
| assert("ImportDeclaration", node, opts); |
| } |
| |
| function assertImportDefaultSpecifier(node, opts = {}) { |
| assert("ImportDefaultSpecifier", node, opts); |
| } |
| |
| function assertImportNamespaceSpecifier(node, opts = {}) { |
| assert("ImportNamespaceSpecifier", node, opts); |
| } |
| |
| function assertImportSpecifier(node, opts = {}) { |
| assert("ImportSpecifier", node, opts); |
| } |
| |
| function assertMetaProperty(node, opts = {}) { |
| assert("MetaProperty", node, opts); |
| } |
| |
| function assertClassMethod(node, opts = {}) { |
| assert("ClassMethod", node, opts); |
| } |
| |
| function assertObjectPattern(node, opts = {}) { |
| assert("ObjectPattern", node, opts); |
| } |
| |
| function assertSpreadElement(node, opts = {}) { |
| assert("SpreadElement", node, opts); |
| } |
| |
| function assertSuper(node, opts = {}) { |
| assert("Super", node, opts); |
| } |
| |
| function assertTaggedTemplateExpression(node, opts = {}) { |
| assert("TaggedTemplateExpression", node, opts); |
| } |
| |
| function assertTemplateElement(node, opts = {}) { |
| assert("TemplateElement", node, opts); |
| } |
| |
| function assertTemplateLiteral(node, opts = {}) { |
| assert("TemplateLiteral", node, opts); |
| } |
| |
| function assertYieldExpression(node, opts = {}) { |
| assert("YieldExpression", node, opts); |
| } |
| |
| function assertAnyTypeAnnotation(node, opts = {}) { |
| assert("AnyTypeAnnotation", node, opts); |
| } |
| |
| function assertArrayTypeAnnotation(node, opts = {}) { |
| assert("ArrayTypeAnnotation", node, opts); |
| } |
| |
| function assertBooleanTypeAnnotation(node, opts = {}) { |
| assert("BooleanTypeAnnotation", node, opts); |
| } |
| |
| function assertBooleanLiteralTypeAnnotation(node, opts = {}) { |
| assert("BooleanLiteralTypeAnnotation", node, opts); |
| } |
| |
| function assertNullLiteralTypeAnnotation(node, opts = {}) { |
| assert("NullLiteralTypeAnnotation", node, opts); |
| } |
| |
| function assertClassImplements(node, opts = {}) { |
| assert("ClassImplements", node, opts); |
| } |
| |
| function assertDeclareClass(node, opts = {}) { |
| assert("DeclareClass", node, opts); |
| } |
| |
| function assertDeclareFunction(node, opts = {}) { |
| assert("DeclareFunction", node, opts); |
| } |
| |
| function assertDeclareInterface(node, opts = {}) { |
| assert("DeclareInterface", node, opts); |
| } |
| |
| function assertDeclareModule(node, opts = {}) { |
| assert("DeclareModule", node, opts); |
| } |
| |
| function assertDeclareModuleExports(node, opts = {}) { |
| assert("DeclareModuleExports", node, opts); |
| } |
| |
| function assertDeclareTypeAlias(node, opts = {}) { |
| assert("DeclareTypeAlias", node, opts); |
| } |
| |
| function assertDeclareOpaqueType(node, opts = {}) { |
| assert("DeclareOpaqueType", node, opts); |
| } |
| |
| function assertDeclareVariable(node, opts = {}) { |
| assert("DeclareVariable", node, opts); |
| } |
| |
| function assertDeclareExportDeclaration(node, opts = {}) { |
| assert("DeclareExportDeclaration", node, opts); |
| } |
| |
| function assertDeclareExportAllDeclaration(node, opts = {}) { |
| assert("DeclareExportAllDeclaration", node, opts); |
| } |
| |
| function assertDeclaredPredicate(node, opts = {}) { |
| assert("DeclaredPredicate", node, opts); |
| } |
| |
| function assertExistsTypeAnnotation(node, opts = {}) { |
| assert("ExistsTypeAnnotation", node, opts); |
| } |
| |
| function assertFunctionTypeAnnotation(node, opts = {}) { |
| assert("FunctionTypeAnnotation", node, opts); |
| } |
| |
| function assertFunctionTypeParam(node, opts = {}) { |
| assert("FunctionTypeParam", node, opts); |
| } |
| |
| function assertGenericTypeAnnotation(node, opts = {}) { |
| assert("GenericTypeAnnotation", node, opts); |
| } |
| |
| function assertInferredPredicate(node, opts = {}) { |
| assert("InferredPredicate", node, opts); |
| } |
| |
| function assertInterfaceExtends(node, opts = {}) { |
| assert("InterfaceExtends", node, opts); |
| } |
| |
| function assertInterfaceDeclaration(node, opts = {}) { |
| assert("InterfaceDeclaration", node, opts); |
| } |
| |
| function assertInterfaceTypeAnnotation(node, opts = {}) { |
| assert("InterfaceTypeAnnotation", node, opts); |
| } |
| |
| function assertIntersectionTypeAnnotation(node, opts = {}) { |
| assert("IntersectionTypeAnnotation", node, opts); |
| } |
| |
| function assertMixedTypeAnnotation(node, opts = {}) { |
| assert("MixedTypeAnnotation", node, opts); |
| } |
| |
| function assertEmptyTypeAnnotation(node, opts = {}) { |
| assert("EmptyTypeAnnotation", node, opts); |
| } |
| |
| function assertNullableTypeAnnotation(node, opts = {}) { |
| assert("NullableTypeAnnotation", node, opts); |
| } |
| |
| function assertNumberLiteralTypeAnnotation(node, opts = {}) { |
| assert("NumberLiteralTypeAnnotation", node, opts); |
| } |
| |
| function assertNumberTypeAnnotation(node, opts = {}) { |
| assert("NumberTypeAnnotation", node, opts); |
| } |
| |
| function assertObjectTypeAnnotation(node, opts = {}) { |
| assert("ObjectTypeAnnotation", node, opts); |
| } |
| |
| function assertObjectTypeInternalSlot(node, opts = {}) { |
| assert("ObjectTypeInternalSlot", node, opts); |
| } |
| |
| function assertObjectTypeCallProperty(node, opts = {}) { |
| assert("ObjectTypeCallProperty", node, opts); |
| } |
| |
| function assertObjectTypeIndexer(node, opts = {}) { |
| assert("ObjectTypeIndexer", node, opts); |
| } |
| |
| function assertObjectTypeProperty(node, opts = {}) { |
| assert("ObjectTypeProperty", node, opts); |
| } |
| |
| function assertObjectTypeSpreadProperty(node, opts = {}) { |
| assert("ObjectTypeSpreadProperty", node, opts); |
| } |
| |
| function assertOpaqueType(node, opts = {}) { |
| assert("OpaqueType", node, opts); |
| } |
| |
| function assertQualifiedTypeIdentifier(node, opts = {}) { |
| assert("QualifiedTypeIdentifier", node, opts); |
| } |
| |
| function assertStringLiteralTypeAnnotation(node, opts = {}) { |
| assert("StringLiteralTypeAnnotation", node, opts); |
| } |
| |
| function assertStringTypeAnnotation(node, opts = {}) { |
| assert("StringTypeAnnotation", node, opts); |
| } |
| |
| function assertThisTypeAnnotation(node, opts = {}) { |
| assert("ThisTypeAnnotation", node, opts); |
| } |
| |
| function assertTupleTypeAnnotation(node, opts = {}) { |
| assert("TupleTypeAnnotation", node, opts); |
| } |
| |
| function assertTypeofTypeAnnotation(node, opts = {}) { |
| assert("TypeofTypeAnnotation", node, opts); |
| } |
| |
| function assertTypeAlias(node, opts = {}) { |
| assert("TypeAlias", node, opts); |
| } |
| |
| function assertTypeAnnotation(node, opts = {}) { |
| assert("TypeAnnotation", node, opts); |
| } |
| |
| function assertTypeCastExpression(node, opts = {}) { |
| assert("TypeCastExpression", node, opts); |
| } |
| |
| function assertTypeParameter(node, opts = {}) { |
| assert("TypeParameter", node, opts); |
| } |
| |
| function assertTypeParameterDeclaration(node, opts = {}) { |
| assert("TypeParameterDeclaration", node, opts); |
| } |
| |
| function assertTypeParameterInstantiation(node, opts = {}) { |
| assert("TypeParameterInstantiation", node, opts); |
| } |
| |
| function assertUnionTypeAnnotation(node, opts = {}) { |
| assert("UnionTypeAnnotation", node, opts); |
| } |
| |
| function assertVariance(node, opts = {}) { |
| assert("Variance", node, opts); |
| } |
| |
| function assertVoidTypeAnnotation(node, opts = {}) { |
| assert("VoidTypeAnnotation", node, opts); |
| } |
| |
| function assertJSXAttribute(node, opts = {}) { |
| assert("JSXAttribute", node, opts); |
| } |
| |
| function assertJSXClosingElement(node, opts = {}) { |
| assert("JSXClosingElement", node, opts); |
| } |
| |
| function assertJSXElement(node, opts = {}) { |
| assert("JSXElement", node, opts); |
| } |
| |
| function assertJSXEmptyExpression(node, opts = {}) { |
| assert("JSXEmptyExpression", node, opts); |
| } |
| |
| function assertJSXExpressionContainer(node, opts = {}) { |
| assert("JSXExpressionContainer", node, opts); |
| } |
| |
| function assertJSXSpreadChild(node, opts = {}) { |
| assert("JSXSpreadChild", node, opts); |
| } |
| |
| function assertJSXIdentifier(node, opts = {}) { |
| assert("JSXIdentifier", node, opts); |
| } |
| |
| function assertJSXMemberExpression(node, opts = {}) { |
| assert("JSXMemberExpression", node, opts); |
| } |
| |
| function assertJSXNamespacedName(node, opts = {}) { |
| assert("JSXNamespacedName", node, opts); |
| } |
| |
| function assertJSXOpeningElement(node, opts = {}) { |
| assert("JSXOpeningElement", node, opts); |
| } |
| |
| function assertJSXSpreadAttribute(node, opts = {}) { |
| assert("JSXSpreadAttribute", node, opts); |
| } |
| |
| function assertJSXText(node, opts = {}) { |
| assert("JSXText", node, opts); |
| } |
| |
| function assertJSXFragment(node, opts = {}) { |
| assert("JSXFragment", node, opts); |
| } |
| |
| function assertJSXOpeningFragment(node, opts = {}) { |
| assert("JSXOpeningFragment", node, opts); |
| } |
| |
| function assertJSXClosingFragment(node, opts = {}) { |
| assert("JSXClosingFragment", node, opts); |
| } |
| |
| function assertNoop(node, opts = {}) { |
| assert("Noop", node, opts); |
| } |
| |
| function assertPlaceholder(node, opts = {}) { |
| assert("Placeholder", node, opts); |
| } |
| |
| function assertV8IntrinsicIdentifier(node, opts = {}) { |
| assert("V8IntrinsicIdentifier", node, opts); |
| } |
| |
| function assertArgumentPlaceholder(node, opts = {}) { |
| assert("ArgumentPlaceholder", node, opts); |
| } |
| |
| function assertAwaitExpression(node, opts = {}) { |
| assert("AwaitExpression", node, opts); |
| } |
| |
| function assertBindExpression(node, opts = {}) { |
| assert("BindExpression", node, opts); |
| } |
| |
| function assertClassProperty(node, opts = {}) { |
| assert("ClassProperty", node, opts); |
| } |
| |
| function assertOptionalMemberExpression(node, opts = {}) { |
| assert("OptionalMemberExpression", node, opts); |
| } |
| |
| function assertPipelineTopicExpression(node, opts = {}) { |
| assert("PipelineTopicExpression", node, opts); |
| } |
| |
| function assertPipelineBareFunction(node, opts = {}) { |
| assert("PipelineBareFunction", node, opts); |
| } |
| |
| function assertPipelinePrimaryTopicReference(node, opts = {}) { |
| assert("PipelinePrimaryTopicReference", node, opts); |
| } |
| |
| function assertOptionalCallExpression(node, opts = {}) { |
| assert("OptionalCallExpression", node, opts); |
| } |
| |
| function assertClassPrivateProperty(node, opts = {}) { |
| assert("ClassPrivateProperty", node, opts); |
| } |
| |
| function assertClassPrivateMethod(node, opts = {}) { |
| assert("ClassPrivateMethod", node, opts); |
| } |
| |
| function assertImport(node, opts = {}) { |
| assert("Import", node, opts); |
| } |
| |
| function assertDecorator(node, opts = {}) { |
| assert("Decorator", node, opts); |
| } |
| |
| function assertDoExpression(node, opts = {}) { |
| assert("DoExpression", node, opts); |
| } |
| |
| function assertExportDefaultSpecifier(node, opts = {}) { |
| assert("ExportDefaultSpecifier", node, opts); |
| } |
| |
| function assertExportNamespaceSpecifier(node, opts = {}) { |
| assert("ExportNamespaceSpecifier", node, opts); |
| } |
| |
| function assertPrivateName(node, opts = {}) { |
| assert("PrivateName", node, opts); |
| } |
| |
| function assertBigIntLiteral(node, opts = {}) { |
| assert("BigIntLiteral", node, opts); |
| } |
| |
| function assertTSParameterProperty(node, opts = {}) { |
| assert("TSParameterProperty", node, opts); |
| } |
| |
| function assertTSDeclareFunction(node, opts = {}) { |
| assert("TSDeclareFunction", node, opts); |
| } |
| |
| function assertTSDeclareMethod(node, opts = {}) { |
| assert("TSDeclareMethod", node, opts); |
| } |
| |
| function assertTSQualifiedName(node, opts = {}) { |
| assert("TSQualifiedName", node, opts); |
| } |
| |
| function assertTSCallSignatureDeclaration(node, opts = {}) { |
| assert("TSCallSignatureDeclaration", node, opts); |
| } |
| |
| function assertTSConstructSignatureDeclaration(node, opts = {}) { |
| assert("TSConstructSignatureDeclaration", node, opts); |
| } |
| |
| function assertTSPropertySignature(node, opts = {}) { |
| assert("TSPropertySignature", node, opts); |
| } |
| |
| function assertTSMethodSignature(node, opts = {}) { |
| assert("TSMethodSignature", node, opts); |
| } |
| |
| function assertTSIndexSignature(node, opts = {}) { |
| assert("TSIndexSignature", node, opts); |
| } |
| |
| function assertTSAnyKeyword(node, opts = {}) { |
| assert("TSAnyKeyword", node, opts); |
| } |
| |
| function assertTSBooleanKeyword(node, opts = {}) { |
| assert("TSBooleanKeyword", node, opts); |
| } |
| |
| function assertTSBigIntKeyword(node, opts = {}) { |
| assert("TSBigIntKeyword", node, opts); |
| } |
| |
| function assertTSNeverKeyword(node, opts = {}) { |
| assert("TSNeverKeyword", node, opts); |
| } |
| |
| function assertTSNullKeyword(node, opts = {}) { |
| assert("TSNullKeyword", node, opts); |
| } |
| |
| function assertTSNumberKeyword(node, opts = {}) { |
| assert("TSNumberKeyword", node, opts); |
| } |
| |
| function assertTSObjectKeyword(node, opts = {}) { |
| assert("TSObjectKeyword", node, opts); |
| } |
| |
| function assertTSStringKeyword(node, opts = {}) { |
| assert("TSStringKeyword", node, opts); |
| } |
| |
| function assertTSSymbolKeyword(node, opts = {}) { |
| assert("TSSymbolKeyword", node, opts); |
| } |
| |
| function assertTSUndefinedKeyword(node, opts = {}) { |
| assert("TSUndefinedKeyword", node, opts); |
| } |
| |
| function assertTSUnknownKeyword(node, opts = {}) { |
| assert("TSUnknownKeyword", node, opts); |
| } |
| |
| function assertTSVoidKeyword(node, opts = {}) { |
| assert("TSVoidKeyword", node, opts); |
| } |
| |
| function assertTSThisType(node, opts = {}) { |
| assert("TSThisType", node, opts); |
| } |
| |
| function assertTSFunctionType(node, opts = {}) { |
| assert("TSFunctionType", node, opts); |
| } |
| |
| function assertTSConstructorType(node, opts = {}) { |
| assert("TSConstructorType", node, opts); |
| } |
| |
| function assertTSTypeReference(node, opts = {}) { |
| assert("TSTypeReference", node, opts); |
| } |
| |
| function assertTSTypePredicate(node, opts = {}) { |
| assert("TSTypePredicate", node, opts); |
| } |
| |
| function assertTSTypeQuery(node, opts = {}) { |
| assert("TSTypeQuery", node, opts); |
| } |
| |
| function assertTSTypeLiteral(node, opts = {}) { |
| assert("TSTypeLiteral", node, opts); |
| } |
| |
| function assertTSArrayType(node, opts = {}) { |
| assert("TSArrayType", node, opts); |
| } |
| |
| function assertTSTupleType(node, opts = {}) { |
| assert("TSTupleType", node, opts); |
| } |
| |
| function assertTSOptionalType(node, opts = {}) { |
| assert("TSOptionalType", node, opts); |
| } |
| |
| function assertTSRestType(node, opts = {}) { |
| assert("TSRestType", node, opts); |
| } |
| |
| function assertTSUnionType(node, opts = {}) { |
| assert("TSUnionType", node, opts); |
| } |
| |
| function assertTSIntersectionType(node, opts = {}) { |
| assert("TSIntersectionType", node, opts); |
| } |
| |
| function assertTSConditionalType(node, opts = {}) { |
| assert("TSConditionalType", node, opts); |
| } |
| |
| function assertTSInferType(node, opts = {}) { |
| assert("TSInferType", node, opts); |
| } |
| |
| function assertTSParenthesizedType(node, opts = {}) { |
| assert("TSParenthesizedType", node, opts); |
| } |
| |
| function assertTSTypeOperator(node, opts = {}) { |
| assert("TSTypeOperator", node, opts); |
| } |
| |
| function assertTSIndexedAccessType(node, opts = {}) { |
| assert("TSIndexedAccessType", node, opts); |
| } |
| |
| function assertTSMappedType(node, opts = {}) { |
| assert("TSMappedType", node, opts); |
| } |
| |
| function assertTSLiteralType(node, opts = {}) { |
| assert("TSLiteralType", node, opts); |
| } |
| |
| function assertTSExpressionWithTypeArguments(node, opts = {}) { |
| assert("TSExpressionWithTypeArguments", node, opts); |
| } |
| |
| function assertTSInterfaceDeclaration(node, opts = {}) { |
| assert("TSInterfaceDeclaration", node, opts); |
| } |
| |
| function assertTSInterfaceBody(node, opts = {}) { |
| assert("TSInterfaceBody", node, opts); |
| } |
| |
| function assertTSTypeAliasDeclaration(node, opts = {}) { |
| assert("TSTypeAliasDeclaration", node, opts); |
| } |
| |
| function assertTSAsExpression(node, opts = {}) { |
| assert("TSAsExpression", node, opts); |
| } |
| |
| function assertTSTypeAssertion(node, opts = {}) { |
| assert("TSTypeAssertion", node, opts); |
| } |
| |
| function assertTSEnumDeclaration(node, opts = {}) { |
| assert("TSEnumDeclaration", node, opts); |
| } |
| |
| function assertTSEnumMember(node, opts = {}) { |
| assert("TSEnumMember", node, opts); |
| } |
| |
| function assertTSModuleDeclaration(node, opts = {}) { |
| assert("TSModuleDeclaration", node, opts); |
| } |
| |
| function assertTSModuleBlock(node, opts = {}) { |
| assert("TSModuleBlock", node, opts); |
| } |
| |
| function assertTSImportType(node, opts = {}) { |
| assert("TSImportType", node, opts); |
| } |
| |
| function assertTSImportEqualsDeclaration(node, opts = {}) { |
| assert("TSImportEqualsDeclaration", node, opts); |
| } |
| |
| function assertTSExternalModuleReference(node, opts = {}) { |
| assert("TSExternalModuleReference", node, opts); |
| } |
| |
| function assertTSNonNullExpression(node, opts = {}) { |
| assert("TSNonNullExpression", node, opts); |
| } |
| |
| function assertTSExportAssignment(node, opts = {}) { |
| assert("TSExportAssignment", node, opts); |
| } |
| |
| function assertTSNamespaceExportDeclaration(node, opts = {}) { |
| assert("TSNamespaceExportDeclaration", node, opts); |
| } |
| |
| function assertTSTypeAnnotation(node, opts = {}) { |
| assert("TSTypeAnnotation", node, opts); |
| } |
| |
| function assertTSTypeParameterInstantiation(node, opts = {}) { |
| assert("TSTypeParameterInstantiation", node, opts); |
| } |
| |
| function assertTSTypeParameterDeclaration(node, opts = {}) { |
| assert("TSTypeParameterDeclaration", node, opts); |
| } |
| |
| function assertTSTypeParameter(node, opts = {}) { |
| assert("TSTypeParameter", node, opts); |
| } |
| |
| function assertExpression(node, opts = {}) { |
| assert("Expression", node, opts); |
| } |
| |
| function assertBinary(node, opts = {}) { |
| assert("Binary", node, opts); |
| } |
| |
| function assertScopable(node, opts = {}) { |
| assert("Scopable", node, opts); |
| } |
| |
| function assertBlockParent(node, opts = {}) { |
| assert("BlockParent", node, opts); |
| } |
| |
| function assertBlock(node, opts = {}) { |
| assert("Block", node, opts); |
| } |
| |
| function assertStatement(node, opts = {}) { |
| assert("Statement", node, opts); |
| } |
| |
| function assertTerminatorless(node, opts = {}) { |
| assert("Terminatorless", node, opts); |
| } |
| |
| function assertCompletionStatement(node, opts = {}) { |
| assert("CompletionStatement", node, opts); |
| } |
| |
| function assertConditional(node, opts = {}) { |
| assert("Conditional", node, opts); |
| } |
| |
| function assertLoop(node, opts = {}) { |
| assert("Loop", node, opts); |
| } |
| |
| function assertWhile(node, opts = {}) { |
| assert("While", node, opts); |
| } |
| |
| function assertExpressionWrapper(node, opts = {}) { |
| assert("ExpressionWrapper", node, opts); |
| } |
| |
| function assertFor(node, opts = {}) { |
| assert("For", node, opts); |
| } |
| |
| function assertForXStatement(node, opts = {}) { |
| assert("ForXStatement", node, opts); |
| } |
| |
| function assertFunction(node, opts = {}) { |
| assert("Function", node, opts); |
| } |
| |
| function assertFunctionParent(node, opts = {}) { |
| assert("FunctionParent", node, opts); |
| } |
| |
| function assertPureish(node, opts = {}) { |
| assert("Pureish", node, opts); |
| } |
| |
| function assertDeclaration(node, opts = {}) { |
| assert("Declaration", node, opts); |
| } |
| |
| function assertPatternLike(node, opts = {}) { |
| assert("PatternLike", node, opts); |
| } |
| |
| function assertLVal(node, opts = {}) { |
| assert("LVal", node, opts); |
| } |
| |
| function assertTSEntityName(node, opts = {}) { |
| assert("TSEntityName", node, opts); |
| } |
| |
| function assertLiteral(node, opts = {}) { |
| assert("Literal", node, opts); |
| } |
| |
| function assertImmutable(node, opts = {}) { |
| assert("Immutable", node, opts); |
| } |
| |
| function assertUserWhitespacable(node, opts = {}) { |
| assert("UserWhitespacable", node, opts); |
| } |
| |
| function assertMethod(node, opts = {}) { |
| assert("Method", node, opts); |
| } |
| |
| function assertObjectMember(node, opts = {}) { |
| assert("ObjectMember", node, opts); |
| } |
| |
| function assertProperty(node, opts = {}) { |
| assert("Property", node, opts); |
| } |
| |
| function assertUnaryLike(node, opts = {}) { |
| assert("UnaryLike", node, opts); |
| } |
| |
| function assertPattern(node, opts = {}) { |
| assert("Pattern", node, opts); |
| } |
| |
| function assertClass(node, opts = {}) { |
| assert("Class", node, opts); |
| } |
| |
| function assertModuleDeclaration(node, opts = {}) { |
| assert("ModuleDeclaration", node, opts); |
| } |
| |
| function assertExportDeclaration(node, opts = {}) { |
| assert("ExportDeclaration", node, opts); |
| } |
| |
| function assertModuleSpecifier(node, opts = {}) { |
| assert("ModuleSpecifier", node, opts); |
| } |
| |
| function assertFlow(node, opts = {}) { |
| assert("Flow", node, opts); |
| } |
| |
| function assertFlowType(node, opts = {}) { |
| assert("FlowType", node, opts); |
| } |
| |
| function assertFlowBaseAnnotation(node, opts = {}) { |
| assert("FlowBaseAnnotation", node, opts); |
| } |
| |
| function assertFlowDeclaration(node, opts = {}) { |
| assert("FlowDeclaration", node, opts); |
| } |
| |
| function assertFlowPredicate(node, opts = {}) { |
| assert("FlowPredicate", node, opts); |
| } |
| |
| function assertJSX(node, opts = {}) { |
| assert("JSX", node, opts); |
| } |
| |
| function assertPrivate(node, opts = {}) { |
| assert("Private", node, opts); |
| } |
| |
| function assertTSTypeElement(node, opts = {}) { |
| assert("TSTypeElement", node, opts); |
| } |
| |
| function assertTSType(node, opts = {}) { |
| assert("TSType", node, opts); |
| } |
| |
| function assertNumberLiteral(node, opts) { |
| console.trace("The node type NumberLiteral has been renamed to NumericLiteral"); |
| assert("NumberLiteral", node, opts); |
| } |
| |
| function assertRegexLiteral(node, opts) { |
| console.trace("The node type RegexLiteral has been renamed to RegExpLiteral"); |
| assert("RegexLiteral", node, opts); |
| } |
| |
| function assertRestProperty(node, opts) { |
| console.trace("The node type RestProperty has been renamed to RestElement"); |
| assert("RestProperty", node, opts); |
| } |
| |
| function assertSpreadProperty(node, opts) { |
| console.trace("The node type SpreadProperty has been renamed to SpreadElement"); |
| assert("SpreadProperty", node, opts); |
| } |