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 to 7.21.4-esm.1

12

lib/asserts/assertNode.js

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

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

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

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

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

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

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

"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);
import { unionTypeAnnotation } from "../generated/index.js";
import removeTypeDuplicates from "../../modifications/flow/removeTypeDuplicates.js";
export default function createFlowUnionType(types) {
const flattened = removeTypeDuplicates(types);
if (flattened.length === 1) {
return flattened[0];
} else {
return (0, _generated.unionTypeAnnotation)(flattened);
return unionTypeAnnotation(flattened);
}

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

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

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

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

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

"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)({
import validateNode from "../validateNode.js";
import deprecationWarning from "../../utils/deprecationWarning.js";
export function arrayExpression(elements = []) {
return validateNode({
type: "ArrayExpression",

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}
function interfaceTypeAnnotation(_extends = null, body) {