Socket
Socket
Sign inDemoInstall

@babel/types

Package Overview
Dependencies
3
Maintainers
4
Versions
155
Alerts
File Explorer

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 7.21.4-esm.2 to 7.21.4-esm.3

12

lib/asserts/assertNode.js

@@ -1,4 +0,10 @@

import isNode from "../validators/isNode.js";
export default function assertNode(node) {
if (!isNode(node)) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = assertNode;
var _isNode = require("../validators/isNode");
function assertNode(node) {
if (!(0, _isNode.default)(node)) {
var _node$type;

@@ -5,0 +11,0 @@ const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);

@@ -1,920 +0,1228 @@

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

@@ -921,0 +1229,0 @@ }

@@ -1,9 +0,15 @@

import { unionTypeAnnotation } from "../generated/index.js";
import removeTypeDuplicates from "../../modifications/flow/removeTypeDuplicates.js";
export default function createFlowUnionType(types) {
const flattened = removeTypeDuplicates(types);
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createFlowUnionType;
var _generated = require("../generated");
var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates");
function createFlowUnionType(types) {
const flattened = (0, _removeTypeDuplicates.default)(types);
if (flattened.length === 1) {
return flattened[0];
} else {
return unionTypeAnnotation(flattened);
return (0, _generated.unionTypeAnnotation)(flattened);
}

@@ -10,0 +16,0 @@ }

@@ -1,21 +0,28 @@

import { anyTypeAnnotation, stringTypeAnnotation, numberTypeAnnotation, voidTypeAnnotation, booleanTypeAnnotation, genericTypeAnnotation, identifier } from "../generated/index.js";
export default createTypeAnnotationBasedOnTypeof;
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _generated = require("../generated");
var _default = createTypeAnnotationBasedOnTypeof;
exports.default = _default;
function createTypeAnnotationBasedOnTypeof(type) {
switch (type) {
case "string":
return stringTypeAnnotation();
return (0, _generated.stringTypeAnnotation)();
case "number":
return numberTypeAnnotation();
return (0, _generated.numberTypeAnnotation)();
case "undefined":
return voidTypeAnnotation();
return (0, _generated.voidTypeAnnotation)();
case "boolean":
return booleanTypeAnnotation();
return (0, _generated.booleanTypeAnnotation)();
case "function":
return genericTypeAnnotation(identifier("Function"));
return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function"));
case "object":
return genericTypeAnnotation(identifier("Object"));
return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object"));
case "symbol":
return genericTypeAnnotation(identifier("Symbol"));
return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol"));
case "bigint":
return anyTypeAnnotation();
return (0, _generated.anyTypeAnnotation)();
}

@@ -22,0 +29,0 @@ throw new Error("Invalid typeof value: " + type);

@@ -1,5 +0,263 @@

import validateNode from "../validateNode.js";
import deprecationWarning from "../../utils/deprecationWarning.js";
export function arrayExpression(elements = []) {
return validateNode({
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.anyTypeAnnotation = anyTypeAnnotation;
exports.argumentPlaceholder = argumentPlaceholder;
exports.arrayExpression = arrayExpression;
exports.arrayPattern = arrayPattern;
exports.arrayTypeAnnotation = arrayTypeAnnotation;
exports.arrowFunctionExpression = arrowFunctionExpression;
exports.assignmentExpression = assignmentExpression;
exports.assignmentPattern = assignmentPattern;
exports.awaitExpression = awaitExpression;
exports.bigIntLiteral = bigIntLiteral;
exports.binaryExpression = binaryExpression;
exports.bindExpression = bindExpression;
exports.blockStatement = blockStatement;
exports.booleanLiteral = booleanLiteral;
exports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation;
exports.booleanTypeAnnotation = booleanTypeAnnotation;
exports.breakStatement = breakStatement;
exports.callExpression = callExpression;
exports.catchClause = catchClause;
exports.classAccessorProperty = classAccessorProperty;
exports.classBody = classBody;
exports.classDeclaration = classDeclaration;
exports.classExpression = classExpression;
exports.classImplements = classImplements;
exports.classMethod = classMethod;
exports.classPrivateMethod = classPrivateMethod;
exports.classPrivateProperty = classPrivateProperty;
exports.classProperty = classProperty;
exports.conditionalExpression = conditionalExpression;
exports.continueStatement = continueStatement;
exports.debuggerStatement = debuggerStatement;
exports.decimalLiteral = decimalLiteral;
exports.declareClass = declareClass;
exports.declareExportAllDeclaration = declareExportAllDeclaration;
exports.declareExportDeclaration = declareExportDeclaration;
exports.declareFunction = declareFunction;
exports.declareInterface = declareInterface;
exports.declareModule = declareModule;
exports.declareModuleExports = declareModuleExports;
exports.declareOpaqueType = declareOpaqueType;
exports.declareTypeAlias = declareTypeAlias;
exports.declareVariable = declareVariable;
exports.declaredPredicate = declaredPredicate;
exports.decorator = decorator;
exports.directive = directive;
exports.directiveLiteral = directiveLiteral;
exports.doExpression = doExpression;
exports.doWhileStatement = doWhileStatement;
exports.emptyStatement = emptyStatement;
exports.emptyTypeAnnotation = emptyTypeAnnotation;
exports.enumBooleanBody = enumBooleanBody;
exports.enumBooleanMember = enumBooleanMember;
exports.enumDeclaration = enumDeclaration;
exports.enumDefaultedMember = enumDefaultedMember;
exports.enumNumberBody = enumNumberBody;
exports.enumNumberMember = enumNumberMember;
exports.enumStringBody = enumStringBody;
exports.enumStringMember = enumStringMember;
exports.enumSymbolBody = enumSymbolBody;
exports.existsTypeAnnotation = existsTypeAnnotation;
exports.exportAllDeclaration = exportAllDeclaration;
exports.exportDefaultDeclaration = exportDefaultDeclaration;
exports.exportDefaultSpecifier = exportDefaultSpecifier;
exports.exportNamedDeclaration = exportNamedDeclaration;
exports.exportNamespaceSpecifier = exportNamespaceSpecifier;
exports.exportSpecifier = exportSpecifier;
exports.expressionStatement = expressionStatement;
exports.file = file;
exports.forInStatement = forInStatement;
exports.forOfStatement = forOfStatement;
exports.forStatement = forStatement;
exports.functionDeclaration = functionDeclaration;
exports.functionExpression = functionExpression;
exports.functionTypeAnnotation = functionTypeAnnotation;
exports.functionTypeParam = functionTypeParam;
exports.genericTypeAnnotation = genericTypeAnnotation;
exports.identifier = identifier;
exports.ifStatement = ifStatement;
exports.import = _import;
exports.importAttribute = importAttribute;
exports.importDeclaration = importDeclaration;
exports.importDefaultSpecifier = importDefaultSpecifier;
exports.importNamespaceSpecifier = importNamespaceSpecifier;
exports.importSpecifier = importSpecifier;
exports.indexedAccessType = indexedAccessType;
exports.inferredPredicate = inferredPredicate;
exports.interfaceDeclaration = interfaceDeclaration;
exports.interfaceExtends = interfaceExtends;
exports.interfaceTypeAnnotation = interfaceTypeAnnotation;
exports.interpreterDirective = interpreterDirective;
exports.intersectionTypeAnnotation = intersectionTypeAnnotation;
exports.jSXAttribute = exports.jsxAttribute = jsxAttribute;
exports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement;
exports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment;
exports.jSXElement = exports.jsxElement = jsxElement;
exports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression;
exports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer;
exports.jSXFragment = exports.jsxFragment = jsxFragment;
exports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier;
exports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression;
exports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName;
exports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement;
exports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment;
exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute;
exports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild;
exports.jSXText = exports.jsxText = jsxText;
exports.labeledStatement = labeledStatement;
exports.logicalExpression = logicalExpression;
exports.memberExpression = memberExpression;
exports.metaProperty = metaProperty;
exports.mixedTypeAnnotation = mixedTypeAnnotation;
exports.moduleExpression = moduleExpression;
exports.newExpression = newExpression;
exports.noop = noop;
exports.nullLiteral = nullLiteral;
exports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation;
exports.nullableTypeAnnotation = nullableTypeAnnotation;
exports.numberLiteral = NumberLiteral;
exports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation;
exports.numberTypeAnnotation = numberTypeAnnotation;
exports.numericLiteral = numericLiteral;
exports.objectExpression = objectExpression;
exports.objectMethod = objectMethod;
exports.objectPattern = objectPattern;
exports.objectProperty = objectProperty;
exports.objectTypeAnnotation = objectTypeAnnotation;
exports.objectTypeCallProperty = objectTypeCallProperty;
exports.objectTypeIndexer = objectTypeIndexer;
exports.objectTypeInternalSlot = objectTypeInternalSlot;
exports.objectTypeProperty = objectTypeProperty;
exports.objectTypeSpreadProperty = objectTypeSpreadProperty;
exports.opaqueType = opaqueType;
exports.optionalCallExpression = optionalCallExpression;
exports.optionalIndexedAccessType = optionalIndexedAccessType;
exports.optionalMemberExpression = optionalMemberExpression;
exports.parenthesizedExpression = parenthesizedExpression;
exports.pipelineBareFunction = pipelineBareFunction;
exports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference;
exports.pipelineTopicExpression = pipelineTopicExpression;
exports.placeholder = placeholder;
exports.privateName = privateName;
exports.program = program;
exports.qualifiedTypeIdentifier = qualifiedTypeIdentifier;
exports.recordExpression = recordExpression;
exports.regExpLiteral = regExpLiteral;
exports.regexLiteral = RegexLiteral;
exports.restElement = restElement;
exports.restProperty = RestProperty;
exports.returnStatement = returnStatement;
exports.sequenceExpression = sequenceExpression;
exports.spreadElement = spreadElement;
exports.spreadProperty = SpreadProperty;
exports.staticBlock = staticBlock;
exports.stringLiteral = stringLiteral;
exports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation;
exports.stringTypeAnnotation = stringTypeAnnotation;
exports.super = _super;
exports.switchCase = switchCase;
exports.switchStatement = switchStatement;
exports.symbolTypeAnnotation = symbolTypeAnnotation;
exports.taggedTemplateExpression = taggedTemplateExpression;
exports.templateElement = templateElement;
exports.templateLiteral = templateLiteral;
exports.thisExpression = thisExpression;
exports.thisTypeAnnotation = thisTypeAnnotation;
exports.throwStatement = throwStatement;
exports.topicReference = topicReference;
exports.tryStatement = tryStatement;
exports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword;
exports.tSArrayType = exports.tsArrayType = tsArrayType;
exports.tSAsExpression = exports.tsAsExpression = tsAsExpression;
exports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword;
exports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword;
exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration;
exports.tSConditionalType = exports.tsConditionalType = tsConditionalType;
exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration;
exports.tSConstructorType = exports.tsConstructorType = tsConstructorType;
exports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction;
exports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod;
exports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration;
exports.tSEnumMember = exports.tsEnumMember = tsEnumMember;
exports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment;
exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments;
exports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference;
exports.tSFunctionType = exports.tsFunctionType = tsFunctionType;
exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration;
exports.tSImportType = exports.tsImportType = tsImportType;
exports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature;
exports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType;
exports.tSInferType = exports.tsInferType = tsInferType;
exports.tSInstantiationExpression = exports.tsInstantiationExpression = tsInstantiationExpression;
exports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody;
exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration;
exports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType;
exports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword;
exports.tSLiteralType = exports.tsLiteralType = tsLiteralType;
exports.tSMappedType = exports.tsMappedType = tsMappedType;
exports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature;
exports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock;
exports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration;
exports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember;
exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration;
exports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword;
exports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression;
exports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword;
exports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword;
exports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword;
exports.tSOptionalType = exports.tsOptionalType = tsOptionalType;
exports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty;
exports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType;
exports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature;
exports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName;
exports.tSRestType = exports.tsRestType = tsRestType;
exports.tSSatisfiesExpression = exports.tsSatisfiesExpression = tsSatisfiesExpression;
exports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword;
exports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword;
exports.tSThisType = exports.tsThisType = tsThisType;
exports.tSTupleType = exports.tsTupleType = tsTupleType;
exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration;
exports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation;
exports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion;
exports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral;
exports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator;
exports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter;
exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration;
exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation;
exports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate;
exports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery;
exports.tSTypeReference = exports.tsTypeReference = tsTypeReference;
exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword;
exports.tSUnionType = exports.tsUnionType = tsUnionType;
exports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword;
exports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword;
exports.tupleExpression = tupleExpression;
exports.tupleTypeAnnotation = tupleTypeAnnotation;
exports.typeAlias = typeAlias;
exports.typeAnnotation = typeAnnotation;
exports.typeCastExpression = typeCastExpression;
exports.typeParameter = typeParameter;
exports.typeParameterDeclaration = typeParameterDeclaration;
exports.typeParameterInstantiation = typeParameterInstantiation;
exports.typeofTypeAnnotation = typeofTypeAnnotation;
exports.unaryExpression = unaryExpression;
exports.unionTypeAnnotation = unionTypeAnnotation;
exports.updateExpression = updateExpression;
exports.v8IntrinsicIdentifier = v8IntrinsicIdentifier;
exports.variableDeclaration = variableDeclaration;
exports.variableDeclarator = variableDeclarator;
exports.variance = variance;
exports.voidTypeAnnotation = voidTypeAnnotation;
exports.whileStatement = whileStatement;
exports.withStatement = withStatement;
exports.yieldExpression = yieldExpression;
var _validateNode = require("../validateNode");
var _deprecationWarning = require("../../utils/deprecationWarning");
function arrayExpression(elements = []) {
return (0, _validateNode.default)({
type: "ArrayExpression",

@@ -9,4 +267,4 @@ elements

}
export function assignmentExpression(operator, left, right) {
return validateNode({
function assignmentExpression(operator, left, right) {
return (0, _validateNode.default)({
type: "AssignmentExpression",

@@ -18,4 +276,4 @@ operator,

}
export function binaryExpression(operator, left, right) {
return validateNode({
function binaryExpression(operator, left, right) {
return (0, _validateNode.default)({
type: "BinaryExpression",

@@ -27,4 +285,4 @@ operator,

}
export function interpreterDirective(value) {
return validateNode({
function interpreterDirective(value) {
return (0, _validateNode.default)({
type: "InterpreterDirective",

@@ -34,4 +292,4 @@ value

}
export function directive(value) {
return validateNode({
function directive(value) {
return (0, _validateNode.default)({
type: "Directive",

@@ -41,4 +299,4 @@ value

}
export function directiveLiteral(value) {
return validateNode({
function directiveLiteral(value) {
return (0, _validateNode.default)({
type: "DirectiveLiteral",

@@ -48,4 +306,4 @@ value

}
export function blockStatement(body, directives = []) {
return validateNode({
function blockStatement(body, directives = []) {
return (0, _validateNode.default)({
type: "BlockStatement",

@@ -56,4 +314,4 @@ body,

}
export function breakStatement(label = null) {
return validateNode({
function breakStatement(label = null) {
return (0, _validateNode.default)({
type: "BreakStatement",

@@ -63,4 +321,4 @@ label

}
export function callExpression(callee, _arguments) {
return validateNode({
function callExpression(callee, _arguments) {
return (0, _validateNode.default)({
type: "CallExpression",

@@ -71,4 +329,4 @@ callee,

}
export function catchClause(param = null, body) {
return validateNode({
function catchClause(param = null, body) {
return (0, _validateNode.default)({
type: "CatchClause",

@@ -79,4 +337,4 @@ param,

}
export function conditionalExpression(test, consequent, alternate) {
return validateNode({
function conditionalExpression(test, consequent, alternate) {
return (0, _validateNode.default)({
type: "ConditionalExpression",

@@ -88,4 +346,4 @@ test,

}
export function continueStatement(label = null) {
return validateNode({
function continueStatement(label = null) {
return (0, _validateNode.default)({
type: "ContinueStatement",

@@ -95,3 +353,3 @@ label

}
export function debuggerStatement() {
function debuggerStatement() {
return {

@@ -101,4 +359,4 @@ type: "DebuggerStatement"

}
export function doWhileStatement(test, body) {
return validateNode({
function doWhileStatement(test, body) {
return (0, _validateNode.default)({
type: "DoWhileStatement",

@@ -109,3 +367,3 @@ test,

}
export function emptyStatement() {
function emptyStatement() {
return {

@@ -115,4 +373,4 @@ type: "EmptyStatement"

}
export function expressionStatement(expression) {
return validateNode({
function expressionStatement(expression) {
return (0, _validateNode.default)({
type: "ExpressionStatement",

@@ -122,4 +380,4 @@ expression

}
export function file(program, comments = null, tokens = null) {
return validateNode({
function file(program, comments = null, tokens = null) {
return (0, _validateNode.default)({
type: "File",

@@ -131,4 +389,4 @@ program,

}
export function forInStatement(left, right, body) {
return validateNode({
function forInStatement(left, right, body) {
return (0, _validateNode.default)({
type: "ForInStatement",

@@ -140,4 +398,4 @@ left,

}
export function forStatement(init = null, test = null, update = null, body) {
return validateNode({
function forStatement(init = null, test = null, update = null, body) {
return (0, _validateNode.default)({
type: "ForStatement",

@@ -150,4 +408,4 @@ init,

}
export function functionDeclaration(id = null, params, body, generator = false, async = false) {
return validateNode({
function functionDeclaration(id = null, params, body, generator = false, async = false) {
return (0, _validateNode.default)({
type: "FunctionDeclaration",

@@ -161,4 +419,4 @@ id,

}
export function functionExpression(id = null, params, body, generator = false, async = false) {
return validateNode({
function functionExpression(id = null, params, body, generator = false, async = false) {
return (0, _validateNode.default)({
type: "FunctionExpression",

@@ -172,4 +430,4 @@ id,

}
export function identifier(name) {
return validateNode({
function identifier(name) {
return (0, _validateNode.default)({
type: "Identifier",

@@ -179,4 +437,4 @@ name

}
export function ifStatement(test, consequent, alternate = null) {
return validateNode({
function ifStatement(test, consequent, alternate = null) {
return (0, _validateNode.default)({
type: "IfStatement",

@@ -188,4 +446,4 @@ test,

}
export function labeledStatement(label, body) {
return validateNode({
function labeledStatement(label, body) {
return (0, _validateNode.default)({
type: "LabeledStatement",

@@ -196,4 +454,4 @@ label,

}
export function stringLiteral(value) {
return validateNode({
function stringLiteral(value) {
return (0, _validateNode.default)({
type: "StringLiteral",

@@ -203,4 +461,4 @@ value

}
export function numericLiteral(value) {
return validateNode({
function numericLiteral(value) {
return (0, _validateNode.default)({
type: "NumericLiteral",

@@ -210,3 +468,3 @@ value

}
export function nullLiteral() {
function nullLiteral() {
return {

@@ -216,4 +474,4 @@ type: "NullLiteral"

}
export function booleanLiteral(value) {
return validateNode({
function booleanLiteral(value) {
return (0, _validateNode.default)({
type: "BooleanLiteral",

@@ -223,4 +481,4 @@ value

}
export function regExpLiteral(pattern, flags = "") {
return validateNode({
function regExpLiteral(pattern, flags = "") {
return (0, _validateNode.default)({
type: "RegExpLiteral",

@@ -231,4 +489,4 @@ pattern,

}
export function logicalExpression(operator, left, right) {
return validateNode({
function logicalExpression(operator, left, right) {
return (0, _validateNode.default)({
type: "LogicalExpression",

@@ -240,4 +498,4 @@ operator,

}
export function memberExpression(object, property, computed = false, optional = null) {
return validateNode({
function memberExpression(object, property, computed = false, optional = null) {
return (0, _validateNode.default)({
type: "MemberExpression",

@@ -250,4 +508,4 @@ object,

}
export function newExpression(callee, _arguments) {
return validateNode({
function newExpression(callee, _arguments) {
return (0, _validateNode.default)({
type: "NewExpression",

@@ -258,4 +516,4 @@ callee,

}
export function program(body, directives = [], sourceType = "script", interpreter = null) {
return validateNode({
function program(body, directives = [], sourceType = "script", interpreter = null) {
return (0, _validateNode.default)({
type: "Program",

@@ -269,4 +527,4 @@ body,

}
export function objectExpression(properties) {
return validateNode({
function objectExpression(properties) {
return (0, _validateNode.default)({
type: "ObjectExpression",

@@ -276,4 +534,4 @@ properties

}
export function objectMethod(kind = "method", key, params, body, computed = false, generator = false, async = false) {
return validateNode({
function objectMethod(kind = "method", key, params, body, computed = false, generator = false, async = false) {
return (0, _validateNode.default)({
type: "ObjectMethod",

@@ -289,4 +547,4 @@ kind,

}
export function objectProperty(key, value, computed = false, shorthand = false, decorators = null) {
return validateNode({
function objectProperty(key, value, computed = false, shorthand = false, decorators = null) {
return (0, _validateNode.default)({
type: "ObjectProperty",

@@ -300,4 +558,4 @@ key,

}
export function restElement(argument) {
return validateNode({
function restElement(argument) {
return (0, _validateNode.default)({
type: "RestElement",

@@ -307,4 +565,4 @@ argument

}
export function returnStatement(argument = null) {
return validateNode({
function returnStatement(argument = null) {
return (0, _validateNode.default)({
type: "ReturnStatement",

@@ -314,4 +572,4 @@ argument

}
export function sequenceExpression(expressions) {
return validateNode({
function sequenceExpression(expressions) {
return (0, _validateNode.default)({
type: "SequenceExpression",

@@ -321,4 +579,4 @@ expressions

}
export function parenthesizedExpression(expression) {
return validateNode({
function parenthesizedExpression(expression) {
return (0, _validateNode.default)({
type: "ParenthesizedExpression",

@@ -328,4 +586,4 @@ expression

}
export function switchCase(test = null, consequent) {
return validateNode({
function switchCase(test = null, consequent) {
return (0, _validateNode.default)({
type: "SwitchCase",

@@ -336,4 +594,4 @@ test,

}
export function switchStatement(discriminant, cases) {
return validateNode({
function switchStatement(discriminant, cases) {
return (0, _validateNode.default)({
type: "SwitchStatement",

@@ -344,3 +602,3 @@ discriminant,

}
export function thisExpression() {
function thisExpression() {
return {

@@ -350,4 +608,4 @@ type: "ThisExpression"

}
export function throwStatement(argument) {
return validateNode({
function throwStatement(argument) {
return (0, _validateNode.default)({
type: "ThrowStatement",

@@ -357,4 +615,4 @@ argument

}
export function tryStatement(block, handler = null, finalizer = null) {
return validateNode({
function tryStatement(block, handler = null, finalizer = null) {
return (0, _validateNode.default)({
type: "TryStatement",

@@ -366,4 +624,4 @@ block,

}
export function unaryExpression(operator, argument, prefix = true) {
return validateNode({
function unaryExpression(operator, argument, prefix = true) {
return (0, _validateNode.default)({
type: "UnaryExpression",

@@ -375,4 +633,4 @@ operator,

}
export function updateExpression(operator, argument, prefix = false) {
return validateNode({
function updateExpression(operator, argument, prefix = false) {
return (0, _validateNode.default)({
type: "UpdateExpression",

@@ -384,4 +642,4 @@ operator,

}
export function variableDeclaration(kind, declarations) {
return validateNode({
function variableDeclaration(kind, declarations) {
return (0, _validateNode.default)({
type: "VariableDeclaration",

@@ -392,4 +650,4 @@ kind,

}
export function variableDeclarator(id, init = null) {
return validateNode({
function variableDeclarator(id, init = null) {
return (0, _validateNode.default)({
type: "VariableDeclarator",

@@ -400,4 +658,4 @@ id,

}
export function whileStatement(test, body) {
return validateNode({
function whileStatement(test, body) {
return (0, _validateNode.default)({
type: "WhileStatement",

@@ -408,4 +666,4 @@ test,

}
export function withStatement(object, body) {
return validateNode({
function withStatement(object, body) {
return (0, _validateNode.default)({
type: "WithStatement",

@@ -416,4 +674,4 @@ object,

}
export function assignmentPattern(left, right) {
return validateNode({
function assignmentPattern(left, right) {
return (0, _validateNode.default)({
type: "AssignmentPattern",

@@ -424,4 +682,4 @@ left,

}
export function arrayPattern(elements) {
return validateNode({
function arrayPattern(elements) {
return (0, _validateNode.default)({
type: "ArrayPattern",

@@ -431,4 +689,4 @@ elements

}
export function arrowFunctionExpression(params, body, async = false) {
return validateNode({
function arrowFunctionExpression(params, body, async = false) {
return (0, _validateNode.default)({
type: "ArrowFunctionExpression",

@@ -441,4 +699,4 @@ params,

}
export function classBody(body) {
return validateNode({
function classBody(body) {
return (0, _validateNode.default)({
type: "ClassBody",

@@ -448,4 +706,4 @@ body

}
export function classExpression(id = null, superClass = null, body, decorators = null) {
return validateNode({
function classExpression(id = null, superClass = null, body, decorators = null) {
return (0, _validateNode.default)({
type: "ClassExpression",

@@ -458,4 +716,4 @@ id,

}
export function classDeclaration(id, superClass = null, body, decorators = null) {
return validateNode({
function classDeclaration(id, superClass = null, body, decorators = null) {
return (0, _validateNode.default)({
type: "ClassDeclaration",

@@ -468,4 +726,4 @@ id,

}
export function exportAllDeclaration(source) {
return validateNode({
function exportAllDeclaration(source) {
return (0, _validateNode.default)({
type: "ExportAllDeclaration",

@@ -475,4 +733,4 @@ source

}
export function exportDefaultDeclaration(declaration) {
return validateNode({
function exportDefaultDeclaration(declaration) {
return (0, _validateNode.default)({
type: "ExportDefaultDeclaration",

@@ -482,4 +740,4 @@ declaration

}
export function exportNamedDeclaration(declaration = null, specifiers = [], source = null) {
return validateNode({
function exportNamedDeclaration(declaration = null, specifiers = [], source = null) {
return (0, _validateNode.default)({
type: "ExportNamedDeclaration",

@@ -491,4 +749,4 @@ declaration,

}
export function exportSpecifier(local, exported) {
return validateNode({
function exportSpecifier(local, exported) {
return (0, _validateNode.default)({
type: "ExportSpecifier",

@@ -499,4 +757,4 @@ local,

}
export function forOfStatement(left, right, body, _await = false) {
return validateNode({
function forOfStatement(left, right, body, _await = false) {
return (0, _validateNode.default)({
type: "ForOfStatement",

@@ -509,4 +767,4 @@ left,

}
export function importDeclaration(specifiers, source) {
return validateNode({
function importDeclaration(specifiers, source) {
return (0, _validateNode.default)({
type: "ImportDeclaration",

@@ -517,4 +775,4 @@ specifiers,

}
export function importDefaultSpecifier(local) {
return validateNode({
function importDefaultSpecifier(local) {
return (0, _validateNode.default)({
type: "ImportDefaultSpecifier",

@@ -524,4 +782,4 @@ local

}
export function importNamespaceSpecifier(local) {
return validateNode({
function importNamespaceSpecifier(local) {
return (0, _validateNode.default)({
type: "ImportNamespaceSpecifier",

@@ -531,4 +789,4 @@ local

}
export function importSpecifier(local, imported) {
return validateNode({
function importSpecifier(local, imported) {
return (0, _validateNode.default)({
type: "ImportSpecifier",

@@ -539,4 +797,4 @@ local,

}
export function metaProperty(meta, property) {
return validateNode({
function metaProperty(meta, property) {
return (0, _validateNode.default)({
type: "MetaProperty",

@@ -547,4 +805,4 @@ meta,

}
export function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator = false, async = false) {
return validateNode({
function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator = false, async = false) {
return (0, _validateNode.default)({
type: "ClassMethod",

@@ -561,4 +819,4 @@ kind,

}
export function objectPattern(properties) {
return validateNode({
function objectPattern(properties) {
return (0, _validateNode.default)({
type: "ObjectPattern",

@@ -568,4 +826,4 @@ properties

}
export function spreadElement(argument) {
return validateNode({
function spreadElement(argument) {
return (0, _validateNode.default)({
type: "SpreadElement",

@@ -580,5 +838,4 @@ argument

}
export { _super as super };
export function taggedTemplateExpression(tag, quasi) {
return validateNode({
function taggedTemplateExpression(tag, quasi) {
return (0, _validateNode.default)({
type: "TaggedTemplateExpression",

@@ -589,4 +846,4 @@ tag,

}
export function templateElement(value, tail = false) {
return validateNode({
function templateElement(value, tail = false) {
return (0, _validateNode.default)({
type: "TemplateElement",

@@ -597,4 +854,4 @@ value,

}
export function templateLiteral(quasis, expressions) {
return validateNode({
function templateLiteral(quasis, expressions) {
return (0, _validateNode.default)({
type: "TemplateLiteral",

@@ -605,4 +862,4 @@ quasis,

}
export function yieldExpression(argument = null, delegate = false) {
return validateNode({
function yieldExpression(argument = null, delegate = false) {
return (0, _validateNode.default)({
type: "YieldExpression",

@@ -613,4 +870,4 @@ argument,

}
export function awaitExpression(argument) {
return validateNode({
function awaitExpression(argument) {
return (0, _validateNode.default)({
type: "AwaitExpression",

@@ -625,5 +882,4 @@ argument

}
export { _import as import };
export function bigIntLiteral(value) {
return validateNode({
function bigIntLiteral(value) {
return (0, _validateNode.default)({
type: "BigIntLiteral",

@@ -633,4 +889,4 @@ value

}
export function exportNamespaceSpecifier(exported) {
return validateNode({
function exportNamespaceSpecifier(exported) {
return (0, _validateNode.default)({
type: "ExportNamespaceSpecifier",

@@ -640,4 +896,4 @@ exported

}
export function optionalMemberExpression(object, property, computed = false, optional) {
return validateNode({
function optionalMemberExpression(object, property, computed = false, optional) {
return (0, _validateNode.default)({
type: "OptionalMemberExpression",

@@ -650,4 +906,4 @@ object,

}
export function optionalCallExpression(callee, _arguments, optional) {
return validateNode({
function optionalCallExpression(callee, _arguments, optional) {
return (0, _validateNode.default)({
type: "OptionalCallExpression",

@@ -659,4 +915,4 @@ callee,

}
export function classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
return validateNode({
function classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
return (0, _validateNode.default)({
type: "ClassProperty",

@@ -671,4 +927,4 @@ key,

}
export function classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
return validateNode({
function classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
return (0, _validateNode.default)({
type: "ClassAccessorProperty",

@@ -683,4 +939,4 @@ key,

}
export function classPrivateProperty(key, value = null, decorators = null, _static = false) {
return validateNode({
function classPrivateProperty(key, value = null, decorators = null, _static = false) {
return (0, _validateNode.default)({
type: "ClassPrivateProperty",

@@ -693,4 +949,4 @@ key,

}
export function classPrivateMethod(kind = "method", key, params, body, _static = false) {
return validateNode({
function classPrivateMethod(kind = "method", key, params, body, _static = false) {
return (0, _validateNode.default)({
type: "ClassPrivateMethod",

@@ -704,4 +960,4 @@ kind,

}
export function privateName(id) {
return validateNode({
function privateName(id) {
return (0, _validateNode.default)({
type: "PrivateName",

@@ -711,4 +967,4 @@ id

}
export function staticBlock(body) {
return validateNode({
function staticBlock(body) {
return (0, _validateNode.default)({
type: "StaticBlock",

@@ -718,3 +974,3 @@ body

}
export function anyTypeAnnotation() {
function anyTypeAnnotation() {
return {

@@ -724,4 +980,4 @@ type: "AnyTypeAnnotation"

}
export function arrayTypeAnnotation(elementType) {
return validateNode({
function arrayTypeAnnotation(elementType) {
return (0, _validateNode.default)({
type: "ArrayTypeAnnotation",

@@ -731,3 +987,3 @@ elementType

}
export function booleanTypeAnnotation() {
function booleanTypeAnnotation() {
return {

@@ -737,4 +993,4 @@ type: "BooleanTypeAnnotation"

}
export function booleanLiteralTypeAnnotation(value) {
return validateNode({
function booleanLiteralTypeAnnotation(value) {
return (0, _validateNode.default)({
type: "BooleanLiteralTypeAnnotation",

@@ -744,3 +1000,3 @@ value

}
export function nullLiteralTypeAnnotation() {
function nullLiteralTypeAnnotation() {
return {

@@ -750,4 +1006,4 @@ type: "NullLiteralTypeAnnotation"

}
export function classImplements(id, typeParameters = null) {
return validateNode({
function classImplements(id, typeParameters = null) {
return (0, _validateNode.default)({
type: "ClassImplements",

@@ -758,4 +1014,4 @@ id,

}
export function declareClass(id, typeParameters = null, _extends = null, body) {
return validateNode({
function declareClass(id, typeParameters = null, _extends = null, body) {
return (0, _validateNode.default)({
type: "DeclareClass",

@@ -768,4 +1024,4 @@ id,

}
export function declareFunction(id) {
return validateNode({
function declareFunction(id) {
return (0, _validateNode.default)({
type: "DeclareFunction",

@@ -775,4 +1031,4 @@ id

}
export function declareInterface(id, typeParameters = null, _extends = null, body) {
return validateNode({
function declareInterface(id, typeParameters = null, _extends = null, body) {
return (0, _validateNode.default)({
type: "DeclareInterface",

@@ -785,4 +1041,4 @@ id,

}
export function declareModule(id, body, kind = null) {
return validateNode({
function declareModule(id, body, kind = null) {
return (0, _validateNode.default)({
type: "DeclareModule",

@@ -794,4 +1050,4 @@ id,

}
export function declareModuleExports(typeAnnotation) {
return validateNode({
function declareModuleExports(typeAnnotation) {
return (0, _validateNode.default)({
type: "DeclareModuleExports",

@@ -801,4 +1057,4 @@ typeAnnotation

}
export function declareTypeAlias(id, typeParameters = null, right) {
return validateNode({
function declareTypeAlias(id, typeParameters = null, right) {
return (0, _validateNode.default)({
type: "DeclareTypeAlias",

@@ -810,4 +1066,4 @@ id,

}
export function declareOpaqueType(id, typeParameters = null, supertype = null) {
return validateNode({
function declareOpaqueType(id, typeParameters = null, supertype = null) {
return (0, _validateNode.default)({
type: "DeclareOpaqueType",

@@ -819,4 +1075,4 @@ id,

}
export function declareVariable(id) {
return validateNode({
function declareVariable(id) {
return (0, _validateNode.default)({
type: "DeclareVariable",

@@ -826,4 +1082,4 @@ id

}
export function declareExportDeclaration(declaration = null, specifiers = null, source = null) {
return validateNode({
function declareExportDeclaration(declaration = null, specifiers = null, source = null) {
return (0, _validateNode.default)({
type: "DeclareExportDeclaration",

@@ -835,4 +1091,4 @@ declaration,

}
export function declareExportAllDeclaration(source) {
return validateNode({
function declareExportAllDeclaration(source) {
return (0, _validateNode.default)({
type: "DeclareExportAllDeclaration",

@@ -842,4 +1098,4 @@ source

}
export function declaredPredicate(value) {
return validateNode({
function declaredPredicate(value) {
return (0, _validateNode.default)({
type: "DeclaredPredicate",

@@ -849,3 +1105,3 @@ value

}
export function existsTypeAnnotation() {
function existsTypeAnnotation() {
return {

@@ -855,4 +1111,4 @@ type: "ExistsTypeAnnotation"

}
export function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) {
return validateNode({
function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) {
return (0, _validateNode.default)({
type: "FunctionTypeAnnotation",

@@ -865,4 +1121,4 @@ typeParameters,

}
export function functionTypeParam(name = null, typeAnnotation) {
return validateNode({
function functionTypeParam(name = null, typeAnnotation) {
return (0, _validateNode.default)({
type: "FunctionTypeParam",

@@ -873,4 +1129,4 @@ name,

}
export function genericTypeAnnotation(id, typeParameters = null) {
return validateNode({
function genericTypeAnnotation(id, typeParameters = null) {
return (0, _validateNode.default)({
type: "GenericTypeAnnotation",

@@ -881,3 +1137,3 @@ id,

}
export function inferredPredicate() {
function inferredPredicate() {
return {

@@ -887,4 +1143,4 @@ type: "InferredPredicate"

}
export function interfaceExtends(id, typeParameters = null) {
return validateNode({
function interfaceExtends(id, typeParameters = null) {
return (0, _validateNode.default)({
type: "InterfaceExtends",

@@ -895,4 +1151,4 @@ id,

}
export function interfaceDeclaration(id, typeParameters = null, _extends = null, body) {
return validateNode({
function interfaceDeclaration(id, typeParameters = null, _extends = null, body) {
return (0, _validateNode.default)({
type: "InterfaceDeclaration",

@@ -905,4 +1161,4 @@ id,

}
export function interfaceTypeAnnotation(_extends = null, body) {