@babel/types - npm Package Compare versions

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

lib/asserts/assertNode.js

@@ -1,4 +0,10 @@
-import isNode from "../validators/isNode.js";
-export default function assertNode(node) {
-  if (!isNode(node)) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = assertNode;
+var _isNode = require("../validators/isNode");
+function assertNode(node) {
+  if (!(0, _isNode.default)(node)) {
     var _node$type;
@@ -5,0 +11,0 @@ const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);

lib/asserts/generated/index.js

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

lib/builders/flow/createFlowUnionType.js

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

lib/builders/flow/createTypeAnnotationBasedOnTypeof.js

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

lib/builders/generated/index.js

@@ -1,5 +0,263 @@
-import validateNode from "../validateNode.js";
-import deprecationWarning from "../../utils/deprecationWarning.js";
-export function arrayExpression(elements = []) {
-  return validateNode({
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.anyTypeAnnotation = anyTypeAnnotation;
+exports.argumentPlaceholder = argumentPlaceholder;
+exports.arrayExpression = arrayExpression;
+exports.arrayPattern = arrayPattern;
+exports.arrayTypeAnnotation = arrayTypeAnnotation;
+exports.arrowFunctionExpression = arrowFunctionExpression;
+exports.assignmentExpression = assignmentExpression;
+exports.assignmentPattern = assignmentPattern;
+exports.awaitExpression = awaitExpression;
+exports.bigIntLiteral = bigIntLiteral;
+exports.binaryExpression = binaryExpression;
+exports.bindExpression = bindExpression;
+exports.blockStatement = blockStatement;
+exports.booleanLiteral = booleanLiteral;
+exports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation;
+exports.booleanTypeAnnotation = booleanTypeAnnotation;
+exports.breakStatement = breakStatement;
+exports.callExpression = callExpression;
+exports.catchClause = catchClause;
+exports.classAccessorProperty = classAccessorProperty;
+exports.classBody = classBody;
+exports.classDeclaration = classDeclaration;
+exports.classExpression = classExpression;
+exports.classImplements = classImplements;
+exports.classMethod = classMethod;
+exports.classPrivateMethod = classPrivateMethod;
+exports.classPrivateProperty = classPrivateProperty;
+exports.classProperty = classProperty;
+exports.conditionalExpression = conditionalExpression;
+exports.continueStatement = continueStatement;
+exports.debuggerStatement = debuggerStatement;
+exports.decimalLiteral = decimalLiteral;
+exports.declareClass = declareClass;
+exports.declareExportAllDeclaration = declareExportAllDeclaration;
+exports.declareExportDeclaration = declareExportDeclaration;
+exports.declareFunction = declareFunction;
+exports.declareInterface = declareInterface;
+exports.declareModule = declareModule;
+exports.declareModuleExports = declareModuleExports;
+exports.declareOpaqueType = declareOpaqueType;
+exports.declareTypeAlias = declareTypeAlias;
+exports.declareVariable = declareVariable;
+exports.declaredPredicate = declaredPredicate;
+exports.decorator = decorator;
+exports.directive = directive;
+exports.directiveLiteral = directiveLiteral;
+exports.doExpression = doExpression;
+exports.doWhileStatement = doWhileStatement;
+exports.emptyStatement = emptyStatement;
+exports.emptyTypeAnnotation = emptyTypeAnnotation;
+exports.enumBooleanBody = enumBooleanBody;
+exports.enumBooleanMember = enumBooleanMember;
+exports.enumDeclaration = enumDeclaration;
+exports.enumDefaultedMember = enumDefaultedMember;
+exports.enumNumberBody = enumNumberBody;
+exports.enumNumberMember = enumNumberMember;
+exports.enumStringBody = enumStringBody;
+exports.enumStringMember = enumStringMember;
+exports.enumSymbolBody = enumSymbolBody;
+exports.existsTypeAnnotation = existsTypeAnnotation;
+exports.exportAllDeclaration = exportAllDeclaration;
+exports.exportDefaultDeclaration = exportDefaultDeclaration;
+exports.exportDefaultSpecifier = exportDefaultSpecifier;
+exports.exportNamedDeclaration = exportNamedDeclaration;
+exports.exportNamespaceSpecifier = exportNamespaceSpecifier;
+exports.exportSpecifier = exportSpecifier;
+exports.expressionStatement = expressionStatement;
+exports.file = file;
+exports.forInStatement = forInStatement;
+exports.forOfStatement = forOfStatement;
+exports.forStatement = forStatement;
+exports.functionDeclaration = functionDeclaration;
+exports.functionExpression = functionExpression;
+exports.functionTypeAnnotation = functionTypeAnnotation;
+exports.functionTypeParam = functionTypeParam;
+exports.genericTypeAnnotation = genericTypeAnnotation;
+exports.identifier = identifier;
+exports.ifStatement = ifStatement;
+exports.import = _import;
+exports.importAttribute = importAttribute;
+exports.importDeclaration = importDeclaration;
+exports.importDefaultSpecifier = importDefaultSpecifier;
+exports.importNamespaceSpecifier = importNamespaceSpecifier;
+exports.importSpecifier = importSpecifier;
+exports.indexedAccessType = indexedAccessType;
+exports.inferredPredicate = inferredPredicate;
+exports.interfaceDeclaration = interfaceDeclaration;
+exports.interfaceExtends = interfaceExtends;
+exports.interfaceTypeAnnotation = interfaceTypeAnnotation;
+exports.interpreterDirective = interpreterDirective;
+exports.intersectionTypeAnnotation = intersectionTypeAnnotation;
+exports.jSXAttribute = exports.jsxAttribute = jsxAttribute;
+exports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement;
+exports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment;
+exports.jSXElement = exports.jsxElement = jsxElement;
+exports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression;
+exports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer;
+exports.jSXFragment = exports.jsxFragment = jsxFragment;
+exports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier;
+exports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression;
+exports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName;
+exports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement;
+exports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment;
+exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute;
+exports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild;
+exports.jSXText = exports.jsxText = jsxText;
+exports.labeledStatement = labeledStatement;
+exports.logicalExpression = logicalExpression;
+exports.memberExpression = memberExpression;
+exports.metaProperty = metaProperty;
+exports.mixedTypeAnnotation = mixedTypeAnnotation;
+exports.moduleExpression = moduleExpression;
+exports.newExpression = newExpression;
+exports.noop = noop;
+exports.nullLiteral = nullLiteral;
+exports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation;
+exports.nullableTypeAnnotation = nullableTypeAnnotation;
+exports.numberLiteral = NumberLiteral;
+exports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation;
+exports.numberTypeAnnotation = numberTypeAnnotation;
+exports.numericLiteral = numericLiteral;
+exports.objectExpression = objectExpression;
+exports.objectMethod = objectMethod;
+exports.objectPattern = objectPattern;
+exports.objectProperty = objectProperty;
+exports.objectTypeAnnotation = objectTypeAnnotation;
+exports.objectTypeCallProperty = objectTypeCallProperty;
+exports.objectTypeIndexer = objectTypeIndexer;
+exports.objectTypeInternalSlot = objectTypeInternalSlot;
+exports.objectTypeProperty = objectTypeProperty;
+exports.objectTypeSpreadProperty = objectTypeSpreadProperty;
+exports.opaqueType = opaqueType;
+exports.optionalCallExpression = optionalCallExpression;
+exports.optionalIndexedAccessType = optionalIndexedAccessType;
+exports.optionalMemberExpression = optionalMemberExpression;
+exports.parenthesizedExpression = parenthesizedExpression;
+exports.pipelineBareFunction = pipelineBareFunction;
+exports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference;
+exports.pipelineTopicExpression = pipelineTopicExpression;
+exports.placeholder = placeholder;
+exports.privateName = privateName;
+exports.program = program;
+exports.qualifiedTypeIdentifier = qualifiedTypeIdentifier;
+exports.recordExpression = recordExpression;
+exports.regExpLiteral = regExpLiteral;
+exports.regexLiteral = RegexLiteral;
+exports.restElement = restElement;
+exports.restProperty = RestProperty;
+exports.returnStatement = returnStatement;
+exports.sequenceExpression = sequenceExpression;
+exports.spreadElement = spreadElement;
+exports.spreadProperty = SpreadProperty;
+exports.staticBlock = staticBlock;
+exports.stringLiteral = stringLiteral;
+exports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation;
+exports.stringTypeAnnotation = stringTypeAnnotation;
+exports.super = _super;
+exports.switchCase = switchCase;
+exports.switchStatement = switchStatement;
+exports.symbolTypeAnnotation = symbolTypeAnnotation;
+exports.taggedTemplateExpression = taggedTemplateExpression;
+exports.templateElement = templateElement;
+exports.templateLiteral = templateLiteral;
+exports.thisExpression = thisExpression;
+exports.thisTypeAnnotation = thisTypeAnnotation;
+exports.throwStatement = throwStatement;
+exports.topicReference = topicReference;
+exports.tryStatement = tryStatement;
+exports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword;
+exports.tSArrayType = exports.tsArrayType = tsArrayType;
+exports.tSAsExpression = exports.tsAsExpression = tsAsExpression;
+exports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword;
+exports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword;
+exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration;
+exports.tSConditionalType = exports.tsConditionalType = tsConditionalType;
+exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration;
+exports.tSConstructorType = exports.tsConstructorType = tsConstructorType;
+exports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction;
+exports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod;
+exports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration;
+exports.tSEnumMember = exports.tsEnumMember = tsEnumMember;
+exports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment;
+exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments;
+exports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference;
+exports.tSFunctionType = exports.tsFunctionType = tsFunctionType;
+exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration;
+exports.tSImportType = exports.tsImportType = tsImportType;
+exports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature;
+exports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType;
+exports.tSInferType = exports.tsInferType = tsInferType;
+exports.tSInstantiationExpression = exports.tsInstantiationExpression = tsInstantiationExpression;
+exports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody;
+exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration;
+exports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType;
+exports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword;
+exports.tSLiteralType = exports.tsLiteralType = tsLiteralType;
+exports.tSMappedType = exports.tsMappedType = tsMappedType;
+exports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature;
+exports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock;
+exports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration;
+exports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember;
+exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration;
+exports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword;
+exports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression;
+exports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword;
+exports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword;
+exports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword;
+exports.tSOptionalType = exports.tsOptionalType = tsOptionalType;
+exports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty;
+exports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType;
+exports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature;
+exports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName;
+exports.tSRestType = exports.tsRestType = tsRestType;
+exports.tSSatisfiesExpression = exports.tsSatisfiesExpression = tsSatisfiesExpression;
+exports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword;
+exports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword;
+exports.tSThisType = exports.tsThisType = tsThisType;
+exports.tSTupleType = exports.tsTupleType = tsTupleType;
+exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration;
+exports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation;
+exports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion;
+exports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral;
+exports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator;
+exports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter;
+exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration;
+exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation;
+exports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate;
+exports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery;
+exports.tSTypeReference = exports.tsTypeReference = tsTypeReference;
+exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword;
+exports.tSUnionType = exports.tsUnionType = tsUnionType;
+exports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword;
+exports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword;
+exports.tupleExpression = tupleExpression;
+exports.tupleTypeAnnotation = tupleTypeAnnotation;
+exports.typeAlias = typeAlias;
+exports.typeAnnotation = typeAnnotation;
+exports.typeCastExpression = typeCastExpression;
+exports.typeParameter = typeParameter;
+exports.typeParameterDeclaration = typeParameterDeclaration;
+exports.typeParameterInstantiation = typeParameterInstantiation;
+exports.typeofTypeAnnotation = typeofTypeAnnotation;
+exports.unaryExpression = unaryExpression;
+exports.unionTypeAnnotation = unionTypeAnnotation;
+exports.updateExpression = updateExpression;
+exports.v8IntrinsicIdentifier = v8IntrinsicIdentifier;
+exports.variableDeclaration = variableDeclaration;
+exports.variableDeclarator = variableDeclarator;
+exports.variance = variance;
+exports.voidTypeAnnotation = voidTypeAnnotation;
+exports.whileStatement = whileStatement;
+exports.withStatement = withStatement;
+exports.yieldExpression = yieldExpression;
+var _validateNode = require("../validateNode");
+var _deprecationWarning = require("../../utils/deprecationWarning");
+function arrayExpression(elements = []) {
+  return (0, _validateNode.default)({
     type: "ArrayExpression",
@@ -9,4 +267,4 @@ elements
 }
-export function assignmentExpression(operator, left, right) {
-  return validateNode({
+function assignmentExpression(operator, left, right) {
+  return (0, _validateNode.default)({
     type: "AssignmentExpression",
@@ -18,4 +276,4 @@ operator,
 }
-export function binaryExpression(operator, left, right) {
-  return validateNode({
+function binaryExpression(operator, left, right) {
+  return (0, _validateNode.default)({
     type: "BinaryExpression",
@@ -27,4 +285,4 @@ operator,
 }
-export function interpreterDirective(value) {
-  return validateNode({
+function interpreterDirective(value) {
+  return (0, _validateNode.default)({
     type: "InterpreterDirective",
@@ -34,4 +292,4 @@ value
 }
-export function directive(value) {
-  return validateNode({
+function directive(value) {
+  return (0, _validateNode.default)({
     type: "Directive",
@@ -41,4 +299,4 @@ value
 }
-export function directiveLiteral(value) {
-  return validateNode({
+function directiveLiteral(value) {
+  return (0, _validateNode.default)({
     type: "DirectiveLiteral",
@@ -48,4 +306,4 @@ value
 }
-export function blockStatement(body, directives = []) {
-  return validateNode({
+function blockStatement(body, directives = []) {
+  return (0, _validateNode.default)({
     type: "BlockStatement",
@@ -56,4 +314,4 @@ body,
 }
-export function breakStatement(label = null) {
-  return validateNode({
+function breakStatement(label = null) {
+  return (0, _validateNode.default)({
     type: "BreakStatement",
@@ -63,4 +321,4 @@ label
 }
-export function callExpression(callee, _arguments) {
-  return validateNode({
+function callExpression(callee, _arguments) {
+  return (0, _validateNode.default)({
     type: "CallExpression",
@@ -71,4 +329,4 @@ callee,
 }
-export function catchClause(param = null, body) {
-  return validateNode({
+function catchClause(param = null, body) {
+  return (0, _validateNode.default)({
     type: "CatchClause",
@@ -79,4 +337,4 @@ param,
 }
-export function conditionalExpression(test, consequent, alternate) {
-  return validateNode({
+function conditionalExpression(test, consequent, alternate) {
+  return (0, _validateNode.default)({
     type: "ConditionalExpression",
@@ -88,4 +346,4 @@ test,
 }
-export function continueStatement(label = null) {
-  return validateNode({
+function continueStatement(label = null) {
+  return (0, _validateNode.default)({
     type: "ContinueStatement",
@@ -95,3 +353,3 @@ label
 }
-export function debuggerStatement() {
+function debuggerStatement() {
   return {
@@ -101,4 +359,4 @@ type: "DebuggerStatement"
 }
-export function doWhileStatement(test, body) {
-  return validateNode({
+function doWhileStatement(test, body) {
+  return (0, _validateNode.default)({
     type: "DoWhileStatement",
@@ -109,3 +367,3 @@ test,
 }
-export function emptyStatement() {
+function emptyStatement() {
   return {
@@ -115,4 +373,4 @@ type: "EmptyStatement"
 }
-export function expressionStatement(expression) {
-  return validateNode({
+function expressionStatement(expression) {
+  return (0, _validateNode.default)({
     type: "ExpressionStatement",
@@ -122,4 +380,4 @@ expression
 }
-export function file(program, comments = null, tokens = null) {
-  return validateNode({
+function file(program, comments = null, tokens = null) {
+  return (0, _validateNode.default)({
     type: "File",
@@ -131,4 +389,4 @@ program,
 }
-export function forInStatement(left, right, body) {
-  return validateNode({
+function forInStatement(left, right, body) {
+  return (0, _validateNode.default)({
     type: "ForInStatement",
@@ -140,4 +398,4 @@ left,
 }
-export function forStatement(init = null, test = null, update = null, body) {
-  return validateNode({
+function forStatement(init = null, test = null, update = null, body) {
+  return (0, _validateNode.default)({
     type: "ForStatement",
@@ -150,4 +408,4 @@ init,
 }
-export function functionDeclaration(id = null, params, body, generator = false, async = false) {
-  return validateNode({
+function functionDeclaration(id = null, params, body, generator = false, async = false) {
+  return (0, _validateNode.default)({
     type: "FunctionDeclaration",
@@ -161,4 +419,4 @@ id,
 }
-export function functionExpression(id = null, params, body, generator = false, async = false) {
-  return validateNode({
+function functionExpression(id = null, params, body, generator = false, async = false) {
+  return (0, _validateNode.default)({
     type: "FunctionExpression",
@@ -172,4 +430,4 @@ id,
 }
-export function identifier(name) {
-  return validateNode({
+function identifier(name) {
+  return (0, _validateNode.default)({
     type: "Identifier",
@@ -179,4 +437,4 @@ name
 }
-export function ifStatement(test, consequent, alternate = null) {
-  return validateNode({
+function ifStatement(test, consequent, alternate = null) {
+  return (0, _validateNode.default)({
     type: "IfStatement",
@@ -188,4 +446,4 @@ test,
 }
-export function labeledStatement(label, body) {
-  return validateNode({
+function labeledStatement(label, body) {
+  return (0, _validateNode.default)({
     type: "LabeledStatement",
@@ -196,4 +454,4 @@ label,
 }
-export function stringLiteral(value) {
-  return validateNode({
+function stringLiteral(value) {
+  return (0, _validateNode.default)({
     type: "StringLiteral",
@@ -203,4 +461,4 @@ value
 }
-export function numericLiteral(value) {
-  return validateNode({
+function numericLiteral(value) {
+  return (0, _validateNode.default)({
     type: "NumericLiteral",
@@ -210,3 +468,3 @@ value
 }
-export function nullLiteral() {
+function nullLiteral() {
   return {
@@ -216,4 +474,4 @@ type: "NullLiteral"
 }
-export function booleanLiteral(value) {
-  return validateNode({
+function booleanLiteral(value) {
+  return (0, _validateNode.default)({
     type: "BooleanLiteral",
@@ -223,4 +481,4 @@ value
 }
-export function regExpLiteral(pattern, flags = "") {
-  return validateNode({
+function regExpLiteral(pattern, flags = "") {
+  return (0, _validateNode.default)({
     type: "RegExpLiteral",
@@ -231,4 +489,4 @@ pattern,
 }
-export function logicalExpression(operator, left, right) {
-  return validateNode({
+function logicalExpression(operator, left, right) {
+  return (0, _validateNode.default)({
     type: "LogicalExpression",
@@ -240,4 +498,4 @@ operator,
 }
-export function memberExpression(object, property, computed = false, optional = null) {
-  return validateNode({
+function memberExpression(object, property, computed = false, optional = null) {
+  return (0, _validateNode.default)({
     type: "MemberExpression",
@@ -250,4 +508,4 @@ object,
 }
-export function newExpression(callee, _arguments) {
-  return validateNode({
+function newExpression(callee, _arguments) {
+  return (0, _validateNode.default)({
     type: "NewExpression",
@@ -258,4 +516,4 @@ callee,
 }
-export function program(body, directives = [], sourceType = "script", interpreter = null) {
-  return validateNode({
+function program(body, directives = [], sourceType = "script", interpreter = null) {
+  return (0, _validateNode.default)({
     type: "Program",
@@ -269,4 +527,4 @@ body,
 }
-export function objectExpression(properties) {
-  return validateNode({
+function objectExpression(properties) {
+  return (0, _validateNode.default)({
     type: "ObjectExpression",
@@ -276,4 +534,4 @@ properties
 }
-export function objectMethod(kind = "method", key, params, body, computed = false, generator = false, async = false) {
-  return validateNode({
+function objectMethod(kind = "method", key, params, body, computed = false, generator = false, async = false) {
+  return (0, _validateNode.default)({
     type: "ObjectMethod",
@@ -289,4 +547,4 @@ kind,
 }
-export function objectProperty(key, value, computed = false, shorthand = false, decorators = null) {
-  return validateNode({
+function objectProperty(key, value, computed = false, shorthand = false, decorators = null) {
+  return (0, _validateNode.default)({
     type: "ObjectProperty",
@@ -300,4 +558,4 @@ key,
 }
-export function restElement(argument) {
-  return validateNode({
+function restElement(argument) {
+  return (0, _validateNode.default)({
     type: "RestElement",
@@ -307,4 +565,4 @@ argument
 }
-export function returnStatement(argument = null) {
-  return validateNode({
+function returnStatement(argument = null) {
+  return (0, _validateNode.default)({
     type: "ReturnStatement",
@@ -314,4 +572,4 @@ argument
 }
-export function sequenceExpression(expressions) {
-  return validateNode({
+function sequenceExpression(expressions) {
+  return (0, _validateNode.default)({
     type: "SequenceExpression",
@@ -321,4 +579,4 @@ expressions
 }
-export function parenthesizedExpression(expression) {
-  return validateNode({
+function parenthesizedExpression(expression) {
+  return (0, _validateNode.default)({
     type: "ParenthesizedExpression",
@@ -328,4 +586,4 @@ expression
 }
-export function switchCase(test = null, consequent) {
-  return validateNode({
+function switchCase(test = null, consequent) {
+  return (0, _validateNode.default)({
     type: "SwitchCase",
@@ -336,4 +594,4 @@ test,
 }
-export function switchStatement(discriminant, cases) {
-  return validateNode({
+function switchStatement(discriminant, cases) {
+  return (0, _validateNode.default)({
     type: "SwitchStatement",
@@ -344,3 +602,3 @@ discriminant,
 }
-export function thisExpression() {
+function thisExpression() {
   return {
@@ -350,4 +608,4 @@ type: "ThisExpression"
 }
-export function throwStatement(argument) {
-  return validateNode({
+function throwStatement(argument) {
+  return (0, _validateNode.default)({
     type: "ThrowStatement",
@@ -357,4 +615,4 @@ argument
 }
-export function tryStatement(block, handler = null, finalizer = null) {
-  return validateNode({
+function tryStatement(block, handler = null, finalizer = null) {
+  return (0, _validateNode.default)({
     type: "TryStatement",
@@ -366,4 +624,4 @@ block,
 }
-export function unaryExpression(operator, argument, prefix = true) {
-  return validateNode({
+function unaryExpression(operator, argument, prefix = true) {
+  return (0, _validateNode.default)({
     type: "UnaryExpression",
@@ -375,4 +633,4 @@ operator,
 }
-export function updateExpression(operator, argument, prefix = false) {
-  return validateNode({
+function updateExpression(operator, argument, prefix = false) {
+  return (0, _validateNode.default)({
     type: "UpdateExpression",
@@ -384,4 +642,4 @@ operator,
 }
-export function variableDeclaration(kind, declarations) {
-  return validateNode({
+function variableDeclaration(kind, declarations) {
+  return (0, _validateNode.default)({
     type: "VariableDeclaration",
@@ -392,4 +650,4 @@ kind,
 }
-export function variableDeclarator(id, init = null) {
-  return validateNode({
+function variableDeclarator(id, init = null) {
+  return (0, _validateNode.default)({
     type: "VariableDeclarator",
@@ -400,4 +658,4 @@ id,
 }
-export function whileStatement(test, body) {
-  return validateNode({
+function whileStatement(test, body) {
+  return (0, _validateNode.default)({
     type: "WhileStatement",
@@ -408,4 +666,4 @@ test,
 }
-export function withStatement(object, body) {
-  return validateNode({
+function withStatement(object, body) {
+  return (0, _validateNode.default)({
     type: "WithStatement",
@@ -416,4 +674,4 @@ object,
 }
-export function assignmentPattern(left, right) {
-  return validateNode({
+function assignmentPattern(left, right) {
+  return (0, _validateNode.default)({
     type: "AssignmentPattern",
@@ -424,4 +682,4 @@ left,
 }
-export function arrayPattern(elements) {
-  return validateNode({
+function arrayPattern(elements) {
+  return (0, _validateNode.default)({
     type: "ArrayPattern",
@@ -431,4 +689,4 @@ elements
 }
-export function arrowFunctionExpression(params, body, async = false) {
-  return validateNode({
+function arrowFunctionExpression(params, body, async = false) {
+  return (0, _validateNode.default)({
     type: "ArrowFunctionExpression",
@@ -441,4 +699,4 @@ params,
 }
-export function classBody(body) {
-  return validateNode({
+function classBody(body) {
+  return (0, _validateNode.default)({
     type: "ClassBody",
@@ -448,4 +706,4 @@ body
 }
-export function classExpression(id = null, superClass = null, body, decorators = null) {
-  return validateNode({
+function classExpression(id = null, superClass = null, body, decorators = null) {
+  return (0, _validateNode.default)({
     type: "ClassExpression",
@@ -458,4 +716,4 @@ id,
 }
-export function classDeclaration(id, superClass = null, body, decorators = null) {
-  return validateNode({
+function classDeclaration(id, superClass = null, body, decorators = null) {
+  return (0, _validateNode.default)({
     type: "ClassDeclaration",
@@ -468,4 +726,4 @@ id,
 }
-export function exportAllDeclaration(source) {
-  return validateNode({
+function exportAllDeclaration(source) {
+  return (0, _validateNode.default)({
     type: "ExportAllDeclaration",
@@ -475,4 +733,4 @@ source
 }
-export function exportDefaultDeclaration(declaration) {
-  return validateNode({
+function exportDefaultDeclaration(declaration) {
+  return (0, _validateNode.default)({
     type: "ExportDefaultDeclaration",
@@ -482,4 +740,4 @@ declaration
 }
-export function exportNamedDeclaration(declaration = null, specifiers = [], source = null) {
-  return validateNode({
+function exportNamedDeclaration(declaration = null, specifiers = [], source = null) {
+  return (0, _validateNode.default)({
     type: "ExportNamedDeclaration",
@@ -491,4 +749,4 @@ declaration,
 }
-export function exportSpecifier(local, exported) {
-  return validateNode({
+function exportSpecifier(local, exported) {
+  return (0, _validateNode.default)({
     type: "ExportSpecifier",
@@ -499,4 +757,4 @@ local,
 }
-export function forOfStatement(left, right, body, _await = false) {
-  return validateNode({
+function forOfStatement(left, right, body, _await = false) {
+  return (0, _validateNode.default)({
     type: "ForOfStatement",
@@ -509,4 +767,4 @@ left,
 }
-export function importDeclaration(specifiers, source) {
-  return validateNode({
+function importDeclaration(specifiers, source) {
+  return (0, _validateNode.default)({
     type: "ImportDeclaration",
@@ -517,4 +775,4 @@ specifiers,
 }
-export function importDefaultSpecifier(local) {
-  return validateNode({
+function importDefaultSpecifier(local) {
+  return (0, _validateNode.default)({
     type: "ImportDefaultSpecifier",
@@ -524,4 +782,4 @@ local
 }
-export function importNamespaceSpecifier(local) {
-  return validateNode({
+function importNamespaceSpecifier(local) {
+  return (0, _validateNode.default)({
     type: "ImportNamespaceSpecifier",
@@ -531,4 +789,4 @@ local
 }
-export function importSpecifier(local, imported) {
-  return validateNode({
+function importSpecifier(local, imported) {
+  return (0, _validateNode.default)({
     type: "ImportSpecifier",
@@ -539,4 +797,4 @@ local,
 }
-export function metaProperty(meta, property) {
-  return validateNode({
+function metaProperty(meta, property) {
+  return (0, _validateNode.default)({
     type: "MetaProperty",
@@ -547,4 +805,4 @@ meta,
 }
-export function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator = false, async = false) {
-  return validateNode({
+function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator = false, async = false) {
+  return (0, _validateNode.default)({
     type: "ClassMethod",
@@ -561,4 +819,4 @@ kind,
 }
-export function objectPattern(properties) {
-  return validateNode({
+function objectPattern(properties) {
+  return (0, _validateNode.default)({
     type: "ObjectPattern",
@@ -568,4 +826,4 @@ properties
 }
-export function spreadElement(argument) {
-  return validateNode({
+function spreadElement(argument) {
+  return (0, _validateNode.default)({
     type: "SpreadElement",
@@ -580,5 +838,4 @@ argument
 }
-export { _super as super };
-export function taggedTemplateExpression(tag, quasi) {
-  return validateNode({
+function taggedTemplateExpression(tag, quasi) {
+  return (0, _validateNode.default)({
     type: "TaggedTemplateExpression",
@@ -589,4 +846,4 @@ tag,
 }
-export function templateElement(value, tail = false) {
-  return validateNode({
+function templateElement(value, tail = false) {
+  return (0, _validateNode.default)({
     type: "TemplateElement",
@@ -597,4 +854,4 @@ value,
 }
-export function templateLiteral(quasis, expressions) {
-  return validateNode({
+function templateLiteral(quasis, expressions) {
+  return (0, _validateNode.default)({
     type: "TemplateLiteral",
@@ -605,4 +862,4 @@ quasis,
 }
-export function yieldExpression(argument = null, delegate = false) {
-  return validateNode({
+function yieldExpression(argument = null, delegate = false) {
+  return (0, _validateNode.default)({
     type: "YieldExpression",
@@ -613,4 +870,4 @@ argument,
 }
-export function awaitExpression(argument) {
-  return validateNode({
+function awaitExpression(argument) {
+  return (0, _validateNode.default)({
     type: "AwaitExpression",
@@ -625,5 +882,4 @@ argument
 }
-export { _import as import };
-export function bigIntLiteral(value) {
-  return validateNode({
+function bigIntLiteral(value) {
+  return (0, _validateNode.default)({
     type: "BigIntLiteral",
@@ -633,4 +889,4 @@ value
 }
-export function exportNamespaceSpecifier(exported) {
-  return validateNode({
+function exportNamespaceSpecifier(exported) {
+  return (0, _validateNode.default)({
     type: "ExportNamespaceSpecifier",
@@ -640,4 +896,4 @@ exported
 }
-export function optionalMemberExpression(object, property, computed = false, optional) {
-  return validateNode({
+function optionalMemberExpression(object, property, computed = false, optional) {
+  return (0, _validateNode.default)({
     type: "OptionalMemberExpression",
@@ -650,4 +906,4 @@ object,
 }
-export function optionalCallExpression(callee, _arguments, optional) {
-  return validateNode({
+function optionalCallExpression(callee, _arguments, optional) {
+  return (0, _validateNode.default)({
     type: "OptionalCallExpression",
@@ -659,4 +915,4 @@ callee,
 }
-export function classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
-  return validateNode({
+function classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
+  return (0, _validateNode.default)({
     type: "ClassProperty",
@@ -671,4 +927,4 @@ key,
 }
-export function classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
-  return validateNode({
+function classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
+  return (0, _validateNode.default)({
     type: "ClassAccessorProperty",
@@ -683,4 +939,4 @@ key,
 }
-export function classPrivateProperty(key, value = null, decorators = null, _static = false) {
-  return validateNode({
+function classPrivateProperty(key, value = null, decorators = null, _static = false) {
+  return (0, _validateNode.default)({
     type: "ClassPrivateProperty",
@@ -693,4 +949,4 @@ key,
 }
-export function classPrivateMethod(kind = "method", key, params, body, _static = false) {
-  return validateNode({
+function classPrivateMethod(kind = "method", key, params, body, _static = false) {
+  return (0, _validateNode.default)({
     type: "ClassPrivateMethod",
@@ -704,4 +960,4 @@ kind,
 }
-export function privateName(id) {
-  return validateNode({
+function privateName(id) {
+  return (0, _validateNode.default)({
     type: "PrivateName",
@@ -711,4 +967,4 @@ id
 }
-export function staticBlock(body) {
-  return validateNode({
+function staticBlock(body) {
+  return (0, _validateNode.default)({
     type: "StaticBlock",
@@ -718,3 +974,3 @@ body
 }
-export function anyTypeAnnotation() {
+function anyTypeAnnotation() {
   return {
@@ -724,4 +980,4 @@ type: "AnyTypeAnnotation"
 }
-export function arrayTypeAnnotation(elementType) {
-  return validateNode({
+function arrayTypeAnnotation(elementType) {
+  return (0, _validateNode.default)({
     type: "ArrayTypeAnnotation",
@@ -731,3 +987,3 @@ elementType
 }
-export function booleanTypeAnnotation() {
+function booleanTypeAnnotation() {
   return {
@@ -737,4 +993,4 @@ type: "BooleanTypeAnnotation"
 }
-export function booleanLiteralTypeAnnotation(value) {
-  return validateNode({
+function booleanLiteralTypeAnnotation(value) {
+  return (0, _validateNode.default)({
     type: "BooleanLiteralTypeAnnotation",
@@ -744,3 +1000,3 @@ value
 }
-export function nullLiteralTypeAnnotation() {
+function nullLiteralTypeAnnotation() {
   return {
@@ -750,4 +1006,4 @@ type: "NullLiteralTypeAnnotation"
 }
-export function classImplements(id, typeParameters = null) {
-  return validateNode({
+function classImplements(id, typeParameters = null) {
+  return (0, _validateNode.default)({
     type: "ClassImplements",
@@ -758,4 +1014,4 @@ id,
 }
-export function declareClass(id, typeParameters = null, _extends = null, body) {
-  return validateNode({
+function declareClass(id, typeParameters = null, _extends = null, body) {
+  return (0, _validateNode.default)({
     type: "DeclareClass",
@@ -768,4 +1024,4 @@ id,
 }
-export function declareFunction(id) {
-  return validateNode({
+function declareFunction(id) {
+  return (0, _validateNode.default)({
     type: "DeclareFunction",
@@ -775,4 +1031,4 @@ id
 }
-export function declareInterface(id, typeParameters = null, _extends = null, body) {
-  return validateNode({
+function declareInterface(id, typeParameters = null, _extends = null, body) {
+  return (0, _validateNode.default)({
     type: "DeclareInterface",
@@ -785,4 +1041,4 @@ id,
 }
-export function declareModule(id, body, kind = null) {
-  return validateNode({
+function declareModule(id, body, kind = null) {
+  return (0, _validateNode.default)({
     type: "DeclareModule",
@@ -794,4 +1050,4 @@ id,
 }
-export function declareModuleExports(typeAnnotation) {
-  return validateNode({
+function declareModuleExports(typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "DeclareModuleExports",
@@ -801,4 +1057,4 @@ typeAnnotation
 }
-export function declareTypeAlias(id, typeParameters = null, right) {
-  return validateNode({
+function declareTypeAlias(id, typeParameters = null, right) {
+  return (0, _validateNode.default)({
     type: "DeclareTypeAlias",
@@ -810,4 +1066,4 @@ id,
 }
-export function declareOpaqueType(id, typeParameters = null, supertype = null) {
-  return validateNode({
+function declareOpaqueType(id, typeParameters = null, supertype = null) {
+  return (0, _validateNode.default)({
     type: "DeclareOpaqueType",
@@ -819,4 +1075,4 @@ id,
 }
-export function declareVariable(id) {
-  return validateNode({
+function declareVariable(id) {
+  return (0, _validateNode.default)({
     type: "DeclareVariable",
@@ -826,4 +1082,4 @@ id
 }
-export function declareExportDeclaration(declaration = null, specifiers = null, source = null) {
-  return validateNode({
+function declareExportDeclaration(declaration = null, specifiers = null, source = null) {
+  return (0, _validateNode.default)({
     type: "DeclareExportDeclaration",
@@ -835,4 +1091,4 @@ declaration,
 }
-export function declareExportAllDeclaration(source) {
-  return validateNode({
+function declareExportAllDeclaration(source) {
+  return (0, _validateNode.default)({
     type: "DeclareExportAllDeclaration",
@@ -842,4 +1098,4 @@ source
 }
-export function declaredPredicate(value) {
-  return validateNode({
+function declaredPredicate(value) {
+  return (0, _validateNode.default)({
     type: "DeclaredPredicate",
@@ -849,3 +1105,3 @@ value
 }
-export function existsTypeAnnotation() {
+function existsTypeAnnotation() {
   return {
@@ -855,4 +1111,4 @@ type: "ExistsTypeAnnotation"
 }
-export function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) {
-  return validateNode({
+function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) {
+  return (0, _validateNode.default)({
     type: "FunctionTypeAnnotation",
@@ -865,4 +1121,4 @@ typeParameters,
 }
-export function functionTypeParam(name = null, typeAnnotation) {
-  return validateNode({
+function functionTypeParam(name = null, typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "FunctionTypeParam",
@@ -873,4 +1129,4 @@ name,
 }
-export function genericTypeAnnotation(id, typeParameters = null) {
-  return validateNode({
+function genericTypeAnnotation(id, typeParameters = null) {
+  return (0, _validateNode.default)({
     type: "GenericTypeAnnotation",
@@ -881,3 +1137,3 @@ id,
 }
-export function inferredPredicate() {
+function inferredPredicate() {
   return {
@@ -887,4 +1143,4 @@ type: "InferredPredicate"
 }
-export function interfaceExtends(id, typeParameters = null) {
-  return validateNode({
+function interfaceExtends(id, typeParameters = null) {
+  return (0, _validateNode.default)({
     type: "InterfaceExtends",
@@ -895,4 +1151,4 @@ id,
 }
-export function interfaceDeclaration(id, typeParameters = null, _extends = null, body) {
-  return validateNode({
+function interfaceDeclaration(id, typeParameters = null, _extends = null, body) {
+  return (0, _validateNode.default)({
     type: "InterfaceDeclaration",
@@ -905,4 +1161,4 @@ id,
 }
-export function interfaceTypeAnnotation(_extends = null, body) {
-  return validateNode({
+function interfaceTypeAnnotation(_extends = null, body) {
+  return (0, _validateNode.default)({
     type: "InterfaceTypeAnnotation",
@@ -913,4 +1169,4 @@ extends: _extends,
 }
-export function intersectionTypeAnnotation(types) {
-  return validateNode({
+function intersectionTypeAnnotation(types) {
+  return (0, _validateNode.default)({
     type: "IntersectionTypeAnnotation",
@@ -920,3 +1176,3 @@ types
 }
-export function mixedTypeAnnotation() {
+function mixedTypeAnnotation() {
   return {
@@ -926,3 +1182,3 @@ type: "MixedTypeAnnotation"
 }
-export function emptyTypeAnnotation() {
+function emptyTypeAnnotation() {
   return {
@@ -932,4 +1188,4 @@ type: "EmptyTypeAnnotation"
 }
-export function nullableTypeAnnotation(typeAnnotation) {
-  return validateNode({
+function nullableTypeAnnotation(typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "NullableTypeAnnotation",
@@ -939,4 +1195,4 @@ typeAnnotation
 }
-export function numberLiteralTypeAnnotation(value) {
-  return validateNode({
+function numberLiteralTypeAnnotation(value) {
+  return (0, _validateNode.default)({
     type: "NumberLiteralTypeAnnotation",
@@ -946,3 +1202,3 @@ value
 }
-export function numberTypeAnnotation() {
+function numberTypeAnnotation() {
   return {
@@ -952,4 +1208,4 @@ type: "NumberTypeAnnotation"
 }
-export function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) {
-  return validateNode({
+function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) {
+  return (0, _validateNode.default)({
     type: "ObjectTypeAnnotation",
@@ -963,4 +1219,4 @@ properties,
 }
-export function objectTypeInternalSlot(id, value, optional, _static, method) {
-  return validateNode({
+function objectTypeInternalSlot(id, value, optional, _static, method) {
+  return (0, _validateNode.default)({
     type: "ObjectTypeInternalSlot",
@@ -974,4 +1230,4 @@ id,
 }
-export function objectTypeCallProperty(value) {
-  return validateNode({
+function objectTypeCallProperty(value) {
+  return (0, _validateNode.default)({
     type: "ObjectTypeCallProperty",
@@ -982,4 +1238,4 @@ value,
 }
-export function objectTypeIndexer(id = null, key, value, variance = null) {
-  return validateNode({
+function objectTypeIndexer(id = null, key, value, variance = null) {
+  return (0, _validateNode.default)({
     type: "ObjectTypeIndexer",
@@ -993,4 +1249,4 @@ id,
 }
-export function objectTypeProperty(key, value, variance = null) {
-  return validateNode({
+function objectTypeProperty(key, value, variance = null) {
+  return (0, _validateNode.default)({
     type: "ObjectTypeProperty",
@@ -1007,4 +1263,4 @@ key,
 }
-export function objectTypeSpreadProperty(argument) {
-  return validateNode({
+function objectTypeSpreadProperty(argument) {
+  return (0, _validateNode.default)({
     type: "ObjectTypeSpreadProperty",
@@ -1014,4 +1270,4 @@ argument
 }
-export function opaqueType(id, typeParameters = null, supertype = null, impltype) {
-  return validateNode({
+function opaqueType(id, typeParameters = null, supertype = null, impltype) {
+  return (0, _validateNode.default)({
     type: "OpaqueType",
@@ -1024,4 +1280,4 @@ id,
 }
-export function qualifiedTypeIdentifier(id, qualification) {
-  return validateNode({
+function qualifiedTypeIdentifier(id, qualification) {
+  return (0, _validateNode.default)({
     type: "QualifiedTypeIdentifier",
@@ -1032,4 +1288,4 @@ id,
 }
-export function stringLiteralTypeAnnotation(value) {
-  return validateNode({
+function stringLiteralTypeAnnotation(value) {
+  return (0, _validateNode.default)({
     type: "StringLiteralTypeAnnotation",
@@ -1039,3 +1295,3 @@ value
 }
-export function stringTypeAnnotation() {
+function stringTypeAnnotation() {
   return {
@@ -1045,3 +1301,3 @@ type: "StringTypeAnnotation"
 }
-export function symbolTypeAnnotation() {
+function symbolTypeAnnotation() {
   return {
@@ -1051,3 +1307,3 @@ type: "SymbolTypeAnnotation"
 }
-export function thisTypeAnnotation() {
+function thisTypeAnnotation() {
   return {
@@ -1057,4 +1313,4 @@ type: "ThisTypeAnnotation"
 }
-export function tupleTypeAnnotation(types) {
-  return validateNode({
+function tupleTypeAnnotation(types) {
+  return (0, _validateNode.default)({
     type: "TupleTypeAnnotation",
@@ -1064,4 +1320,4 @@ types
 }
-export function typeofTypeAnnotation(argument) {
-  return validateNode({
+function typeofTypeAnnotation(argument) {
+  return (0, _validateNode.default)({
     type: "TypeofTypeAnnotation",
@@ -1071,4 +1327,4 @@ argument
 }
-export function typeAlias(id, typeParameters = null, right) {
-  return validateNode({
+function typeAlias(id, typeParameters = null, right) {
+  return (0, _validateNode.default)({
     type: "TypeAlias",
@@ -1080,4 +1336,4 @@ id,
 }
-export function typeAnnotation(typeAnnotation) {
-  return validateNode({
+function typeAnnotation(typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "TypeAnnotation",
@@ -1087,4 +1343,4 @@ typeAnnotation
 }
-export function typeCastExpression(expression, typeAnnotation) {
-  return validateNode({
+function typeCastExpression(expression, typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "TypeCastExpression",
@@ -1095,4 +1351,4 @@ expression,
 }
-export function typeParameter(bound = null, _default = null, variance = null) {
-  return validateNode({
+function typeParameter(bound = null, _default = null, variance = null) {
+  return (0, _validateNode.default)({
     type: "TypeParameter",
@@ -1105,4 +1361,4 @@ bound,
 }
-export function typeParameterDeclaration(params) {
-  return validateNode({
+function typeParameterDeclaration(params) {
+  return (0, _validateNode.default)({
     type: "TypeParameterDeclaration",
@@ -1112,4 +1368,4 @@ params
 }
-export function typeParameterInstantiation(params) {
-  return validateNode({
+function typeParameterInstantiation(params) {
+  return (0, _validateNode.default)({
     type: "TypeParameterInstantiation",
@@ -1119,4 +1375,4 @@ params
 }
-export function unionTypeAnnotation(types) {
-  return validateNode({
+function unionTypeAnnotation(types) {
+  return (0, _validateNode.default)({
     type: "UnionTypeAnnotation",
@@ -1126,4 +1382,4 @@ types
 }
-export function variance(kind) {
-  return validateNode({
+function variance(kind) {
+  return (0, _validateNode.default)({
     type: "Variance",
@@ -1133,3 +1389,3 @@ kind
 }
-export function voidTypeAnnotation() {
+function voidTypeAnnotation() {
   return {
@@ -1139,4 +1395,4 @@ type: "VoidTypeAnnotation"
 }
-export function enumDeclaration(id, body) {
-  return validateNode({
+function enumDeclaration(id, body) {
+  return (0, _validateNode.default)({
     type: "EnumDeclaration",
@@ -1147,4 +1403,4 @@ id,
 }
-export function enumBooleanBody(members) {
-  return validateNode({
+function enumBooleanBody(members) {
+  return (0, _validateNode.default)({
     type: "EnumBooleanBody",
@@ -1156,4 +1412,4 @@ members,
 }
-export function enumNumberBody(members) {
-  return validateNode({
+function enumNumberBody(members) {
+  return (0, _validateNode.default)({
     type: "EnumNumberBody",
@@ -1165,4 +1421,4 @@ members,
 }
-export function enumStringBody(members) {
-  return validateNode({
+function enumStringBody(members) {
+  return (0, _validateNode.default)({
     type: "EnumStringBody",
@@ -1174,4 +1430,4 @@ members,
 }
-export function enumSymbolBody(members) {
-  return validateNode({
+function enumSymbolBody(members) {
+  return (0, _validateNode.default)({
     type: "EnumSymbolBody",
@@ -1182,4 +1438,4 @@ members,
 }
-export function enumBooleanMember(id) {
-  return validateNode({
+function enumBooleanMember(id) {
+  return (0, _validateNode.default)({
     type: "EnumBooleanMember",
@@ -1190,4 +1446,4 @@ id,
 }
-export function enumNumberMember(id, init) {
-  return validateNode({
+function enumNumberMember(id, init) {
+  return (0, _validateNode.default)({
     type: "EnumNumberMember",
@@ -1198,4 +1454,4 @@ id,
 }
-export function enumStringMember(id, init) {
-  return validateNode({
+function enumStringMember(id, init) {
+  return (0, _validateNode.default)({
     type: "EnumStringMember",
@@ -1206,4 +1462,4 @@ id,
 }
-export function enumDefaultedMember(id) {
-  return validateNode({
+function enumDefaultedMember(id) {
+  return (0, _validateNode.default)({
     type: "EnumDefaultedMember",
@@ -1213,4 +1469,4 @@ id
 }
-export function indexedAccessType(objectType, indexType) {
-  return validateNode({
+function indexedAccessType(objectType, indexType) {
+  return (0, _validateNode.default)({
     type: "IndexedAccessType",
@@ -1221,4 +1477,4 @@ objectType,
 }
-export function optionalIndexedAccessType(objectType, indexType) {
-  return validateNode({
+function optionalIndexedAccessType(objectType, indexType) {
+  return (0, _validateNode.default)({
     type: "OptionalIndexedAccessType",
@@ -1230,4 +1486,4 @@ objectType,
 }
-export function jsxAttribute(name, value = null) {
-  return validateNode({
+function jsxAttribute(name, value = null) {
+  return (0, _validateNode.default)({
     type: "JSXAttribute",
@@ -1238,5 +1494,4 @@ name,
 }
-export { jsxAttribute as jSXAttribute };
-export function jsxClosingElement(name) {
-  return validateNode({
+function jsxClosingElement(name) {
+  return (0, _validateNode.default)({
     type: "JSXClosingElement",
@@ -1246,5 +1501,4 @@ name
 }
-export { jsxClosingElement as jSXClosingElement };
-export function jsxElement(openingElement, closingElement = null, children, selfClosing = null) {
-  return validateNode({
+function jsxElement(openingElement, closingElement = null, children, selfClosing = null) {
+  return (0, _validateNode.default)({
     type: "JSXElement",
@@ -1257,4 +1511,3 @@ openingElement,
 }
-export { jsxElement as jSXElement };
-export function jsxEmptyExpression() {
+function jsxEmptyExpression() {
   return {
@@ -1264,5 +1517,4 @@ type: "JSXEmptyExpression"
 }
-export { jsxEmptyExpression as jSXEmptyExpression };
-export function jsxExpressionContainer(expression) {
-  return validateNode({
+function jsxExpressionContainer(expression) {
+  return (0, _validateNode.default)({
     type: "JSXExpressionContainer",
@@ -1272,5 +1524,4 @@ expression
 }
-export { jsxExpressionContainer as jSXExpressionContainer };
-export function jsxSpreadChild(expression) {
-  return validateNode({
+function jsxSpreadChild(expression) {
+  return (0, _validateNode.default)({
     type: "JSXSpreadChild",
@@ -1280,5 +1531,4 @@ expression
 }
-export { jsxSpreadChild as jSXSpreadChild };
-export function jsxIdentifier(name) {
-  return validateNode({
+function jsxIdentifier(name) {
+  return (0, _validateNode.default)({
     type: "JSXIdentifier",
@@ -1288,5 +1538,4 @@ name
 }
-export { jsxIdentifier as jSXIdentifier };
-export function jsxMemberExpression(object, property) {
-  return validateNode({
+function jsxMemberExpression(object, property) {
+  return (0, _validateNode.default)({
     type: "JSXMemberExpression",
@@ -1297,5 +1546,4 @@ object,
 }
-export { jsxMemberExpression as jSXMemberExpression };
-export function jsxNamespacedName(namespace, name) {
-  return validateNode({
+function jsxNamespacedName(namespace, name) {
+  return (0, _validateNode.default)({
     type: "JSXNamespacedName",
@@ -1306,5 +1554,4 @@ namespace,
 }
-export { jsxNamespacedName as jSXNamespacedName };
-export function jsxOpeningElement(name, attributes, selfClosing = false) {
-  return validateNode({
+function jsxOpeningElement(name, attributes, selfClosing = false) {
+  return (0, _validateNode.default)({
     type: "JSXOpeningElement",
@@ -1316,5 +1563,4 @@ name,
 }
-export { jsxOpeningElement as jSXOpeningElement };
-export function jsxSpreadAttribute(argument) {
-  return validateNode({
+function jsxSpreadAttribute(argument) {
+  return (0, _validateNode.default)({
     type: "JSXSpreadAttribute",
@@ -1324,5 +1570,4 @@ argument
 }
-export { jsxSpreadAttribute as jSXSpreadAttribute };
-export function jsxText(value) {
-  return validateNode({
+function jsxText(value) {
+  return (0, _validateNode.default)({
     type: "JSXText",
@@ -1332,5 +1577,4 @@ value
 }
-export { jsxText as jSXText };
-export function jsxFragment(openingFragment, closingFragment, children) {
-  return validateNode({
+function jsxFragment(openingFragment, closingFragment, children) {
+  return (0, _validateNode.default)({
     type: "JSXFragment",
@@ -1342,4 +1586,3 @@ openingFragment,
 }
-export { jsxFragment as jSXFragment };
-export function jsxOpeningFragment() {
+function jsxOpeningFragment() {
   return {
@@ -1349,4 +1592,3 @@ type: "JSXOpeningFragment"
 }
-export { jsxOpeningFragment as jSXOpeningFragment };
-export function jsxClosingFragment() {
+function jsxClosingFragment() {
   return {
@@ -1356,4 +1598,3 @@ type: "JSXClosingFragment"
 }
-export { jsxClosingFragment as jSXClosingFragment };
-export function noop() {
+function noop() {
   return {
@@ -1363,4 +1604,4 @@ type: "Noop"
 }
-export function placeholder(expectedNode, name) {
-  return validateNode({
+function placeholder(expectedNode, name) {
+  return (0, _validateNode.default)({
     type: "Placeholder",
@@ -1371,4 +1612,4 @@ expectedNode,
 }
-export function v8IntrinsicIdentifier(name) {
-  return validateNode({
+function v8IntrinsicIdentifier(name) {
+  return (0, _validateNode.default)({
     type: "V8IntrinsicIdentifier",
@@ -1378,3 +1619,3 @@ name
 }
-export function argumentPlaceholder() {
+function argumentPlaceholder() {
   return {
@@ -1384,4 +1625,4 @@ type: "ArgumentPlaceholder"
 }
-export function bindExpression(object, callee) {
-  return validateNode({
+function bindExpression(object, callee) {
+  return (0, _validateNode.default)({
     type: "BindExpression",
@@ -1392,4 +1633,4 @@ object,
 }
-export function importAttribute(key, value) {
-  return validateNode({
+function importAttribute(key, value) {
+  return (0, _validateNode.default)({
     type: "ImportAttribute",
@@ -1400,4 +1641,4 @@ key,
 }
-export function decorator(expression) {
-  return validateNode({
+function decorator(expression) {
+  return (0, _validateNode.default)({
     type: "Decorator",
@@ -1407,4 +1648,4 @@ expression
 }
-export function doExpression(body, async = false) {
-  return validateNode({
+function doExpression(body, async = false) {
+  return (0, _validateNode.default)({
     type: "DoExpression",
@@ -1415,4 +1656,4 @@ body,
 }
-export function exportDefaultSpecifier(exported) {
-  return validateNode({
+function exportDefaultSpecifier(exported) {
+  return (0, _validateNode.default)({
     type: "ExportDefaultSpecifier",
@@ -1422,4 +1663,4 @@ exported
 }
-export function recordExpression(properties) {
-  return validateNode({
+function recordExpression(properties) {
+  return (0, _validateNode.default)({
     type: "RecordExpression",
@@ -1429,4 +1670,4 @@ properties
 }
-export function tupleExpression(elements = []) {
-  return validateNode({
+function tupleExpression(elements = []) {
+  return (0, _validateNode.default)({
     type: "TupleExpression",
@@ -1436,4 +1677,4 @@ elements
 }
-export function decimalLiteral(value) {
-  return validateNode({
+function decimalLiteral(value) {
+  return (0, _validateNode.default)({
     type: "DecimalLiteral",
@@ -1443,4 +1684,4 @@ value
 }
-export function moduleExpression(body) {
-  return validateNode({
+function moduleExpression(body) {
+  return (0, _validateNode.default)({
     type: "ModuleExpression",
@@ -1450,3 +1691,3 @@ body
 }
-export function topicReference() {
+function topicReference() {
   return {
@@ -1456,4 +1697,4 @@ type: "TopicReference"
 }
-export function pipelineTopicExpression(expression) {
-  return validateNode({
+function pipelineTopicExpression(expression) {
+  return (0, _validateNode.default)({
     type: "PipelineTopicExpression",
@@ -1463,4 +1704,4 @@ expression
 }
-export function pipelineBareFunction(callee) {
-  return validateNode({
+function pipelineBareFunction(callee) {
+  return (0, _validateNode.default)({
     type: "PipelineBareFunction",
@@ -1470,3 +1711,3 @@ callee
 }
-export function pipelinePrimaryTopicReference() {
+function pipelinePrimaryTopicReference() {
   return {
@@ -1476,4 +1717,4 @@ type: "PipelinePrimaryTopicReference"
 }
-export function tsParameterProperty(parameter) {
-  return validateNode({
+function tsParameterProperty(parameter) {
+  return (0, _validateNode.default)({
     type: "TSParameterProperty",
@@ -1483,5 +1724,4 @@ parameter
 }
-export { tsParameterProperty as tSParameterProperty };
-export function tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) {
-  return validateNode({
+function tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) {
+  return (0, _validateNode.default)({
     type: "TSDeclareFunction",
@@ -1494,5 +1734,4 @@ id,
 }
-export { tsDeclareFunction as tSDeclareFunction };
-export function tsDeclareMethod(decorators = null, key, typeParameters = null, params, returnType = null) {
-  return validateNode({
+function tsDeclareMethod(decorators = null, key, typeParameters = null, params, returnType = null) {
+  return (0, _validateNode.default)({
     type: "TSDeclareMethod",
@@ -1506,5 +1745,4 @@ decorators,
 }
-export { tsDeclareMethod as tSDeclareMethod };
-export function tsQualifiedName(left, right) {
-  return validateNode({
+function tsQualifiedName(left, right) {
+  return (0, _validateNode.default)({
     type: "TSQualifiedName",
@@ -1515,5 +1753,4 @@ left,
 }
-export { tsQualifiedName as tSQualifiedName };
-export function tsCallSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {
-  return validateNode({
+function tsCallSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
     type: "TSCallSignatureDeclaration",
@@ -1525,5 +1762,4 @@ typeParameters,
 }
-export { tsCallSignatureDeclaration as tSCallSignatureDeclaration };
-export function tsConstructSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {
-  return validateNode({
+function tsConstructSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
     type: "TSConstructSignatureDeclaration",
@@ -1535,5 +1771,4 @@ typeParameters,
 }
-export { tsConstructSignatureDeclaration as tSConstructSignatureDeclaration };
-export function tsPropertySignature(key, typeAnnotation = null, initializer = null) {
-  return validateNode({
+function tsPropertySignature(key, typeAnnotation = null, initializer = null) {
+  return (0, _validateNode.default)({
     type: "TSPropertySignature",
@@ -1546,5 +1781,4 @@ key,
 }
-export { tsPropertySignature as tSPropertySignature };
-export function tsMethodSignature(key, typeParameters = null, parameters, typeAnnotation = null) {
-  return validateNode({
+function tsMethodSignature(key, typeParameters = null, parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
     type: "TSMethodSignature",
@@ -1558,5 +1792,4 @@ key,
 }
-export { tsMethodSignature as tSMethodSignature };
-export function tsIndexSignature(parameters, typeAnnotation = null) {
-  return validateNode({
+function tsIndexSignature(parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
     type: "TSIndexSignature",
@@ -1567,4 +1800,3 @@ parameters,
 }
-export { tsIndexSignature as tSIndexSignature };
-export function tsAnyKeyword() {
+function tsAnyKeyword() {
   return {
@@ -1574,4 +1806,3 @@ type: "TSAnyKeyword"
 }
-export { tsAnyKeyword as tSAnyKeyword };
-export function tsBooleanKeyword() {
+function tsBooleanKeyword() {
   return {
@@ -1581,4 +1812,3 @@ type: "TSBooleanKeyword"
 }
-export { tsBooleanKeyword as tSBooleanKeyword };
-export function tsBigIntKeyword() {
+function tsBigIntKeyword() {
   return {
@@ -1588,4 +1818,3 @@ type: "TSBigIntKeyword"
 }
-export { tsBigIntKeyword as tSBigIntKeyword };
-export function tsIntrinsicKeyword() {
+function tsIntrinsicKeyword() {
   return {
@@ -1595,4 +1824,3 @@ type: "TSIntrinsicKeyword"
 }
-export { tsIntrinsicKeyword as tSIntrinsicKeyword };
-export function tsNeverKeyword() {
+function tsNeverKeyword() {
   return {
@@ -1602,4 +1830,3 @@ type: "TSNeverKeyword"
 }
-export { tsNeverKeyword as tSNeverKeyword };
-export function tsNullKeyword() {
+function tsNullKeyword() {
   return {
@@ -1609,4 +1836,3 @@ type: "TSNullKeyword"
 }
-export { tsNullKeyword as tSNullKeyword };
-export function tsNumberKeyword() {
+function tsNumberKeyword() {
   return {
@@ -1616,4 +1842,3 @@ type: "TSNumberKeyword"
 }
-export { tsNumberKeyword as tSNumberKeyword };
-export function tsObjectKeyword() {
+function tsObjectKeyword() {
   return {
@@ -1623,4 +1848,3 @@ type: "TSObjectKeyword"
 }
-export { tsObjectKeyword as tSObjectKeyword };
-export function tsStringKeyword() {
+function tsStringKeyword() {
   return {
@@ -1630,4 +1854,3 @@ type: "TSStringKeyword"
 }
-export { tsStringKeyword as tSStringKeyword };
-export function tsSymbolKeyword() {
+function tsSymbolKeyword() {
   return {
@@ -1637,4 +1860,3 @@ type: "TSSymbolKeyword"
 }
-export { tsSymbolKeyword as tSSymbolKeyword };
-export function tsUndefinedKeyword() {
+function tsUndefinedKeyword() {
   return {
@@ -1644,4 +1866,3 @@ type: "TSUndefinedKeyword"
 }
-export { tsUndefinedKeyword as tSUndefinedKeyword };
-export function tsUnknownKeyword() {
+function tsUnknownKeyword() {
   return {
@@ -1651,4 +1872,3 @@ type: "TSUnknownKeyword"
 }
-export { tsUnknownKeyword as tSUnknownKeyword };
-export function tsVoidKeyword() {
+function tsVoidKeyword() {
   return {
@@ -1658,4 +1878,3 @@ type: "TSVoidKeyword"
 }
-export { tsVoidKeyword as tSVoidKeyword };
-export function tsThisType() {
+function tsThisType() {
   return {
@@ -1665,5 +1884,4 @@ type: "TSThisType"
 }
-export { tsThisType as tSThisType };
-export function tsFunctionType(typeParameters = null, parameters, typeAnnotation = null) {
-  return validateNode({
+function tsFunctionType(typeParameters = null, parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
     type: "TSFunctionType",
@@ -1675,5 +1893,4 @@ typeParameters,
 }
-export { tsFunctionType as tSFunctionType };
-export function tsConstructorType(typeParameters = null, parameters, typeAnnotation = null) {
-  return validateNode({
+function tsConstructorType(typeParameters = null, parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
     type: "TSConstructorType",
@@ -1685,5 +1902,4 @@ typeParameters,
 }
-export { tsConstructorType as tSConstructorType };
-export function tsTypeReference(typeName, typeParameters = null) {
-  return validateNode({
+function tsTypeReference(typeName, typeParameters = null) {
+  return (0, _validateNode.default)({
     type: "TSTypeReference",
@@ -1694,5 +1910,4 @@ typeName,
 }
-export { tsTypeReference as tSTypeReference };
-export function tsTypePredicate(parameterName, typeAnnotation = null, asserts = null) {
-  return validateNode({
+function tsTypePredicate(parameterName, typeAnnotation = null, asserts = null) {
+  return (0, _validateNode.default)({
     type: "TSTypePredicate",
@@ -1704,5 +1919,4 @@ parameterName,
 }
-export { tsTypePredicate as tSTypePredicate };
-export function tsTypeQuery(exprName, typeParameters = null) {
-  return validateNode({
+function tsTypeQuery(exprName, typeParameters = null) {
+  return (0, _validateNode.default)({
     type: "TSTypeQuery",
@@ -1713,5 +1927,4 @@ exprName,
 }
-export { tsTypeQuery as tSTypeQuery };
-export function tsTypeLiteral(members) {
-  return validateNode({
+function tsTypeLiteral(members) {
+  return (0, _validateNode.default)({
     type: "TSTypeLiteral",
@@ -1721,5 +1934,4 @@ members
 }
-export { tsTypeLiteral as tSTypeLiteral };
-export function tsArrayType(elementType) {
-  return validateNode({
+function tsArrayType(elementType) {
+  return (0, _validateNode.default)({
     type: "TSArrayType",
@@ -1729,5 +1941,4 @@ elementType
 }
-export { tsArrayType as tSArrayType };
-export function tsTupleType(elementTypes) {
-  return validateNode({
+function tsTupleType(elementTypes) {
+  return (0, _validateNode.default)({
     type: "TSTupleType",
@@ -1737,5 +1948,4 @@ elementTypes
 }
-export { tsTupleType as tSTupleType };
-export function tsOptionalType(typeAnnotation) {
-  return validateNode({
+function tsOptionalType(typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "TSOptionalType",
@@ -1745,5 +1955,4 @@ typeAnnotation
 }
-export { tsOptionalType as tSOptionalType };
-export function tsRestType(typeAnnotation) {
-  return validateNode({
+function tsRestType(typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "TSRestType",
@@ -1753,5 +1962,4 @@ typeAnnotation
 }
-export { tsRestType as tSRestType };
-export function tsNamedTupleMember(label, elementType, optional = false) {
-  return validateNode({
+function tsNamedTupleMember(label, elementType, optional = false) {
+  return (0, _validateNode.default)({
     type: "TSNamedTupleMember",
@@ -1763,5 +1971,4 @@ label,
 }
-export { tsNamedTupleMember as tSNamedTupleMember };
-export function tsUnionType(types) {
-  return validateNode({
+function tsUnionType(types) {
+  return (0, _validateNode.default)({
     type: "TSUnionType",
@@ -1771,5 +1978,4 @@ types
 }
-export { tsUnionType as tSUnionType };
-export function tsIntersectionType(types) {
-  return validateNode({
+function tsIntersectionType(types) {
+  return (0, _validateNode.default)({
     type: "TSIntersectionType",
@@ -1779,5 +1985,4 @@ types
 }
-export { tsIntersectionType as tSIntersectionType };
-export function tsConditionalType(checkType, extendsType, trueType, falseType) {
-  return validateNode({
+function tsConditionalType(checkType, extendsType, trueType, falseType) {
+  return (0, _validateNode.default)({
     type: "TSConditionalType",
@@ -1790,5 +1995,4 @@ checkType,
 }
-export { tsConditionalType as tSConditionalType };
-export function tsInferType(typeParameter) {
-  return validateNode({
+function tsInferType(typeParameter) {
+  return (0, _validateNode.default)({
     type: "TSInferType",
@@ -1798,5 +2002,4 @@ typeParameter
 }
-export { tsInferType as tSInferType };
-export function tsParenthesizedType(typeAnnotation) {
-  return validateNode({
+function tsParenthesizedType(typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "TSParenthesizedType",
@@ -1806,5 +2009,4 @@ typeAnnotation
 }
-export { tsParenthesizedType as tSParenthesizedType };
-export function tsTypeOperator(typeAnnotation) {
-  return validateNode({
+function tsTypeOperator(typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "TSTypeOperator",
@@ -1815,5 +2017,4 @@ typeAnnotation,
 }
-export { tsTypeOperator as tSTypeOperator };
-export function tsIndexedAccessType(objectType, indexType) {
-  return validateNode({
+function tsIndexedAccessType(objectType, indexType) {
+  return (0, _validateNode.default)({
     type: "TSIndexedAccessType",
@@ -1824,5 +2025,4 @@ objectType,
 }
-export { tsIndexedAccessType as tSIndexedAccessType };
-export function tsMappedType(typeParameter, typeAnnotation = null, nameType = null) {
-  return validateNode({
+function tsMappedType(typeParameter, typeAnnotation = null, nameType = null) {
+  return (0, _validateNode.default)({
     type: "TSMappedType",
@@ -1834,5 +2034,4 @@ typeParameter,
 }
-export { tsMappedType as tSMappedType };
-export function tsLiteralType(literal) {
-  return validateNode({
+function tsLiteralType(literal) {
+  return (0, _validateNode.default)({
     type: "TSLiteralType",
@@ -1842,5 +2041,4 @@ literal
 }
-export { tsLiteralType as tSLiteralType };
-export function tsExpressionWithTypeArguments(expression, typeParameters = null) {
-  return validateNode({
+function tsExpressionWithTypeArguments(expression, typeParameters = null) {
+  return (0, _validateNode.default)({
     type: "TSExpressionWithTypeArguments",
@@ -1851,5 +2049,4 @@ expression,
 }
-export { tsExpressionWithTypeArguments as tSExpressionWithTypeArguments };
-export function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) {
-  return validateNode({
+function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) {
+  return (0, _validateNode.default)({
     type: "TSInterfaceDeclaration",
@@ -1862,5 +2059,4 @@ id,
 }
-export { tsInterfaceDeclaration as tSInterfaceDeclaration };
-export function tsInterfaceBody(body) {
-  return validateNode({
+function tsInterfaceBody(body) {
+  return (0, _validateNode.default)({
     type: "TSInterfaceBody",
@@ -1870,5 +2066,4 @@ body
 }
-export { tsInterfaceBody as tSInterfaceBody };
-export function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation) {
-  return validateNode({
+function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "TSTypeAliasDeclaration",
@@ -1880,5 +2075,4 @@ id,
 }
-export { tsTypeAliasDeclaration as tSTypeAliasDeclaration };
-export function tsInstantiationExpression(expression, typeParameters = null) {
-  return validateNode({
+function tsInstantiationExpression(expression, typeParameters = null) {
+  return (0, _validateNode.default)({
     type: "TSInstantiationExpression",
@@ -1889,5 +2083,4 @@ expression,
 }
-export { tsInstantiationExpression as tSInstantiationExpression };
-export function tsAsExpression(expression, typeAnnotation) {
-  return validateNode({
+function tsAsExpression(expression, typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "TSAsExpression",
@@ -1898,5 +2091,4 @@ expression,
 }
-export { tsAsExpression as tSAsExpression };
-export function tsSatisfiesExpression(expression, typeAnnotation) {
-  return validateNode({
+function tsSatisfiesExpression(expression, typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "TSSatisfiesExpression",
@@ -1907,5 +2099,4 @@ expression,
 }
-export { tsSatisfiesExpression as tSSatisfiesExpression };
-export function tsTypeAssertion(typeAnnotation, expression) {
-  return validateNode({
+function tsTypeAssertion(typeAnnotation, expression) {
+  return (0, _validateNode.default)({
     type: "TSTypeAssertion",
@@ -1916,5 +2107,4 @@ typeAnnotation,
 }
-export { tsTypeAssertion as tSTypeAssertion };
-export function tsEnumDeclaration(id, members) {
-  return validateNode({
+function tsEnumDeclaration(id, members) {
+  return (0, _validateNode.default)({
     type: "TSEnumDeclaration",
@@ -1925,5 +2115,4 @@ id,
 }
-export { tsEnumDeclaration as tSEnumDeclaration };
-export function tsEnumMember(id, initializer = null) {
-  return validateNode({
+function tsEnumMember(id, initializer = null) {
+  return (0, _validateNode.default)({
     type: "TSEnumMember",
@@ -1934,5 +2123,4 @@ id,
 }
-export { tsEnumMember as tSEnumMember };
-export function tsModuleDeclaration(id, body) {
-  return validateNode({
+function tsModuleDeclaration(id, body) {
+  return (0, _validateNode.default)({
     type: "TSModuleDeclaration",
@@ -1943,5 +2131,4 @@ id,
 }
-export { tsModuleDeclaration as tSModuleDeclaration };
-export function tsModuleBlock(body) {
-  return validateNode({
+function tsModuleBlock(body) {
+  return (0, _validateNode.default)({
     type: "TSModuleBlock",
@@ -1951,5 +2138,4 @@ body
 }
-export { tsModuleBlock as tSModuleBlock };
-export function tsImportType(argument, qualifier = null, typeParameters = null) {
-  return validateNode({
+function tsImportType(argument, qualifier = null, typeParameters = null) {
+  return (0, _validateNode.default)({
     type: "TSImportType",
@@ -1961,5 +2147,4 @@ argument,
 }
-export { tsImportType as tSImportType };
-export function tsImportEqualsDeclaration(id, moduleReference) {
-  return validateNode({
+function tsImportEqualsDeclaration(id, moduleReference) {
+  return (0, _validateNode.default)({
     type: "TSImportEqualsDeclaration",
@@ -1971,5 +2156,4 @@ id,
 }
-export { tsImportEqualsDeclaration as tSImportEqualsDeclaration };
-export function tsExternalModuleReference(expression) {
-  return validateNode({
+function tsExternalModuleReference(expression) {
+  return (0, _validateNode.default)({
     type: "TSExternalModuleReference",
@@ -1979,5 +2163,4 @@ expression
 }
-export { tsExternalModuleReference as tSExternalModuleReference };
-export function tsNonNullExpression(expression) {
-  return validateNode({
+function tsNonNullExpression(expression) {
+  return (0, _validateNode.default)({
     type: "TSNonNullExpression",
@@ -1987,5 +2170,4 @@ expression
 }
-export { tsNonNullExpression as tSNonNullExpression };
-export function tsExportAssignment(expression) {
-  return validateNode({
+function tsExportAssignment(expression) {
+  return (0, _validateNode.default)({
     type: "TSExportAssignment",
@@ -1995,5 +2177,4 @@ expression
 }
-export { tsExportAssignment as tSExportAssignment };
-export function tsNamespaceExportDeclaration(id) {
-  return validateNode({
+function tsNamespaceExportDeclaration(id) {
+  return (0, _validateNode.default)({
     type: "TSNamespaceExportDeclaration",
@@ -2003,5 +2184,4 @@ id
 }
-export { tsNamespaceExportDeclaration as tSNamespaceExportDeclaration };
-export function tsTypeAnnotation(typeAnnotation) {
-  return validateNode({
+function tsTypeAnnotation(typeAnnotation) {
+  return (0, _validateNode.default)({
     type: "TSTypeAnnotation",
@@ -2011,5 +2191,4 @@ typeAnnotation
 }
-export { tsTypeAnnotation as tSTypeAnnotation };
-export function tsTypeParameterInstantiation(params) {
-  return validateNode({
+function tsTypeParameterInstantiation(params) {
+  return (0, _validateNode.default)({
     type: "TSTypeParameterInstantiation",
@@ -2019,5 +2198,4 @@ params
 }
-export { tsTypeParameterInstantiation as tSTypeParameterInstantiation };
-export function tsTypeParameterDeclaration(params) {
-  return validateNode({
+function tsTypeParameterDeclaration(params) {
+  return (0, _validateNode.default)({
     type: "TSTypeParameterDeclaration",
@@ -2027,5 +2205,4 @@ params
 }
-export { tsTypeParameterDeclaration as tSTypeParameterDeclaration };
-export function tsTypeParameter(constraint = null, _default = null, name) {
-  return validateNode({
+function tsTypeParameter(constraint = null, _default = null, name) {
+  return (0, _validateNode.default)({
     type: "TSTypeParameter",
@@ -2037,24 +2214,19 @@ constraint,
 }
-export { tsTypeParameter as tSTypeParameter };
 function NumberLiteral(value) {
-  deprecationWarning("NumberLiteral", "NumericLiteral", "The node type ");
+  (0, _deprecationWarning.default)("NumberLiteral", "NumericLiteral", "The node type ");
   return numericLiteral(value);
 }
-export { NumberLiteral as numberLiteral };
 function RegexLiteral(pattern, flags = "") {
-  deprecationWarning("RegexLiteral", "RegExpLiteral", "The node type ");
+  (0, _deprecationWarning.default)("RegexLiteral", "RegExpLiteral", "The node type ");
   return regExpLiteral(pattern, flags);
 }
-export { RegexLiteral as regexLiteral };
 function RestProperty(argument) {
-  deprecationWarning("RestProperty", "RestElement", "The node type ");
+  (0, _deprecationWarning.default)("RestProperty", "RestElement", "The node type ");
   return restElement(argument);
 }
-export { RestProperty as restProperty };
 function SpreadProperty(argument) {
-  deprecationWarning("SpreadProperty", "SpreadElement", "The node type ");
+  (0, _deprecationWarning.default)("SpreadProperty", "SpreadElement", "The node type ");
   return spreadElement(argument);
 }
-export { SpreadProperty as spreadProperty };
 
 //# sourceMappingURL=index.js.map

lib/builders/generated/uppercase.js

@@ -1,3 +0,1526 @@
-export { arrayExpression as ArrayExpression, assignmentExpression as AssignmentExpression, binaryExpression as BinaryExpression, interpreterDirective as InterpreterDirective, directive as Directive, directiveLiteral as DirectiveLiteral, blockStatement as BlockStatement, breakStatement as BreakStatement, callExpression as CallExpression, catchClause as CatchClause, conditionalExpression as ConditionalExpression, continueStatement as ContinueStatement, debuggerStatement as DebuggerStatement, doWhileStatement as DoWhileStatement, emptyStatement as EmptyStatement, expressionStatement as ExpressionStatement, file as File, forInStatement as ForInStatement, forStatement as ForStatement, functionDeclaration as FunctionDeclaration, functionExpression as FunctionExpression, identifier as Identifier, ifStatement as IfStatement, labeledStatement as LabeledStatement, stringLiteral as StringLiteral, numericLiteral as NumericLiteral, nullLiteral as NullLiteral, booleanLiteral as BooleanLiteral, regExpLiteral as RegExpLiteral, logicalExpression as LogicalExpression, memberExpression as MemberExpression, newExpression as NewExpression, program as Program, objectExpression as ObjectExpression, objectMethod as ObjectMethod, objectProperty as ObjectProperty, restElement as RestElement, returnStatement as ReturnStatement, sequenceExpression as SequenceExpression, parenthesizedExpression as ParenthesizedExpression, switchCase as SwitchCase, switchStatement as SwitchStatement, thisExpression as ThisExpression, throwStatement as ThrowStatement, tryStatement as TryStatement, unaryExpression as UnaryExpression, updateExpression as UpdateExpression, variableDeclaration as VariableDeclaration, variableDeclarator as VariableDeclarator, whileStatement as WhileStatement, withStatement as WithStatement, assignmentPattern as AssignmentPattern, arrayPattern as ArrayPattern, arrowFunctionExpression as ArrowFunctionExpression, classBody as ClassBody, classExpression as ClassExpression, classDeclaration as ClassDeclaration, exportAllDeclaration as ExportAllDeclaration, exportDefaultDeclaration as ExportDefaultDeclaration, exportNamedDeclaration as ExportNamedDeclaration, exportSpecifier as ExportSpecifier, forOfStatement as ForOfStatement, importDeclaration as ImportDeclaration, importDefaultSpecifier as ImportDefaultSpecifier, importNamespaceSpecifier as ImportNamespaceSpecifier, importSpecifier as ImportSpecifier, metaProperty as MetaProperty, classMethod as ClassMethod, objectPattern as ObjectPattern, spreadElement as SpreadElement, super as Super, taggedTemplateExpression as TaggedTemplateExpression, templateElement as TemplateElement, templateLiteral as TemplateLiteral, yieldExpression as YieldExpression, awaitExpression as AwaitExpression, import as Import, bigIntLiteral as BigIntLiteral, exportNamespaceSpecifier as ExportNamespaceSpecifier, optionalMemberExpression as OptionalMemberExpression, optionalCallExpression as OptionalCallExpression, classProperty as ClassProperty, classAccessorProperty as ClassAccessorProperty, classPrivateProperty as ClassPrivateProperty, classPrivateMethod as ClassPrivateMethod, privateName as PrivateName, staticBlock as StaticBlock, anyTypeAnnotation as AnyTypeAnnotation, arrayTypeAnnotation as ArrayTypeAnnotation, booleanTypeAnnotation as BooleanTypeAnnotation, booleanLiteralTypeAnnotation as BooleanLiteralTypeAnnotation, nullLiteralTypeAnnotation as NullLiteralTypeAnnotation, classImplements as ClassImplements, declareClass as DeclareClass, declareFunction as DeclareFunction, declareInterface as DeclareInterface, declareModule as DeclareModule, declareModuleExports as DeclareModuleExports, declareTypeAlias as DeclareTypeAlias, declareOpaqueType as DeclareOpaqueType, declareVariable as DeclareVariable, declareExportDeclaration as DeclareExportDeclaration, declareExportAllDeclaration as DeclareExportAllDeclaration, declaredPredicate as DeclaredPredicate, existsTypeAnnotation as ExistsTypeAnnotation, functionTypeAnnotation as FunctionTypeAnnotation, functionTypeParam as FunctionTypeParam, genericTypeAnnotation as GenericTypeAnnotation, inferredPredicate as InferredPredicate, interfaceExtends as InterfaceExtends, interfaceDeclaration as InterfaceDeclaration, interfaceTypeAnnotation as InterfaceTypeAnnotation, intersectionTypeAnnotation as IntersectionTypeAnnotation, mixedTypeAnnotation as MixedTypeAnnotation, emptyTypeAnnotation as EmptyTypeAnnotation, nullableTypeAnnotation as NullableTypeAnnotation, numberLiteralTypeAnnotation as NumberLiteralTypeAnnotation, numberTypeAnnotation as NumberTypeAnnotation, objectTypeAnnotation as ObjectTypeAnnotation, objectTypeInternalSlot as ObjectTypeInternalSlot, objectTypeCallProperty as ObjectTypeCallProperty, objectTypeIndexer as ObjectTypeIndexer, objectTypeProperty as ObjectTypeProperty, objectTypeSpreadProperty as ObjectTypeSpreadProperty, opaqueType as OpaqueType, qualifiedTypeIdentifier as QualifiedTypeIdentifier, stringLiteralTypeAnnotation as StringLiteralTypeAnnotation, stringTypeAnnotation as StringTypeAnnotation, symbolTypeAnnotation as SymbolTypeAnnotation, thisTypeAnnotation as ThisTypeAnnotation, tupleTypeAnnotation as TupleTypeAnnotation, typeofTypeAnnotation as TypeofTypeAnnotation, typeAlias as TypeAlias, typeAnnotation as TypeAnnotation, typeCastExpression as TypeCastExpression, typeParameter as TypeParameter, typeParameterDeclaration as TypeParameterDeclaration, typeParameterInstantiation as TypeParameterInstantiation, unionTypeAnnotation as UnionTypeAnnotation, variance as Variance, voidTypeAnnotation as VoidTypeAnnotation, enumDeclaration as EnumDeclaration, enumBooleanBody as EnumBooleanBody, enumNumberBody as EnumNumberBody, enumStringBody as EnumStringBody, enumSymbolBody as EnumSymbolBody, enumBooleanMember as EnumBooleanMember, enumNumberMember as EnumNumberMember, enumStringMember as EnumStringMember, enumDefaultedMember as EnumDefaultedMember, indexedAccessType as IndexedAccessType, optionalIndexedAccessType as OptionalIndexedAccessType, jsxAttribute as JSXAttribute, jsxClosingElement as JSXClosingElement, jsxElement as JSXElement, jsxEmptyExpression as JSXEmptyExpression, jsxExpressionContainer as JSXExpressionContainer, jsxSpreadChild as JSXSpreadChild, jsxIdentifier as JSXIdentifier, jsxMemberExpression as JSXMemberExpression, jsxNamespacedName as JSXNamespacedName, jsxOpeningElement as JSXOpeningElement, jsxSpreadAttribute as JSXSpreadAttribute, jsxText as JSXText, jsxFragment as JSXFragment, jsxOpeningFragment as JSXOpeningFragment, jsxClosingFragment as JSXClosingFragment, noop as Noop, placeholder as Placeholder, v8IntrinsicIdentifier as V8IntrinsicIdentifier, argumentPlaceholder as ArgumentPlaceholder, bindExpression as BindExpression, importAttribute as ImportAttribute, decorator as Decorator, doExpression as DoExpression, exportDefaultSpecifier as ExportDefaultSpecifier, recordExpression as RecordExpression, tupleExpression as TupleExpression, decimalLiteral as DecimalLiteral, moduleExpression as ModuleExpression, topicReference as TopicReference, pipelineTopicExpression as PipelineTopicExpression, pipelineBareFunction as PipelineBareFunction, pipelinePrimaryTopicReference as PipelinePrimaryTopicReference, tsParameterProperty as TSParameterProperty, tsDeclareFunction as TSDeclareFunction, tsDeclareMethod as TSDeclareMethod, tsQualifiedName as TSQualifiedName, tsCallSignatureDeclaration as TSCallSignatureDeclaration, tsConstructSignatureDeclaration as TSConstructSignatureDeclaration, tsPropertySignature as TSPropertySignature, tsMethodSignature as TSMethodSignature, tsIndexSignature as TSIndexSignature, tsAnyKeyword as TSAnyKeyword, tsBooleanKeyword as TSBooleanKeyword, tsBigIntKeyword as TSBigIntKeyword, tsIntrinsicKeyword as TSIntrinsicKeyword, tsNeverKeyword as TSNeverKeyword, tsNullKeyword as TSNullKeyword, tsNumberKeyword as TSNumberKeyword, tsObjectKeyword as TSObjectKeyword, tsStringKeyword as TSStringKeyword, tsSymbolKeyword as TSSymbolKeyword, tsUndefinedKeyword as TSUndefinedKeyword, tsUnknownKeyword as TSUnknownKeyword, tsVoidKeyword as TSVoidKeyword, tsThisType as TSThisType, tsFunctionType as TSFunctionType, tsConstructorType as TSConstructorType, tsTypeReference as TSTypeReference, tsTypePredicate as TSTypePredicate, tsTypeQuery as TSTypeQuery, tsTypeLiteral as TSTypeLiteral, tsArrayType as TSArrayType, tsTupleType as TSTupleType, tsOptionalType as TSOptionalType, tsRestType as TSRestType, tsNamedTupleMember as TSNamedTupleMember, tsUnionType as TSUnionType, tsIntersectionType as TSIntersectionType, tsConditionalType as TSConditionalType, tsInferType as TSInferType, tsParenthesizedType as TSParenthesizedType, tsTypeOperator as TSTypeOperator, tsIndexedAccessType as TSIndexedAccessType, tsMappedType as TSMappedType, tsLiteralType as TSLiteralType, tsExpressionWithTypeArguments as TSExpressionWithTypeArguments, tsInterfaceDeclaration as TSInterfaceDeclaration, tsInterfaceBody as TSInterfaceBody, tsTypeAliasDeclaration as TSTypeAliasDeclaration, tsInstantiationExpression as TSInstantiationExpression, tsAsExpression as TSAsExpression, tsSatisfiesExpression as TSSatisfiesExpression, tsTypeAssertion as TSTypeAssertion, tsEnumDeclaration as TSEnumDeclaration, tsEnumMember as TSEnumMember, tsModuleDeclaration as TSModuleDeclaration, tsModuleBlock as TSModuleBlock, tsImportType as TSImportType, tsImportEqualsDeclaration as TSImportEqualsDeclaration, tsExternalModuleReference as TSExternalModuleReference, tsNonNullExpression as TSNonNullExpression, tsExportAssignment as TSExportAssignment, tsNamespaceExportDeclaration as TSNamespaceExportDeclaration, tsTypeAnnotation as TSTypeAnnotation, tsTypeParameterInstantiation as TSTypeParameterInstantiation, tsTypeParameterDeclaration as TSTypeParameterDeclaration, tsTypeParameter as TSTypeParameter, numberLiteral as NumberLiteral, regexLiteral as RegexLiteral, restProperty as RestProperty, spreadProperty as SpreadProperty } from "./index.js";
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AnyTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.anyTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ArgumentPlaceholder", {
+  enumerable: true,
+  get: function () {
+    return _index.argumentPlaceholder;
+  }
+});
+Object.defineProperty(exports, "ArrayExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.arrayExpression;
+  }
+});
+Object.defineProperty(exports, "ArrayPattern", {
+  enumerable: true,
+  get: function () {
+    return _index.arrayPattern;
+  }
+});
+Object.defineProperty(exports, "ArrayTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.arrayTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ArrowFunctionExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.arrowFunctionExpression;
+  }
+});
+Object.defineProperty(exports, "AssignmentExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.assignmentExpression;
+  }
+});
+Object.defineProperty(exports, "AssignmentPattern", {
+  enumerable: true,
+  get: function () {
+    return _index.assignmentPattern;
+  }
+});
+Object.defineProperty(exports, "AwaitExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.awaitExpression;
+  }
+});
+Object.defineProperty(exports, "BigIntLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.bigIntLiteral;
+  }
+});
+Object.defineProperty(exports, "BinaryExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.binaryExpression;
+  }
+});
+Object.defineProperty(exports, "BindExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.bindExpression;
+  }
+});
+Object.defineProperty(exports, "BlockStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.blockStatement;
+  }
+});
+Object.defineProperty(exports, "BooleanLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.booleanLiteral;
+  }
+});
+Object.defineProperty(exports, "BooleanLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.booleanLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "BooleanTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.booleanTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "BreakStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.breakStatement;
+  }
+});
+Object.defineProperty(exports, "CallExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.callExpression;
+  }
+});
+Object.defineProperty(exports, "CatchClause", {
+  enumerable: true,
+  get: function () {
+    return _index.catchClause;
+  }
+});
+Object.defineProperty(exports, "ClassAccessorProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.classAccessorProperty;
+  }
+});
+Object.defineProperty(exports, "ClassBody", {
+  enumerable: true,
+  get: function () {
+    return _index.classBody;
+  }
+});
+Object.defineProperty(exports, "ClassDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.classDeclaration;
+  }
+});
+Object.defineProperty(exports, "ClassExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.classExpression;
+  }
+});
+Object.defineProperty(exports, "ClassImplements", {
+  enumerable: true,
+  get: function () {
+    return _index.classImplements;
+  }
+});
+Object.defineProperty(exports, "ClassMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.classMethod;
+  }
+});
+Object.defineProperty(exports, "ClassPrivateMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.classPrivateMethod;
+  }
+});
+Object.defineProperty(exports, "ClassPrivateProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.classPrivateProperty;
+  }
+});
+Object.defineProperty(exports, "ClassProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.classProperty;
+  }
+});
+Object.defineProperty(exports, "ConditionalExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.conditionalExpression;
+  }
+});
+Object.defineProperty(exports, "ContinueStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.continueStatement;
+  }
+});
+Object.defineProperty(exports, "DebuggerStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.debuggerStatement;
+  }
+});
+Object.defineProperty(exports, "DecimalLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.decimalLiteral;
+  }
+});
+Object.defineProperty(exports, "DeclareClass", {
+  enumerable: true,
+  get: function () {
+    return _index.declareClass;
+  }
+});
+Object.defineProperty(exports, "DeclareExportAllDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.declareExportAllDeclaration;
+  }
+});
+Object.defineProperty(exports, "DeclareExportDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.declareExportDeclaration;
+  }
+});
+Object.defineProperty(exports, "DeclareFunction", {
+  enumerable: true,
+  get: function () {
+    return _index.declareFunction;
+  }
+});
+Object.defineProperty(exports, "DeclareInterface", {
+  enumerable: true,
+  get: function () {
+    return _index.declareInterface;
+  }
+});
+Object.defineProperty(exports, "DeclareModule", {
+  enumerable: true,
+  get: function () {
+    return _index.declareModule;
+  }
+});
+Object.defineProperty(exports, "DeclareModuleExports", {
+  enumerable: true,
+  get: function () {
+    return _index.declareModuleExports;
+  }
+});
+Object.defineProperty(exports, "DeclareOpaqueType", {
+  enumerable: true,
+  get: function () {
+    return _index.declareOpaqueType;
+  }
+});
+Object.defineProperty(exports, "DeclareTypeAlias", {
+  enumerable: true,
+  get: function () {
+    return _index.declareTypeAlias;
+  }
+});
+Object.defineProperty(exports, "DeclareVariable", {
+  enumerable: true,
+  get: function () {
+    return _index.declareVariable;
+  }
+});
+Object.defineProperty(exports, "DeclaredPredicate", {
+  enumerable: true,
+  get: function () {
+    return _index.declaredPredicate;
+  }
+});
+Object.defineProperty(exports, "Decorator", {
+  enumerable: true,
+  get: function () {
+    return _index.decorator;
+  }
+});
+Object.defineProperty(exports, "Directive", {
+  enumerable: true,
+  get: function () {
+    return _index.directive;
+  }
+});
+Object.defineProperty(exports, "DirectiveLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.directiveLiteral;
+  }
+});
+Object.defineProperty(exports, "DoExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.doExpression;
+  }
+});
+Object.defineProperty(exports, "DoWhileStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.doWhileStatement;
+  }
+});
+Object.defineProperty(exports, "EmptyStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.emptyStatement;
+  }
+});
+Object.defineProperty(exports, "EmptyTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.emptyTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "EnumBooleanBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumBooleanBody;
+  }
+});
+Object.defineProperty(exports, "EnumBooleanMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumBooleanMember;
+  }
+});
+Object.defineProperty(exports, "EnumDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.enumDeclaration;
+  }
+});
+Object.defineProperty(exports, "EnumDefaultedMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumDefaultedMember;
+  }
+});
+Object.defineProperty(exports, "EnumNumberBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumNumberBody;
+  }
+});
+Object.defineProperty(exports, "EnumNumberMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumNumberMember;
+  }
+});
+Object.defineProperty(exports, "EnumStringBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumStringBody;
+  }
+});
+Object.defineProperty(exports, "EnumStringMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumStringMember;
+  }
+});
+Object.defineProperty(exports, "EnumSymbolBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumSymbolBody;
+  }
+});
+Object.defineProperty(exports, "ExistsTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.existsTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ExportAllDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.exportAllDeclaration;
+  }
+});
+Object.defineProperty(exports, "ExportDefaultDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.exportDefaultDeclaration;
+  }
+});
+Object.defineProperty(exports, "ExportDefaultSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.exportDefaultSpecifier;
+  }
+});
+Object.defineProperty(exports, "ExportNamedDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.exportNamedDeclaration;
+  }
+});
+Object.defineProperty(exports, "ExportNamespaceSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.exportNamespaceSpecifier;
+  }
+});
+Object.defineProperty(exports, "ExportSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.exportSpecifier;
+  }
+});
+Object.defineProperty(exports, "ExpressionStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.expressionStatement;
+  }
+});
+Object.defineProperty(exports, "File", {
+  enumerable: true,
+  get: function () {
+    return _index.file;
+  }
+});
+Object.defineProperty(exports, "ForInStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.forInStatement;
+  }
+});
+Object.defineProperty(exports, "ForOfStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.forOfStatement;
+  }
+});
+Object.defineProperty(exports, "ForStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.forStatement;
+  }
+});
+Object.defineProperty(exports, "FunctionDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.functionDeclaration;
+  }
+});
+Object.defineProperty(exports, "FunctionExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.functionExpression;
+  }
+});
+Object.defineProperty(exports, "FunctionTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.functionTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "FunctionTypeParam", {
+  enumerable: true,
+  get: function () {
+    return _index.functionTypeParam;
+  }
+});
+Object.defineProperty(exports, "GenericTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.genericTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "Identifier", {
+  enumerable: true,
+  get: function () {
+    return _index.identifier;
+  }
+});
+Object.defineProperty(exports, "IfStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.ifStatement;
+  }
+});
+Object.defineProperty(exports, "Import", {
+  enumerable: true,
+  get: function () {
+    return _index.import;
+  }
+});
+Object.defineProperty(exports, "ImportAttribute", {
+  enumerable: true,
+  get: function () {
+    return _index.importAttribute;
+  }
+});
+Object.defineProperty(exports, "ImportDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.importDeclaration;
+  }
+});
+Object.defineProperty(exports, "ImportDefaultSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.importDefaultSpecifier;
+  }
+});
+Object.defineProperty(exports, "ImportNamespaceSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.importNamespaceSpecifier;
+  }
+});
+Object.defineProperty(exports, "ImportSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.importSpecifier;
+  }
+});
+Object.defineProperty(exports, "IndexedAccessType", {
+  enumerable: true,
+  get: function () {
+    return _index.indexedAccessType;
+  }
+});
+Object.defineProperty(exports, "InferredPredicate", {
+  enumerable: true,
+  get: function () {
+    return _index.inferredPredicate;
+  }
+});
+Object.defineProperty(exports, "InterfaceDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.interfaceDeclaration;
+  }
+});
+Object.defineProperty(exports, "InterfaceExtends", {
+  enumerable: true,
+  get: function () {
+    return _index.interfaceExtends;
+  }
+});
+Object.defineProperty(exports, "InterfaceTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.interfaceTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "InterpreterDirective", {
+  enumerable: true,
+  get: function () {
+    return _index.interpreterDirective;
+  }
+});
+Object.defineProperty(exports, "IntersectionTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.intersectionTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "JSXAttribute", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxAttribute;
+  }
+});
+Object.defineProperty(exports, "JSXClosingElement", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxClosingElement;
+  }
+});
+Object.defineProperty(exports, "JSXClosingFragment", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxClosingFragment;
+  }
+});
+Object.defineProperty(exports, "JSXElement", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxElement;
+  }
+});
+Object.defineProperty(exports, "JSXEmptyExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxEmptyExpression;
+  }
+});
+Object.defineProperty(exports, "JSXExpressionContainer", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxExpressionContainer;
+  }
+});
+Object.defineProperty(exports, "JSXFragment", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxFragment;
+  }
+});
+Object.defineProperty(exports, "JSXIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxIdentifier;
+  }
+});
+Object.defineProperty(exports, "JSXMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxMemberExpression;
+  }
+});
+Object.defineProperty(exports, "JSXNamespacedName", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxNamespacedName;
+  }
+});
+Object.defineProperty(exports, "JSXOpeningElement", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxOpeningElement;
+  }
+});
+Object.defineProperty(exports, "JSXOpeningFragment", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxOpeningFragment;
+  }
+});
+Object.defineProperty(exports, "JSXSpreadAttribute", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxSpreadAttribute;
+  }
+});
+Object.defineProperty(exports, "JSXSpreadChild", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxSpreadChild;
+  }
+});
+Object.defineProperty(exports, "JSXText", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxText;
+  }
+});
+Object.defineProperty(exports, "LabeledStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.labeledStatement;
+  }
+});
+Object.defineProperty(exports, "LogicalExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.logicalExpression;
+  }
+});
+Object.defineProperty(exports, "MemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.memberExpression;
+  }
+});
+Object.defineProperty(exports, "MetaProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.metaProperty;
+  }
+});
+Object.defineProperty(exports, "MixedTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.mixedTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ModuleExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.moduleExpression;
+  }
+});
+Object.defineProperty(exports, "NewExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.newExpression;
+  }
+});
+Object.defineProperty(exports, "Noop", {
+  enumerable: true,
+  get: function () {
+    return _index.noop;
+  }
+});
+Object.defineProperty(exports, "NullLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.nullLiteral;
+  }
+});
+Object.defineProperty(exports, "NullLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.nullLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NullableTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.nullableTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NumberLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.numberLiteral;
+  }
+});
+Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.numberLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NumberTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.numberTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NumericLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.numericLiteral;
+  }
+});
+Object.defineProperty(exports, "ObjectExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.objectExpression;
+  }
+});
+Object.defineProperty(exports, "ObjectMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.objectMethod;
+  }
+});
+Object.defineProperty(exports, "ObjectPattern", {
+  enumerable: true,
+  get: function () {
+    return _index.objectPattern;
+  }
+});
+Object.defineProperty(exports, "ObjectProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectProperty;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeCallProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeCallProperty;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeIndexer", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeIndexer;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeInternalSlot", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeInternalSlot;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeProperty;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeSpreadProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeSpreadProperty;
+  }
+});
+Object.defineProperty(exports, "OpaqueType", {
+  enumerable: true,
+  get: function () {
+    return _index.opaqueType;
+  }
+});
+Object.defineProperty(exports, "OptionalCallExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.optionalCallExpression;
+  }
+});
+Object.defineProperty(exports, "OptionalIndexedAccessType", {
+  enumerable: true,
+  get: function () {
+    return _index.optionalIndexedAccessType;
+  }
+});
+Object.defineProperty(exports, "OptionalMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.optionalMemberExpression;
+  }
+});
+Object.defineProperty(exports, "ParenthesizedExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.parenthesizedExpression;
+  }
+});
+Object.defineProperty(exports, "PipelineBareFunction", {
+  enumerable: true,
+  get: function () {
+    return _index.pipelineBareFunction;
+  }
+});
+Object.defineProperty(exports, "PipelinePrimaryTopicReference", {
+  enumerable: true,
+  get: function () {
+    return _index.pipelinePrimaryTopicReference;
+  }
+});
+Object.defineProperty(exports, "PipelineTopicExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.pipelineTopicExpression;
+  }
+});
+Object.defineProperty(exports, "Placeholder", {
+  enumerable: true,
+  get: function () {
+    return _index.placeholder;
+  }
+});
+Object.defineProperty(exports, "PrivateName", {
+  enumerable: true,
+  get: function () {
+    return _index.privateName;
+  }
+});
+Object.defineProperty(exports, "Program", {
+  enumerable: true,
+  get: function () {
+    return _index.program;
+  }
+});
+Object.defineProperty(exports, "QualifiedTypeIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _index.qualifiedTypeIdentifier;
+  }
+});
+Object.defineProperty(exports, "RecordExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.recordExpression;
+  }
+});
+Object.defineProperty(exports, "RegExpLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.regExpLiteral;
+  }
+});
+Object.defineProperty(exports, "RegexLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.regexLiteral;
+  }
+});
+Object.defineProperty(exports, "RestElement", {
+  enumerable: true,
+  get: function () {
+    return _index.restElement;
+  }
+});
+Object.defineProperty(exports, "RestProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.restProperty;
+  }
+});
+Object.defineProperty(exports, "ReturnStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.returnStatement;
+  }
+});
+Object.defineProperty(exports, "SequenceExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.sequenceExpression;
+  }
+});
+Object.defineProperty(exports, "SpreadElement", {
+  enumerable: true,
+  get: function () {
+    return _index.spreadElement;
+  }
+});
+Object.defineProperty(exports, "SpreadProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.spreadProperty;
+  }
+});
+Object.defineProperty(exports, "StaticBlock", {
+  enumerable: true,
+  get: function () {
+    return _index.staticBlock;
+  }
+});
+Object.defineProperty(exports, "StringLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.stringLiteral;
+  }
+});
+Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.stringLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "StringTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.stringTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "Super", {
+  enumerable: true,
+  get: function () {
+    return _index.super;
+  }
+});
+Object.defineProperty(exports, "SwitchCase", {
+  enumerable: true,
+  get: function () {
+    return _index.switchCase;
+  }
+});
+Object.defineProperty(exports, "SwitchStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.switchStatement;
+  }
+});
+Object.defineProperty(exports, "SymbolTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.symbolTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "TSAnyKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsAnyKeyword;
+  }
+});
+Object.defineProperty(exports, "TSArrayType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsArrayType;
+  }
+});
+Object.defineProperty(exports, "TSAsExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tsAsExpression;
+  }
+});
+Object.defineProperty(exports, "TSBigIntKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsBigIntKeyword;
+  }
+});
+Object.defineProperty(exports, "TSBooleanKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsBooleanKeyword;
+  }
+});
+Object.defineProperty(exports, "TSCallSignatureDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsCallSignatureDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSConditionalType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsConditionalType;
+  }
+});
+Object.defineProperty(exports, "TSConstructSignatureDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsConstructSignatureDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSConstructorType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsConstructorType;
+  }
+});
+Object.defineProperty(exports, "TSDeclareFunction", {
+  enumerable: true,
+  get: function () {
+    return _index.tsDeclareFunction;
+  }
+});
+Object.defineProperty(exports, "TSDeclareMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.tsDeclareMethod;
+  }
+});
+Object.defineProperty(exports, "TSEnumDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsEnumDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSEnumMember", {
+  enumerable: true,
+  get: function () {
+    return _index.tsEnumMember;
+  }
+});
+Object.defineProperty(exports, "TSExportAssignment", {
+  enumerable: true,
+  get: function () {
+    return _index.tsExportAssignment;
+  }
+});
+Object.defineProperty(exports, "TSExpressionWithTypeArguments", {
+  enumerable: true,
+  get: function () {
+    return _index.tsExpressionWithTypeArguments;
+  }
+});
+Object.defineProperty(exports, "TSExternalModuleReference", {
+  enumerable: true,
+  get: function () {
+    return _index.tsExternalModuleReference;
+  }
+});
+Object.defineProperty(exports, "TSFunctionType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsFunctionType;
+  }
+});
+Object.defineProperty(exports, "TSImportEqualsDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsImportEqualsDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSImportType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsImportType;
+  }
+});
+Object.defineProperty(exports, "TSIndexSignature", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIndexSignature;
+  }
+});
+Object.defineProperty(exports, "TSIndexedAccessType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIndexedAccessType;
+  }
+});
+Object.defineProperty(exports, "TSInferType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInferType;
+  }
+});
+Object.defineProperty(exports, "TSInstantiationExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInstantiationExpression;
+  }
+});
+Object.defineProperty(exports, "TSInterfaceBody", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInterfaceBody;
+  }
+});
+Object.defineProperty(exports, "TSInterfaceDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInterfaceDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSIntersectionType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIntersectionType;
+  }
+});
+Object.defineProperty(exports, "TSIntrinsicKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIntrinsicKeyword;
+  }
+});
+Object.defineProperty(exports, "TSLiteralType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsLiteralType;
+  }
+});
+Object.defineProperty(exports, "TSMappedType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsMappedType;
+  }
+});
+Object.defineProperty(exports, "TSMethodSignature", {
+  enumerable: true,
+  get: function () {
+    return _index.tsMethodSignature;
+  }
+});
+Object.defineProperty(exports, "TSModuleBlock", {
+  enumerable: true,
+  get: function () {
+    return _index.tsModuleBlock;
+  }
+});
+Object.defineProperty(exports, "TSModuleDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsModuleDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSNamedTupleMember", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNamedTupleMember;
+  }
+});
+Object.defineProperty(exports, "TSNamespaceExportDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNamespaceExportDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSNeverKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNeverKeyword;
+  }
+});
+Object.defineProperty(exports, "TSNonNullExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNonNullExpression;
+  }
+});
+Object.defineProperty(exports, "TSNullKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNullKeyword;
+  }
+});
+Object.defineProperty(exports, "TSNumberKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNumberKeyword;
+  }
+});
+Object.defineProperty(exports, "TSObjectKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsObjectKeyword;
+  }
+});
+Object.defineProperty(exports, "TSOptionalType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsOptionalType;
+  }
+});
+Object.defineProperty(exports, "TSParameterProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.tsParameterProperty;
+  }
+});
+Object.defineProperty(exports, "TSParenthesizedType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsParenthesizedType;
+  }
+});
+Object.defineProperty(exports, "TSPropertySignature", {
+  enumerable: true,
+  get: function () {
+    return _index.tsPropertySignature;
+  }
+});
+Object.defineProperty(exports, "TSQualifiedName", {
+  enumerable: true,
+  get: function () {
+    return _index.tsQualifiedName;
+  }
+});
+Object.defineProperty(exports, "TSRestType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsRestType;
+  }
+});
+Object.defineProperty(exports, "TSSatisfiesExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tsSatisfiesExpression;
+  }
+});
+Object.defineProperty(exports, "TSStringKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsStringKeyword;
+  }
+});
+Object.defineProperty(exports, "TSSymbolKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsSymbolKeyword;
+  }
+});
+Object.defineProperty(exports, "TSThisType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsThisType;
+  }
+});
+Object.defineProperty(exports, "TSTupleType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTupleType;
+  }
+});
+Object.defineProperty(exports, "TSTypeAliasDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeAliasDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "TSTypeAssertion", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeAssertion;
+  }
+});
+Object.defineProperty(exports, "TSTypeLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeLiteral;
+  }
+});
+Object.defineProperty(exports, "TSTypeOperator", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeOperator;
+  }
+});
+Object.defineProperty(exports, "TSTypeParameter", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeParameter;
+  }
+});
+Object.defineProperty(exports, "TSTypeParameterDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeParameterDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSTypeParameterInstantiation", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeParameterInstantiation;
+  }
+});
+Object.defineProperty(exports, "TSTypePredicate", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypePredicate;
+  }
+});
+Object.defineProperty(exports, "TSTypeQuery", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeQuery;
+  }
+});
+Object.defineProperty(exports, "TSTypeReference", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeReference;
+  }
+});
+Object.defineProperty(exports, "TSUndefinedKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsUndefinedKeyword;
+  }
+});
+Object.defineProperty(exports, "TSUnionType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsUnionType;
+  }
+});
+Object.defineProperty(exports, "TSUnknownKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsUnknownKeyword;
+  }
+});
+Object.defineProperty(exports, "TSVoidKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsVoidKeyword;
+  }
+});
+Object.defineProperty(exports, "TaggedTemplateExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.taggedTemplateExpression;
+  }
+});
+Object.defineProperty(exports, "TemplateElement", {
+  enumerable: true,
+  get: function () {
+    return _index.templateElement;
+  }
+});
+Object.defineProperty(exports, "TemplateLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.templateLiteral;
+  }
+});
+Object.defineProperty(exports, "ThisExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.thisExpression;
+  }
+});
+Object.defineProperty(exports, "ThisTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.thisTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ThrowStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.throwStatement;
+  }
+});
+Object.defineProperty(exports, "TopicReference", {
+  enumerable: true,
+  get: function () {
+    return _index.topicReference;
+  }
+});
+Object.defineProperty(exports, "TryStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.tryStatement;
+  }
+});
+Object.defineProperty(exports, "TupleExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tupleExpression;
+  }
+});
+Object.defineProperty(exports, "TupleTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.tupleTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "TypeAlias", {
+  enumerable: true,
+  get: function () {
+    return _index.typeAlias;
+  }
+});
+Object.defineProperty(exports, "TypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.typeAnnotation;
+  }
+});
+Object.defineProperty(exports, "TypeCastExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.typeCastExpression;
+  }
+});
+Object.defineProperty(exports, "TypeParameter", {
+  enumerable: true,
+  get: function () {
+    return _index.typeParameter;
+  }
+});
+Object.defineProperty(exports, "TypeParameterDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.typeParameterDeclaration;
+  }
+});
+Object.defineProperty(exports, "TypeParameterInstantiation", {
+  enumerable: true,
+  get: function () {
+    return _index.typeParameterInstantiation;
+  }
+});
+Object.defineProperty(exports, "TypeofTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.typeofTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "UnaryExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.unaryExpression;
+  }
+});
+Object.defineProperty(exports, "UnionTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.unionTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "UpdateExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.updateExpression;
+  }
+});
+Object.defineProperty(exports, "V8IntrinsicIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _index.v8IntrinsicIdentifier;
+  }
+});
+Object.defineProperty(exports, "VariableDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.variableDeclaration;
+  }
+});
+Object.defineProperty(exports, "VariableDeclarator", {
+  enumerable: true,
+  get: function () {
+    return _index.variableDeclarator;
+  }
+});
+Object.defineProperty(exports, "Variance", {
+  enumerable: true,
+  get: function () {
+    return _index.variance;
+  }
+});
+Object.defineProperty(exports, "VoidTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.voidTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "WhileStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.whileStatement;
+  }
+});
+Object.defineProperty(exports, "WithStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.withStatement;
+  }
+});
+Object.defineProperty(exports, "YieldExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.yieldExpression;
+  }
+});
+var _index = require("./index");
+
 //# sourceMappingURL=uppercase.js.map

lib/builders/react/buildChildren.js

@@ -1,13 +0,19 @@
-import { isJSXText, isJSXExpressionContainer, isJSXEmptyExpression } from "../../validators/generated/index.js";
-import cleanJSXElementLiteralChild from "../../utils/react/cleanJSXElementLiteralChild.js";
-export default function buildChildren(node) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildChildren;
+var _generated = require("../../validators/generated");
+var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild");
+function buildChildren(node) {
   const elements = [];
   for (let i = 0; i < node.children.length; i++) {
     let child = node.children[i];
-    if (isJSXText(child)) {
-      cleanJSXElementLiteralChild(child, elements);
+    if ((0, _generated.isJSXText)(child)) {
+      (0, _cleanJSXElementLiteralChild.default)(child, elements);
       continue;
     }
-    if (isJSXExpressionContainer(child)) child = child.expression;
-    if (isJSXEmptyExpression(child)) continue;
+    if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression;
+    if ((0, _generated.isJSXEmptyExpression)(child)) continue;
     elements.push(child);
@@ -14,0 +20,0 @@ }

lib/builders/typescript/createTSUnionType.js

@@ -1,13 +0,19 @@
-import { tsUnionType } from "../generated/index.js";
-import removeTypeDuplicates from "../../modifications/typescript/removeTypeDuplicates.js";
-import { isTSTypeAnnotation } from "../../validators/generated/index.js";
-export default function createTSUnionType(typeAnnotations) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createTSUnionType;
+var _generated = require("../generated");
+var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates");
+var _index = require("../../validators/generated/index");
+function createTSUnionType(typeAnnotations) {
   const types = typeAnnotations.map(type => {
-    return isTSTypeAnnotation(type) ? type.typeAnnotation : type;
+    return (0, _index.isTSTypeAnnotation)(type) ? type.typeAnnotation : type;
   });
-  const flattened = removeTypeDuplicates(types);
+  const flattened = (0, _removeTypeDuplicates.default)(types);
   if (flattened.length === 1) {
     return flattened[0];
   } else {
-    return tsUnionType(flattened);
+    return (0, _generated.tsUnionType)(flattened);
   }
@@ -14,0 +20,0 @@ }

lib/builders/validateNode.js

@@ -1,7 +0,13 @@
-import validate from "../validators/validate.js";
-import { BUILDER_KEYS } from "../index.js";
-export default function validateNode(node) {
-  const keys = BUILDER_KEYS[node.type];
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = validateNode;
+var _validate = require("../validators/validate");
+var _ = require("..");
+function validateNode(node) {
+  const keys = _.BUILDER_KEYS[node.type];
   for (const key of keys) {
-    validate(node, key, node[key]);
+    (0, _validate.default)(node, key, node[key]);
   }
@@ -8,0 +14,0 @@ return node;

lib/clone/clone.js

@@ -1,6 +0,12 @@
-import cloneNode from "./cloneNode.js";
-export default function clone(node) {
-  return cloneNode(node, false);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = clone;
+var _cloneNode = require("./cloneNode");
+function clone(node) {
+  return (0, _cloneNode.default)(node, false);
 }
 
 //# sourceMappingURL=clone.js.map

lib/clone/cloneDeep.js

@@ -1,6 +0,12 @@
-import cloneNode from "./cloneNode.js";
-export default function cloneDeep(node) {
-  return cloneNode(node);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneDeep;
+var _cloneNode = require("./cloneNode");
+function cloneDeep(node) {
+  return (0, _cloneNode.default)(node);
 }
 
 //# sourceMappingURL=cloneDeep.js.map

lib/clone/cloneDeepWithoutLoc.js

@@ -1,6 +0,12 @@
-import cloneNode from "./cloneNode.js";
-export default function cloneDeepWithoutLoc(node) {
-  return cloneNode(node, true, true);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneDeepWithoutLoc;
+var _cloneNode = require("./cloneNode");
+function cloneDeepWithoutLoc(node) {
+  return (0, _cloneNode.default)(node, true, true);
 }
 
 //# sourceMappingURL=cloneDeepWithoutLoc.js.map

lib/clone/cloneNode.js

@@ -1,3 +0,9 @@
-import { NODE_FIELDS } from "../definitions/index.js";
-import { isFile, isIdentifier } from "../validators/generated/index.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneNode;
+var _definitions = require("../definitions");
+var _generated = require("../validators/generated");
 const has = Function.call.bind(Object.prototype.hasOwnProperty);
@@ -16,3 +22,3 @@ function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
 }
-export default function cloneNode(node, deep = true, withoutLoc = false) {
+function cloneNode(node, deep = true, withoutLoc = false) {
   return cloneNodeInternal(node, deep, withoutLoc, new Map());
@@ -28,3 +34,3 @@ }
   };
-  if (isIdentifier(node)) {
+  if ((0, _generated.isIdentifier)(node)) {
     newNode.name = node.name;
@@ -37,9 +43,9 @@ if (has(node, "optional") && typeof node.optional === "boolean") {
     }
-  } else if (!has(NODE_FIELDS, type)) {
+  } else if (!has(_definitions.NODE_FIELDS, type)) {
     throw new Error(`Unknown node type: "${type}"`);
   } else {
-    for (const field of Object.keys(NODE_FIELDS[type])) {
+    for (const field of Object.keys(_definitions.NODE_FIELDS[type])) {
       if (has(node, field)) {
         if (deep) {
-          newNode[field] = isFile(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache);
+          newNode[field] = (0, _generated.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache);
         } else {
@@ -46,0 +52,0 @@ newNode[field] = node[field];

lib/clone/cloneWithoutLoc.js

@@ -1,6 +0,12 @@
-import cloneNode from "./cloneNode.js";
-export default function cloneWithoutLoc(node) {
-  return cloneNode(node, false, true);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneWithoutLoc;
+var _cloneNode = require("./cloneNode");
+function cloneWithoutLoc(node) {
+  return (0, _cloneNode.default)(node, false, true);
 }
 
 //# sourceMappingURL=cloneWithoutLoc.js.map

lib/comments/addComment.js

@@ -1,4 +0,10 @@
-import addComments from "./addComments.js";
-export default function addComment(node, type, content, line) {
-  return addComments(node, type, [{
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addComment;
+var _addComments = require("./addComments");
+function addComment(node, type, content, line) {
+  return (0, _addComments.default)(node, type, [{
     type: line ? "CommentLine" : "CommentBlock",
@@ -5,0 +11,0 @@ value: content

lib/comments/addComments.js

@@ -1,2 +0,8 @@
-export default function addComments(node, type, comments) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addComments;
+function addComments(node, type, comments) {
   if (!comments || !node) return node;
@@ -3,0 +9,0 @@ const key = `${type}Comments`;

lib/comments/inheritInnerComments.js

@@ -1,6 +0,12 @@
-import inherit from "../utils/inherit.js";
-export default function inheritInnerComments(child, parent) {
-  inherit("innerComments", child, parent);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritInnerComments;
+var _inherit = require("../utils/inherit");
+function inheritInnerComments(child, parent) {
+  (0, _inherit.default)("innerComments", child, parent);
 }
 
 //# sourceMappingURL=inheritInnerComments.js.map

lib/comments/inheritLeadingComments.js

@@ -1,6 +0,12 @@
-import inherit from "../utils/inherit.js";
-export default function inheritLeadingComments(child, parent) {
-  inherit("leadingComments", child, parent);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritLeadingComments;
+var _inherit = require("../utils/inherit");
+function inheritLeadingComments(child, parent) {
+  (0, _inherit.default)("leadingComments", child, parent);
 }
 
 //# sourceMappingURL=inheritLeadingComments.js.map

lib/comments/inheritsComments.js

@@ -1,8 +0,14 @@
-import inheritTrailingComments from "./inheritTrailingComments.js";
-import inheritLeadingComments from "./inheritLeadingComments.js";
-import inheritInnerComments from "./inheritInnerComments.js";
-export default function inheritsComments(child, parent) {
-  inheritTrailingComments(child, parent);
-  inheritLeadingComments(child, parent);
-  inheritInnerComments(child, parent);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritsComments;
+var _inheritTrailingComments = require("./inheritTrailingComments");
+var _inheritLeadingComments = require("./inheritLeadingComments");
+var _inheritInnerComments = require("./inheritInnerComments");
+function inheritsComments(child, parent) {
+  (0, _inheritTrailingComments.default)(child, parent);
+  (0, _inheritLeadingComments.default)(child, parent);
+  (0, _inheritInnerComments.default)(child, parent);
   return child;
@@ -9,0 +15,0 @@ }

lib/comments/inheritTrailingComments.js

@@ -1,6 +0,12 @@
-import inherit from "../utils/inherit.js";
-export default function inheritTrailingComments(child, parent) {
-  inherit("trailingComments", child, parent);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritTrailingComments;
+var _inherit = require("../utils/inherit");
+function inheritTrailingComments(child, parent) {
+  (0, _inherit.default)("trailingComments", child, parent);
 }
 
 //# sourceMappingURL=inheritTrailingComments.js.map

lib/comments/removeComments.js

@@ -1,4 +0,10 @@
-import { COMMENT_KEYS } from "../constants/index.js";
-export default function removeComments(node) {
-  COMMENT_KEYS.forEach(key => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeComments;
+var _constants = require("../constants");
+function removeComments(node) {
+  _constants.COMMENT_KEYS.forEach(key => {
     node[key] = null;
@@ -5,0 +11,0 @@ });

lib/constants/generated/index.js

@@ -1,53 +0,109 @@
-import { FLIPPED_ALIAS_KEYS } from "../../definitions/index.js";
-export const STANDARDIZED_TYPES = FLIPPED_ALIAS_KEYS["Standardized"];
-export const EXPRESSION_TYPES = FLIPPED_ALIAS_KEYS["Expression"];
-export const BINARY_TYPES = FLIPPED_ALIAS_KEYS["Binary"];
-export const SCOPABLE_TYPES = FLIPPED_ALIAS_KEYS["Scopable"];
-export const BLOCKPARENT_TYPES = FLIPPED_ALIAS_KEYS["BlockParent"];
-export const BLOCK_TYPES = FLIPPED_ALIAS_KEYS["Block"];
-export const STATEMENT_TYPES = FLIPPED_ALIAS_KEYS["Statement"];
-export const TERMINATORLESS_TYPES = FLIPPED_ALIAS_KEYS["Terminatorless"];
-export const COMPLETIONSTATEMENT_TYPES = FLIPPED_ALIAS_KEYS["CompletionStatement"];
-export const CONDITIONAL_TYPES = FLIPPED_ALIAS_KEYS["Conditional"];
-export const LOOP_TYPES = FLIPPED_ALIAS_KEYS["Loop"];
-export const WHILE_TYPES = FLIPPED_ALIAS_KEYS["While"];
-export const EXPRESSIONWRAPPER_TYPES = FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
-export const FOR_TYPES = FLIPPED_ALIAS_KEYS["For"];
-export const FORXSTATEMENT_TYPES = FLIPPED_ALIAS_KEYS["ForXStatement"];
-export const FUNCTION_TYPES = FLIPPED_ALIAS_KEYS["Function"];
-export const FUNCTIONPARENT_TYPES = FLIPPED_ALIAS_KEYS["FunctionParent"];
-export const PUREISH_TYPES = FLIPPED_ALIAS_KEYS["Pureish"];
-export const DECLARATION_TYPES = FLIPPED_ALIAS_KEYS["Declaration"];
-export const PATTERNLIKE_TYPES = FLIPPED_ALIAS_KEYS["PatternLike"];
-export const LVAL_TYPES = FLIPPED_ALIAS_KEYS["LVal"];
-export const TSENTITYNAME_TYPES = FLIPPED_ALIAS_KEYS["TSEntityName"];
-export const LITERAL_TYPES = FLIPPED_ALIAS_KEYS["Literal"];
-export const IMMUTABLE_TYPES = FLIPPED_ALIAS_KEYS["Immutable"];
-export const USERWHITESPACABLE_TYPES = FLIPPED_ALIAS_KEYS["UserWhitespacable"];
-export const METHOD_TYPES = FLIPPED_ALIAS_KEYS["Method"];
-export const OBJECTMEMBER_TYPES = FLIPPED_ALIAS_KEYS["ObjectMember"];
-export const PROPERTY_TYPES = FLIPPED_ALIAS_KEYS["Property"];
-export const UNARYLIKE_TYPES = FLIPPED_ALIAS_KEYS["UnaryLike"];
-export const PATTERN_TYPES = FLIPPED_ALIAS_KEYS["Pattern"];
-export const CLASS_TYPES = FLIPPED_ALIAS_KEYS["Class"];
-export const IMPORTOREXPORTDECLARATION_TYPES = FLIPPED_ALIAS_KEYS["ImportOrExportDeclaration"];
-export const EXPORTDECLARATION_TYPES = FLIPPED_ALIAS_KEYS["ExportDeclaration"];
-export const MODULESPECIFIER_TYPES = FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
-export const ACCESSOR_TYPES = FLIPPED_ALIAS_KEYS["Accessor"];
-export const PRIVATE_TYPES = FLIPPED_ALIAS_KEYS["Private"];
-export const FLOW_TYPES = FLIPPED_ALIAS_KEYS["Flow"];
-export const FLOWTYPE_TYPES = FLIPPED_ALIAS_KEYS["FlowType"];
-export const FLOWBASEANNOTATION_TYPES = FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
-export const FLOWDECLARATION_TYPES = FLIPPED_ALIAS_KEYS["FlowDeclaration"];
-export const FLOWPREDICATE_TYPES = FLIPPED_ALIAS_KEYS["FlowPredicate"];
-export const ENUMBODY_TYPES = FLIPPED_ALIAS_KEYS["EnumBody"];
-export const ENUMMEMBER_TYPES = FLIPPED_ALIAS_KEYS["EnumMember"];
-export const JSX_TYPES = FLIPPED_ALIAS_KEYS["JSX"];
-export const MISCELLANEOUS_TYPES = FLIPPED_ALIAS_KEYS["Miscellaneous"];
-export const TYPESCRIPT_TYPES = FLIPPED_ALIAS_KEYS["TypeScript"];
-export const TSTYPEELEMENT_TYPES = FLIPPED_ALIAS_KEYS["TSTypeElement"];
-export const TSTYPE_TYPES = FLIPPED_ALIAS_KEYS["TSType"];
-export const TSBASETYPE_TYPES = FLIPPED_ALIAS_KEYS["TSBaseType"];
-export const MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.IMPORTOREXPORTDECLARATION_TYPES = exports.IMMUTABLE_TYPES = exports.FUNCTION_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FOR_TYPES = exports.FORXSTATEMENT_TYPES = exports.FLOW_TYPES = exports.FLOWTYPE_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.EXPRESSION_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.DECLARATION_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.CLASS_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.BINARY_TYPES = exports.ACCESSOR_TYPES = void 0;
+var _definitions = require("../../definitions");
+const STANDARDIZED_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Standardized"];
+exports.STANDARDIZED_TYPES = STANDARDIZED_TYPES;
+const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"];
+exports.EXPRESSION_TYPES = EXPRESSION_TYPES;
+const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"];
+exports.BINARY_TYPES = BINARY_TYPES;
+const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"];
+exports.SCOPABLE_TYPES = SCOPABLE_TYPES;
+const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"];
+exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES;
+const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"];
+exports.BLOCK_TYPES = BLOCK_TYPES;
+const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"];
+exports.STATEMENT_TYPES = STATEMENT_TYPES;
+const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"];
+exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES;
+const COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"];
+exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES;
+const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"];
+exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES;
+const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"];
+exports.LOOP_TYPES = LOOP_TYPES;
+const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"];
+exports.WHILE_TYPES = WHILE_TYPES;
+const EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
+exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES;
+const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"];
+exports.FOR_TYPES = FOR_TYPES;
+const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"];
+exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES;
+const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"];
+exports.FUNCTION_TYPES = FUNCTION_TYPES;
+const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"];
+exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES;
+const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"];
+exports.PUREISH_TYPES = PUREISH_TYPES;
+const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"];
+exports.DECLARATION_TYPES = DECLARATION_TYPES;
+const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"];
+exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES;
+const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"];
+exports.LVAL_TYPES = LVAL_TYPES;
+const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"];
+exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES;
+const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"];
+exports.LITERAL_TYPES = LITERAL_TYPES;
+const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"];
+exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES;
+const USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
+exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES;
+const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"];
+exports.METHOD_TYPES = METHOD_TYPES;
+const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"];
+exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES;
+const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"];
+exports.PROPERTY_TYPES = PROPERTY_TYPES;
+const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"];
+exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES;
+const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"];
+exports.PATTERN_TYPES = PATTERN_TYPES;
+const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"];
+exports.CLASS_TYPES = CLASS_TYPES;
+const IMPORTOREXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ImportOrExportDeclaration"];
+exports.IMPORTOREXPORTDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
+const EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
+exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES;
+const MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
+exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES;
+const ACCESSOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Accessor"];
+exports.ACCESSOR_TYPES = ACCESSOR_TYPES;
+const PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Private"];
+exports.PRIVATE_TYPES = PRIVATE_TYPES;
+const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"];
+exports.FLOW_TYPES = FLOW_TYPES;
+const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"];
+exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES;
+const FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
+exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES;
+const FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
+exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES;
+const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"];
+exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES;
+const ENUMBODY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumBody"];
+exports.ENUMBODY_TYPES = ENUMBODY_TYPES;
+const ENUMMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumMember"];
+exports.ENUMMEMBER_TYPES = ENUMMEMBER_TYPES;
+const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"];
+exports.JSX_TYPES = JSX_TYPES;
+const MISCELLANEOUS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Miscellaneous"];
+exports.MISCELLANEOUS_TYPES = MISCELLANEOUS_TYPES;
+const TYPESCRIPT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TypeScript"];
+exports.TYPESCRIPT_TYPES = TYPESCRIPT_TYPES;
+const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"];
+exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES;
+const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"];
+exports.TSTYPE_TYPES = TSTYPE_TYPES;
+const TSBASETYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSBaseType"];
+exports.TSBASETYPE_TYPES = TSBASETYPE_TYPES;
+const MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
+exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES;
+
 //# sourceMappingURL=index.js.map

lib/constants/index.js

@@ -1,25 +0,51 @@
-export const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
-export const FLATTENABLE_KEYS = ["body", "expressions"];
-export const FOR_INIT_KEYS = ["left", "init"];
-export const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
-export const LOGICAL_OPERATORS = ["||", "&&", "??"];
-export const UPDATE_OPERATORS = ["++", "--"];
-export const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
-export const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
-export const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
-export const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
-export const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
-export const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"];
-export const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")];
-export const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
-export const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
-export const STRING_UNARY_OPERATORS = ["typeof"];
-export const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
-export const INHERIT_KEYS = {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UPDATE_OPERATORS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.STATEMENT_OR_BLOCK_KEYS = exports.NUMBER_UNARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.NOT_LOCAL_BINDING = exports.LOGICAL_OPERATORS = exports.INHERIT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.EQUALITY_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.COMMENT_KEYS = exports.BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.BLOCK_SCOPED_SYMBOL = exports.BINARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = void 0;
+const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
+exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS;
+const FLATTENABLE_KEYS = ["body", "expressions"];
+exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS;
+const FOR_INIT_KEYS = ["left", "init"];
+exports.FOR_INIT_KEYS = FOR_INIT_KEYS;
+const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
+exports.COMMENT_KEYS = COMMENT_KEYS;
+const LOGICAL_OPERATORS = ["||", "&&", "??"];
+exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS;
+const UPDATE_OPERATORS = ["++", "--"];
+exports.UPDATE_OPERATORS = UPDATE_OPERATORS;
+const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
+exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS;
+const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
+exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS;
+const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
+exports.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS;
+const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
+exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS;
+const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS;
+const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"];
+exports.BINARY_OPERATORS = BINARY_OPERATORS;
+const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")];
+exports.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS;
+const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
+exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS;
+const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
+exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS;
+const STRING_UNARY_OPERATORS = ["typeof"];
+exports.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS;
+const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
+exports.UNARY_OPERATORS = UNARY_OPERATORS;
+const INHERIT_KEYS = {
   optional: ["typeAnnotation", "typeParameters", "returnType"],
   force: ["start", "loc", "end"]
 };
-export const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
-export const NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding");
+exports.INHERIT_KEYS = INHERIT_KEYS;
+const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
+exports.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL;
+const NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding");
+exports.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING;
 
 //# sourceMappingURL=index.js.map

lib/converters/ensureBlock.js

@@ -1,4 +0,10 @@
-import toBlock from "./toBlock.js";
-export default function ensureBlock(node, key = "body") {
-  const result = toBlock(node[key], node);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = ensureBlock;
+var _toBlock = require("./toBlock");
+function ensureBlock(node, key = "body") {
+  const result = (0, _toBlock.default)(node[key], node);
   node[key] = result;
@@ -5,0 +11,0 @@ return result;

lib/converters/gatherSequenceExpressions.js

@@ -1,41 +0,47 @@
-import getBindingIdentifiers from "../retrievers/getBindingIdentifiers.js";
-import { isExpression, isExpressionStatement, isVariableDeclaration, isIfStatement, isBlockStatement, isEmptyStatement } from "../validators/generated/index.js";
-import { sequenceExpression, assignmentExpression, conditionalExpression } from "../builders/generated/index.js";
-import cloneNode from "../clone/cloneNode.js";
-export default function gatherSequenceExpressions(nodes, scope, declars) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = gatherSequenceExpressions;
+var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers");
+var _generated = require("../validators/generated");
+var _generated2 = require("../builders/generated");
+var _cloneNode = require("../clone/cloneNode");
+function gatherSequenceExpressions(nodes, scope, declars) {
   const exprs = [];
   let ensureLastUndefined = true;
   for (const node of nodes) {
-    if (!isEmptyStatement(node)) {
+    if (!(0, _generated.isEmptyStatement)(node)) {
       ensureLastUndefined = false;
     }
-    if (isExpression(node)) {
+    if ((0, _generated.isExpression)(node)) {
       exprs.push(node);
-    } else if (isExpressionStatement(node)) {
+    } else if ((0, _generated.isExpressionStatement)(node)) {
       exprs.push(node.expression);
-    } else if (isVariableDeclaration(node)) {
+    } else if ((0, _generated.isVariableDeclaration)(node)) {
       if (node.kind !== "var") return;
       for (const declar of node.declarations) {
-        const bindings = getBindingIdentifiers(declar);
+        const bindings = (0, _getBindingIdentifiers.default)(declar);
         for (const key of Object.keys(bindings)) {
           declars.push({
             kind: node.kind,
-            id: cloneNode(bindings[key])
+            id: (0, _cloneNode.default)(bindings[key])
           });
         }
         if (declar.init) {
-          exprs.push(assignmentExpression("=", declar.id, declar.init));
+          exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init));
         }
       }
       ensureLastUndefined = true;
-    } else if (isIfStatement(node)) {
+    } else if ((0, _generated.isIfStatement)(node)) {
       const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode();
       const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
       if (!consequent || !alternate) return;
-      exprs.push(conditionalExpression(node.test, consequent, alternate));
-    } else if (isBlockStatement(node)) {
+      exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate));
+    } else if ((0, _generated.isBlockStatement)(node)) {
       const body = gatherSequenceExpressions(node.body, scope, declars);
       if (!body) return;
       exprs.push(body);
-    } else if (isEmptyStatement(node)) {
+    } else if ((0, _generated.isEmptyStatement)(node)) {
       if (nodes.indexOf(node) === 0) {
@@ -54,3 +60,3 @@ ensureLastUndefined = true;
   } else {
-    return sequenceExpression(exprs);
+    return (0, _generated2.sequenceExpression)(exprs);
   }
@@ -57,0 +63,0 @@ }

lib/converters/toBindingIdentifierName.js

@@ -1,4 +0,10 @@
-import toIdentifier from "./toIdentifier.js";
-export default function toBindingIdentifierName(name) {
-  name = toIdentifier(name);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toBindingIdentifierName;
+var _toIdentifier = require("./toIdentifier");
+function toBindingIdentifierName(name) {
+  name = (0, _toIdentifier.default)(name);
   if (name === "eval" || name === "arguments") name = "_" + name;
@@ -5,0 +11,0 @@ return name;

lib/converters/toBlock.js

@@ -1,16 +0,22 @@
-import { isBlockStatement, isFunction, isEmptyStatement, isStatement } from "../validators/generated/index.js";
-import { returnStatement, expressionStatement, blockStatement } from "../builders/generated/index.js";
-export default function toBlock(node, parent) {
-  if (isBlockStatement(node)) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toBlock;
+var _generated = require("../validators/generated");
+var _generated2 = require("../builders/generated");
+function toBlock(node, parent) {
+  if ((0, _generated.isBlockStatement)(node)) {
     return node;
   }
   let blockNodes = [];
-  if (isEmptyStatement(node)) {
+  if ((0, _generated.isEmptyStatement)(node)) {
     blockNodes = [];
   } else {
-    if (!isStatement(node)) {
-      if (isFunction(parent)) {
-        node = returnStatement(node);
+    if (!(0, _generated.isStatement)(node)) {
+      if ((0, _generated.isFunction)(parent)) {
+        node = (0, _generated2.returnStatement)(node);
       } else {
-        node = expressionStatement(node);
+        node = (0, _generated2.expressionStatement)(node);
       }
@@ -20,5 +26,5 @@ }
   }
-  return blockStatement(blockNodes);
+  return (0, _generated2.blockStatement)(blockNodes);
 }
 
 //# sourceMappingURL=toBlock.js.map

lib/converters/toComputedKey.js

@@ -1,5 +0,11 @@
-import { isIdentifier } from "../validators/generated/index.js";
-import { stringLiteral } from "../builders/generated/index.js";
-export default function toComputedKey(node, key = node.key || node.property) {
-  if (!node.computed && isIdentifier(key)) key = stringLiteral(key.name);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toComputedKey;
+var _generated = require("../validators/generated");
+var _generated2 = require("../builders/generated");
+function toComputedKey(node, key = node.key || node.property) {
+  if (!node.computed && (0, _generated.isIdentifier)(key)) key = (0, _generated2.stringLiteral)(key.name);
   return key;
@@ -6,0 +12,0 @@ }

lib/converters/toExpression.js

@@ -1,16 +0,23 @@
-import { isExpression, isFunction, isClass, isExpressionStatement } from "../validators/generated/index.js";
-export default toExpression;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _generated = require("../validators/generated");
+var _default = toExpression;
+exports.default = _default;
 function toExpression(node) {
-  if (isExpressionStatement(node)) {
+  if ((0, _generated.isExpressionStatement)(node)) {
     node = node.expression;
   }
-  if (isExpression(node)) {
+  if ((0, _generated.isExpression)(node)) {
     return node;
   }
-  if (isClass(node)) {
+  if ((0, _generated.isClass)(node)) {
     node.type = "ClassExpression";
-  } else if (isFunction(node)) {
+  } else if ((0, _generated.isFunction)(node)) {
     node.type = "FunctionExpression";
   }
-  if (!isExpression(node)) {
+  if (!(0, _generated.isExpression)(node)) {
     throw new Error(`cannot turn ${node.type} to an expression`);
@@ -17,0 +24,0 @@ }

lib/converters/toIdentifier.js

@@ -1,8 +0,14 @@
-import isValidIdentifier from "../validators/isValidIdentifier.js";
-import { isIdentifierChar } from "@babel/helper-validator-identifier";
-export default function toIdentifier(input) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toIdentifier;
+var _isValidIdentifier = require("../validators/isValidIdentifier");
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+function toIdentifier(input) {
   input = input + "";
   let name = "";
   for (const c of input) {
-    name += isIdentifierChar(c.codePointAt(0)) ? c : "-";
+    name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-";
   }
@@ -13,3 +19,3 @@ name = name.replace(/^[-0-9]+/, "");
   });
-  if (!isValidIdentifier(name)) {
+  if (!(0, _isValidIdentifier.default)(name)) {
     name = `_${name}`;
@@ -16,0 +22,0 @@ }

lib/converters/toKeyAlias.js

@@ -1,14 +0,20 @@
-import { isIdentifier, isStringLiteral } from "../validators/generated/index.js";
-import cloneNode from "../clone/cloneNode.js";
-import removePropertiesDeep from "../modifications/removePropertiesDeep.js";
-export default function toKeyAlias(node, key = node.key) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toKeyAlias;
+var _generated = require("../validators/generated");
+var _cloneNode = require("../clone/cloneNode");
+var _removePropertiesDeep = require("../modifications/removePropertiesDeep");
+function toKeyAlias(node, key = node.key) {
   let alias;
   if (node.kind === "method") {
     return toKeyAlias.increment() + "";
-  } else if (isIdentifier(key)) {
+  } else if ((0, _generated.isIdentifier)(key)) {
     alias = key.name;
-  } else if (isStringLiteral(key)) {
+  } else if ((0, _generated.isStringLiteral)(key)) {
     alias = JSON.stringify(key.value);
   } else {
-    alias = JSON.stringify(removePropertiesDeep(cloneNode(key)));
+    alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key)));
   }
@@ -15,0 +21,0 @@ if (node.computed) {

lib/converters/toSequenceExpression.js

@@ -1,6 +0,12 @@
-import gatherSequenceExpressions from "./gatherSequenceExpressions.js";
-export default function toSequenceExpression(nodes, scope) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toSequenceExpression;
+var _gatherSequenceExpressions = require("./gatherSequenceExpressions");
+function toSequenceExpression(nodes, scope) {
   if (!(nodes != null && nodes.length)) return;
   const declars = [];
-  const result = gatherSequenceExpressions(nodes, scope, declars);
+  const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars);
   if (!result) return;
@@ -7,0 +13,0 @@ for (const declar of declars) {

lib/converters/toStatement.js

@@ -1,6 +0,13 @@
-import { isStatement, isFunction, isClass, isAssignmentExpression } from "../validators/generated/index.js";
-import { expressionStatement } from "../builders/generated/index.js";
-export default toStatement;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _generated = require("../validators/generated");
+var _generated2 = require("../builders/generated");
+var _default = toStatement;
+exports.default = _default;
 function toStatement(node, ignore) {
-  if (isStatement(node)) {
+  if ((0, _generated.isStatement)(node)) {
     return node;
@@ -10,10 +17,10 @@ }
   let newType;
-  if (isClass(node)) {
+  if ((0, _generated.isClass)(node)) {
     mustHaveId = true;
     newType = "ClassDeclaration";
-  } else if (isFunction(node)) {
+  } else if ((0, _generated.isFunction)(node)) {
     mustHaveId = true;
     newType = "FunctionDeclaration";
-  } else if (isAssignmentExpression(node)) {
-    return expressionStatement(node);
+  } else if ((0, _generated.isAssignmentExpression)(node)) {
+    return (0, _generated2.expressionStatement)(node);
   }
@@ -20,0 +27,0 @@ if (mustHaveId && !node.id) {

lib/converters/valueToNode.js

@@ -1,4 +0,11 @@
-import isValidIdentifier from "../validators/isValidIdentifier.js";
-import { identifier, booleanLiteral, nullLiteral, stringLiteral, numericLiteral, regExpLiteral, arrayExpression, objectProperty, objectExpression, unaryExpression, binaryExpression } from "../builders/generated/index.js";
-export default valueToNode;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isValidIdentifier = require("../validators/isValidIdentifier");
+var _generated = require("../builders/generated");
+var _default = valueToNode;
+exports.default = _default;
 const objectToString = Function.call.bind(Object.prototype.toString);
@@ -17,12 +24,12 @@ function isRegExp(value) {
   if (value === undefined) {
-    return identifier("undefined");
+    return (0, _generated.identifier)("undefined");
   }
   if (value === true || value === false) {
-    return booleanLiteral(value);
+    return (0, _generated.booleanLiteral)(value);
   }
   if (value === null) {
-    return nullLiteral();
+    return (0, _generated.nullLiteral)();
   }
   if (typeof value === "string") {
-    return stringLiteral(value);
+    return (0, _generated.stringLiteral)(value);
   }
@@ -32,14 +39,14 @@ if (typeof value === "number") {
     if (Number.isFinite(value)) {
-      result = numericLiteral(Math.abs(value));
+      result = (0, _generated.numericLiteral)(Math.abs(value));
     } else {
       let numerator;
       if (Number.isNaN(value)) {
-        numerator = numericLiteral(0);
+        numerator = (0, _generated.numericLiteral)(0);
       } else {
-        numerator = numericLiteral(1);
+        numerator = (0, _generated.numericLiteral)(1);
       }
-      result = binaryExpression("/", numerator, numericLiteral(0));
+      result = (0, _generated.binaryExpression)("/", numerator, (0, _generated.numericLiteral)(0));
     }
     if (value < 0 || Object.is(value, -0)) {
-      result = unaryExpression("-", result);
+      result = (0, _generated.unaryExpression)("-", result);
     }
@@ -51,6 +58,6 @@ return result;
     const flags = value.toString().match(/\/([a-z]+|)$/)[1];
-    return regExpLiteral(pattern, flags);
+    return (0, _generated.regExpLiteral)(pattern, flags);
   }
   if (Array.isArray(value)) {
-    return arrayExpression(value.map(valueToNode));
+    return (0, _generated.arrayExpression)(value.map(valueToNode));
   }
@@ -61,10 +68,10 @@ if (isPlainObject(value)) {
       let nodeKey;
-      if (isValidIdentifier(key)) {
-        nodeKey = identifier(key);
+      if ((0, _isValidIdentifier.default)(key)) {
+        nodeKey = (0, _generated.identifier)(key);
       } else {
-        nodeKey = stringLiteral(key);
+        nodeKey = (0, _generated.stringLiteral)(key);
       }
-      props.push(objectProperty(nodeKey, valueToNode(value[key])));
+      props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value[key])));
     }
-    return objectExpression(props);
+    return (0, _generated.objectExpression)(props);
   }
@@ -71,0 +78,0 @@ throw new Error("don't know how to turn this value into a node");

lib/definitions/core.js

@@ -1,12 +0,18 @@
-import is from "../validators/is.js";
-import isValidIdentifier from "../validators/isValidIdentifier.js";
-import { isKeyword, isReservedWord } from "@babel/helper-validator-identifier";
-import { readStringContents } from "@babel/helper-string-parser";
-import { BINARY_OPERATORS, LOGICAL_OPERATORS, ASSIGNMENT_OPERATORS, UNARY_OPERATORS, UPDATE_OPERATORS } from "../constants/index.js";
-import { defineAliasedType, assertShape, assertOptionalChainStart, assertValueType, assertNodeType, assertNodeOrValueType, assertEach, chain, assertOneOf, validateOptional } from "./utils.js";
-const defineType = defineAliasedType("Standardized");
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.patternLikeCommon = exports.functionTypeAnnotationCommon = exports.functionDeclarationCommon = exports.functionCommon = exports.classMethodOrPropertyCommon = exports.classMethodOrDeclareMethodCommon = void 0;
+var _is = require("../validators/is");
+var _isValidIdentifier = require("../validators/isValidIdentifier");
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+var _helperStringParser = require("@babel/helper-string-parser");
+var _constants = require("../constants");
+var _utils = require("./utils");
+const defineType = (0, _utils.defineAliasedType)("Standardized");
 defineType("ArrayExpression", {
   fields: {
     elements: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeOrValueType("null", "Expression", "SpreadElement"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
       default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined
@@ -23,8 +29,8 @@ }
         if (!process.env.BABEL_TYPES_8_BREAKING) {
-          return assertValueType("string");
+          return (0, _utils.assertValueType)("string");
         }
-        const identifier = assertOneOf(...ASSIGNMENT_OPERATORS);
-        const pattern = assertOneOf("=");
+        const identifier = (0, _utils.assertOneOf)(..._constants.ASSIGNMENT_OPERATORS);
+        const pattern = (0, _utils.assertOneOf)("=");
         return function (node, key, val) {
-          const validator = is("Pattern", node.left) ? pattern : identifier;
+          const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier;
           validator(node, key, val);
@@ -35,6 +41,6 @@ };
     left: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? assertNodeType("LVal") : assertNodeType("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
     },
     right: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -50,8 +56,8 @@ },
     operator: {
-      validate: assertOneOf(...BINARY_OPERATORS)
+      validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS)
     },
     left: {
       validate: function () {
-        const expression = assertNodeType("Expression");
-        const inOp = assertNodeType("Expression", "PrivateName");
+        const expression = (0, _utils.assertNodeType)("Expression");
+        const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName");
         const validator = Object.assign(function (node, key, val) {
@@ -67,3 +73,3 @@ const validator = node.operator === "in" ? inOp : expression;
     right: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -78,3 +84,3 @@ },
     value: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     }
@@ -87,3 +93,3 @@ }
     value: {
-      validate: assertNodeType("DirectiveLiteral")
+      validate: (0, _utils.assertNodeType)("DirectiveLiteral")
     }
@@ -96,3 +102,3 @@ }
     value: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     }
@@ -106,7 +112,7 @@ }
     directives: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Directive"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
       default: []
     },
     body: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Statement")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
     }
@@ -120,3 +126,3 @@ },
     label: {
-      validate: assertNodeType("Identifier"),
+      validate: (0, _utils.assertNodeType)("Identifier"),
       optional: true
@@ -133,10 +139,10 @@ }
     callee: {
-      validate: assertNodeType("Expression", "Super", "V8IntrinsicIdentifier")
+      validate: (0, _utils.assertNodeType)("Expression", "Super", "V8IntrinsicIdentifier")
     },
     arguments: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
     }
   }, !process.env.BABEL_TYPES_8_BREAKING ? {
     optional: {
-      validate: assertOneOf(true, false),
+      validate: (0, _utils.assertOneOf)(true, false),
       optional: true
@@ -146,7 +152,7 @@ }
     typeArguments: {
-      validate: assertNodeType("TypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
       optional: true
     },
     typeParameters: {
-      validate: assertNodeType("TSTypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
       optional: true
@@ -160,7 +166,7 @@ }
     param: {
-      validate: assertNodeType("Identifier", "ArrayPattern", "ObjectPattern"),
+      validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
       optional: true
     },
     body: {
-      validate: assertNodeType("BlockStatement")
+      validate: (0, _utils.assertNodeType)("BlockStatement")
     }
@@ -174,9 +180,9 @@ },
     test: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     consequent: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     alternate: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -190,3 +196,3 @@ },
     label: {
-      validate: assertNodeType("Identifier"),
+      validate: (0, _utils.assertNodeType)("Identifier"),
       optional: true
@@ -204,6 +210,6 @@ }
     test: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     body: {
-      validate: assertNodeType("Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     }
@@ -220,3 +226,3 @@ },
     expression: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -231,3 +237,3 @@ },
     program: {
-      validate: assertNodeType("Program")
+      validate: (0, _utils.assertNodeType)("Program")
     },
@@ -239,7 +245,7 @@ comments: {
         }
-      }) : assertEach(assertNodeType("CommentBlock", "CommentLine")),
+      }) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")),
       optional: true
     },
     tokens: {
-      validate: assertEach(Object.assign(() => {}, {
+      validate: (0, _utils.assertEach)(Object.assign(() => {}, {
         type: "any"
@@ -256,9 +262,9 @@ })),
     left: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? assertNodeType("VariableDeclaration", "LVal") : assertNodeType("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
     },
     right: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     body: {
-      validate: assertNodeType("Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     }
@@ -272,21 +278,21 @@ }
     init: {
-      validate: assertNodeType("VariableDeclaration", "Expression"),
+      validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"),
       optional: true
     },
     test: {
-      validate: assertNodeType("Expression"),
+      validate: (0, _utils.assertNodeType)("Expression"),
       optional: true
     },
     update: {
-      validate: assertNodeType("Expression"),
+      validate: (0, _utils.assertNodeType)("Expression"),
       optional: true
     },
     body: {
-      validate: assertNodeType("Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     }
   }
 });
-export const functionCommon = () => ({
+const functionCommon = () => ({
   params: {
-    validate: chain(assertValueType("array"), assertEach(assertNodeType("Identifier", "Pattern", "RestElement")))
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement")))
   },
@@ -300,22 +306,25 @@ generator: {
 });
-export const functionTypeAnnotationCommon = () => ({
+exports.functionCommon = functionCommon;
+const functionTypeAnnotationCommon = () => ({
   returnType: {
-    validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+    validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
     optional: true
   },
   typeParameters: {
-    validate: assertNodeType("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
+    validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
     optional: true
   }
 });
-export const functionDeclarationCommon = () => Object.assign({}, functionCommon(), {
+exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon;
+const functionDeclarationCommon = () => Object.assign({}, functionCommon(), {
   declare: {
-    validate: assertValueType("boolean"),
+    validate: (0, _utils.assertValueType)("boolean"),
     optional: true
   },
   id: {
-    validate: assertNodeType("Identifier"),
+    validate: (0, _utils.assertNodeType)("Identifier"),
     optional: true
   }
 });
+exports.functionDeclarationCommon = functionDeclarationCommon;
 defineType("FunctionDeclaration", {
@@ -326,6 +335,6 @@ builder: ["id", "params", "body", "generator", "async"],
     body: {
-      validate: assertNodeType("BlockStatement")
+      validate: (0, _utils.assertNodeType)("BlockStatement")
     },
     predicate: {
-      validate: assertNodeType("DeclaredPredicate", "InferredPredicate"),
+      validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
       optional: true
@@ -337,5 +346,5 @@ }
     if (!process.env.BABEL_TYPES_8_BREAKING) return () => {};
-    const identifier = assertNodeType("Identifier");
+    const identifier = (0, _utils.assertNodeType)("Identifier");
     return function (parent, key, node) {
-      if (!is("ExportDefaultDeclaration", parent)) {
+      if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
         identifier(node, "id", node.id);
@@ -351,10 +360,10 @@ }
     id: {
-      validate: assertNodeType("Identifier"),
+      validate: (0, _utils.assertNodeType)("Identifier"),
       optional: true
     },
     body: {
-      validate: assertNodeType("BlockStatement")
+      validate: (0, _utils.assertNodeType)("BlockStatement")
     },
     predicate: {
-      validate: assertNodeType("DeclaredPredicate", "InferredPredicate"),
+      validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
       optional: true
@@ -364,16 +373,17 @@ }
 });
-export const patternLikeCommon = () => ({
+const patternLikeCommon = () => ({
   typeAnnotation: {
-    validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+    validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
     optional: true
   },
   optional: {
-    validate: assertValueType("boolean"),
+    validate: (0, _utils.assertValueType)("boolean"),
     optional: true
   },
   decorators: {
-    validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
     optional: true
   }
 });
+exports.patternLikeCommon = patternLikeCommon;
 defineType("Identifier", {
@@ -385,5 +395,5 @@ builder: ["name"],
     name: {
-      validate: chain(assertValueType("string"), Object.assign(function (node, key, val) {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
         if (!process.env.BABEL_TYPES_8_BREAKING) return;
-        if (!isValidIdentifier(val, false)) {
+        if (!(0, _isValidIdentifier.default)(val, false)) {
           throw new TypeError(`"${val}" is not a valid identifier name`);
@@ -405,19 +415,19 @@ }
     if (parentKey === "property") {
-      if (is("MemberExpression", parent, nonComp)) return;
-      if (is("OptionalMemberExpression", parent, nonComp)) return;
+      if ((0, _is.default)("MemberExpression", parent, nonComp)) return;
+      if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return;
     } else if (parentKey === "key") {
-      if (is("Property", parent, nonComp)) return;
-      if (is("Method", parent, nonComp)) return;
+      if ((0, _is.default)("Property", parent, nonComp)) return;
+      if ((0, _is.default)("Method", parent, nonComp)) return;
     } else if (parentKey === "exported") {
-      if (is("ExportSpecifier", parent)) return;
+      if ((0, _is.default)("ExportSpecifier", parent)) return;
     } else if (parentKey === "imported") {
-      if (is("ImportSpecifier", parent, {
+      if ((0, _is.default)("ImportSpecifier", parent, {
         imported: node
       })) return;
     } else if (parentKey === "meta") {
-      if (is("MetaProperty", parent, {
+      if ((0, _is.default)("MetaProperty", parent, {
         meta: node
       })) return;
     }
-    if ((isKeyword(node.name) || isReservedWord(node.name, false)) && node.name !== "this") {
+    if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== "this") {
       throw new TypeError(`"${node.name}" is not a valid identifier`);
@@ -432,10 +442,10 @@ }
     test: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     consequent: {
-      validate: assertNodeType("Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     },
     alternate: {
       optional: true,
-      validate: assertNodeType("Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     }
@@ -449,6 +459,6 @@ }
     label: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     },
     body: {
-      validate: assertNodeType("Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     }
@@ -461,3 +471,3 @@ }
     value: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     }
@@ -472,3 +482,3 @@ },
     value: {
-      validate: assertValueType("number")
+      validate: (0, _utils.assertValueType)("number")
     }
@@ -485,3 +495,3 @@ },
     value: {
-      validate: assertValueType("boolean")
+      validate: (0, _utils.assertValueType)("boolean")
     }
@@ -497,6 +507,6 @@ },
     pattern: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     },
     flags: {
-      validate: chain(assertValueType("string"), Object.assign(function (node, key, val) {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
         if (!process.env.BABEL_TYPES_8_BREAKING) return;
@@ -520,9 +530,9 @@ const invalid = /[^gimsuy]/.exec(val);
     operator: {
-      validate: assertOneOf(...LOGICAL_OPERATORS)
+      validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS)
     },
     left: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     right: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -537,8 +547,8 @@ }
     object: {
-      validate: assertNodeType("Expression", "Super")
+      validate: (0, _utils.assertNodeType)("Expression", "Super")
     },
     property: {
       validate: function () {
-        const normal = assertNodeType("Identifier", "PrivateName");
-        const computed = assertNodeType("Expression");
+        const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
+        const computed = (0, _utils.assertNodeType)("Expression");
         const validator = function (node, key, val) {
@@ -557,3 +567,3 @@ const validator = node.computed ? computed : normal;
     optional: {
-      validate: assertOneOf(true, false),
+      validate: (0, _utils.assertOneOf)(true, false),
       optional: true
@@ -571,10 +581,10 @@ }
     sourceFile: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     },
     sourceType: {
-      validate: assertOneOf("script", "module"),
+      validate: (0, _utils.assertOneOf)("script", "module"),
       default: "script"
     },
     interpreter: {
-      validate: assertNodeType("InterpreterDirective"),
+      validate: (0, _utils.assertNodeType)("InterpreterDirective"),
       default: null,
@@ -584,7 +594,7 @@ optional: true
     directives: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Directive"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
       default: []
     },
     body: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Statement")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
     }
@@ -599,3 +609,3 @@ },
     properties: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("ObjectMethod", "ObjectProperty", "SpreadElement")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
     }
@@ -608,3 +618,3 @@ }
     kind: Object.assign({
-      validate: assertOneOf("method", "get", "set")
+      validate: (0, _utils.assertOneOf)("method", "get", "set")
     }, !process.env.BABEL_TYPES_8_BREAKING ? {
@@ -618,4 +628,4 @@ default: "method"
       validate: function () {
-        const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
-        const computed = assertNodeType("Expression");
+        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
+        const computed = (0, _utils.assertNodeType)("Expression");
         const validator = function (node, key, val) {
@@ -630,7 +640,7 @@ const validator = node.computed ? computed : normal;
     decorators: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
     },
     body: {
-      validate: assertNodeType("BlockStatement")
+      validate: (0, _utils.assertNodeType)("BlockStatement")
     }
@@ -649,4 +659,4 @@ }),
       validate: function () {
-        const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName");
-        const computed = assertNodeType("Expression");
+        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName");
+        const computed = (0, _utils.assertNodeType)("Expression");
         const validator = Object.assign(function (node, key, val) {
@@ -662,6 +672,6 @@ const validator = node.computed ? computed : normal;
     value: {
-      validate: assertNodeType("Expression", "PatternLike")
+      validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
     },
     shorthand: {
-      validate: chain(assertValueType("boolean"), Object.assign(function (node, key, val) {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
         if (!process.env.BABEL_TYPES_8_BREAKING) return;
@@ -675,3 +685,3 @@ if (val && node.computed) {
         if (!process.env.BABEL_TYPES_8_BREAKING) return;
-        if (val && !is("Identifier", node.key)) {
+        if (val && !(0, _is.default)("Identifier", node.key)) {
           throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
@@ -683,3 +693,3 @@ }
     decorators: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
@@ -691,7 +701,7 @@ }
   validate: function () {
-    const pattern = assertNodeType("Identifier", "Pattern", "TSAsExpression", "TSSatisfiesExpression", "TSNonNullExpression", "TSTypeAssertion");
-    const expression = assertNodeType("Expression");
+    const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern", "TSAsExpression", "TSSatisfiesExpression", "TSNonNullExpression", "TSTypeAssertion");
+    const expression = (0, _utils.assertNodeType)("Expression");
     return function (parent, key, node) {
       if (!process.env.BABEL_TYPES_8_BREAKING) return;
-      const validator = is("ObjectPattern", parent) ? pattern : expression;
+      const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression;
       validator(node, "value", node.value);
@@ -708,3 +718,3 @@ };
     argument: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? assertNodeType("LVal") : assertNodeType("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
     }
@@ -727,3 +737,3 @@ }),
     argument: {
-      validate: assertNodeType("Expression"),
+      validate: (0, _utils.assertNodeType)("Expression"),
       optional: true
@@ -737,3 +747,3 @@ }
     expressions: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Expression")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
     }
@@ -748,3 +758,3 @@ },
     expression: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -757,7 +767,7 @@ }
     test: {
-      validate: assertNodeType("Expression"),
+      validate: (0, _utils.assertNodeType)("Expression"),
       optional: true
     },
     consequent: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Statement")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
     }
@@ -771,6 +781,6 @@ }
     discriminant: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     cases: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("SwitchCase")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase")))
     }
@@ -787,3 +797,3 @@ }
     argument: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -797,3 +807,3 @@ }
     block: {
-      validate: chain(assertNodeType("BlockStatement"), Object.assign(function (node) {
+      validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function (node) {
         if (!process.env.BABEL_TYPES_8_BREAKING) return;
@@ -809,7 +819,7 @@ if (!node.handler && !node.finalizer) {
       optional: true,
-      validate: assertNodeType("CatchClause")
+      validate: (0, _utils.assertNodeType)("CatchClause")
     },
     finalizer: {
       optional: true,
-      validate: assertNodeType("BlockStatement")
+      validate: (0, _utils.assertNodeType)("BlockStatement")
     }
@@ -825,6 +835,6 @@ }
     argument: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     operator: {
-      validate: assertOneOf(...UNARY_OPERATORS)
+      validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS)
     }
@@ -842,6 +852,6 @@ },
     argument: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? assertNodeType("Expression") : assertNodeType("Identifier", "MemberExpression")
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression")
     },
     operator: {
-      validate: assertOneOf(...UPDATE_OPERATORS)
+      validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
     }
@@ -858,10 +868,10 @@ },
     declare: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     kind: {
-      validate: assertOneOf("var", "let", "const", "using")
+      validate: (0, _utils.assertOneOf)("var", "let", "const", "using")
     },
     declarations: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("VariableDeclarator")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator")))
     }
@@ -871,3 +881,3 @@ },
     if (!process.env.BABEL_TYPES_8_BREAKING) return;
-    if (!is("ForXStatement", parent, {
+    if (!(0, _is.default)("ForXStatement", parent, {
       left: node
@@ -886,6 +896,6 @@ })) return;
         if (!process.env.BABEL_TYPES_8_BREAKING) {
-          return assertNodeType("LVal");
+          return (0, _utils.assertNodeType)("LVal");
         }
-        const normal = assertNodeType("Identifier", "ArrayPattern", "ObjectPattern");
-        const without = assertNodeType("Identifier");
+        const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern");
+        const without = (0, _utils.assertNodeType)("Identifier");
         return function (node, key, val) {
@@ -899,7 +909,7 @@ const validator = node.init ? normal : without;
       optional: true,
-      validate: assertValueType("boolean")
+      validate: (0, _utils.assertValueType)("boolean")
     },
     init: {
       optional: true,
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -913,6 +923,6 @@ }
     test: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     body: {
-      validate: assertNodeType("Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     }
@@ -926,6 +936,6 @@ }
     object: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     body: {
-      validate: assertNodeType("Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     }
@@ -940,9 +950,9 @@ }
     left: {
-      validate: assertNodeType("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
+      validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
     },
     right: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     decorators: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
@@ -958,3 +968,3 @@ }
     elements: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeOrValueType("null", "PatternLike", "LVal")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike", "LVal")))
     }
@@ -969,9 +979,9 @@ })
     expression: {
-      validate: assertValueType("boolean")
+      validate: (0, _utils.assertValueType)("boolean")
     },
     body: {
-      validate: assertNodeType("BlockStatement", "Expression")
+      validate: (0, _utils.assertNodeType)("BlockStatement", "Expression")
     },
     predicate: {
-      validate: assertNodeType("DeclaredPredicate", "InferredPredicate"),
+      validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
       optional: true
@@ -985,3 +995,3 @@ }
     body: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock")))
     }
@@ -996,30 +1006,30 @@ }
     id: {
-      validate: assertNodeType("Identifier"),
+      validate: (0, _utils.assertNodeType)("Identifier"),
       optional: true
     },
     typeParameters: {
-      validate: assertNodeType("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
+      validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
       optional: true
     },
     body: {
-      validate: assertNodeType("ClassBody")
+      validate: (0, _utils.assertNodeType)("ClassBody")
     },
     superClass: {
       optional: true,
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     superTypeParameters: {
-      validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
       optional: true
     },
     implements: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("TSExpressionWithTypeArguments", "ClassImplements"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
       optional: true
     },
     decorators: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
     },
     mixins: {
-      validate: assertNodeType("InterfaceExtends"),
+      validate: (0, _utils.assertNodeType)("InterfaceExtends"),
       optional: true
@@ -1034,37 +1044,37 @@ }
     id: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     },
     typeParameters: {
-      validate: assertNodeType("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
+      validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
       optional: true
     },
     body: {
-      validate: assertNodeType("ClassBody")
+      validate: (0, _utils.assertNodeType)("ClassBody")
     },
     superClass: {
       optional: true,
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     superTypeParameters: {
-      validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
       optional: true
     },
     implements: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("TSExpressionWithTypeArguments", "ClassImplements"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
       optional: true
     },
     decorators: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
     },
     mixins: {
-      validate: assertNodeType("InterfaceExtends"),
+      validate: (0, _utils.assertNodeType)("InterfaceExtends"),
       optional: true
     },
     declare: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     abstract: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
@@ -1074,6 +1084,6 @@ }
   validate: function () {
-    const identifier = assertNodeType("Identifier");
+    const identifier = (0, _utils.assertNodeType)("Identifier");
     return function (parent, key, node) {
       if (!process.env.BABEL_TYPES_8_BREAKING) return;
-      if (!is("ExportDefaultDeclaration", parent)) {
+      if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
         identifier(node, "id", node.id);
@@ -1089,8 +1099,8 @@ }
     source: {
-      validate: assertNodeType("StringLiteral")
+      validate: (0, _utils.assertNodeType)("StringLiteral")
     },
-    exportKind: validateOptional(assertOneOf("type", "value")),
+    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")),
     assertions: {
       optional: true,
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("ImportAttribute")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
     }
@@ -1104,5 +1114,5 @@ }
     declaration: {
-      validate: assertNodeType("TSDeclareFunction", "FunctionDeclaration", "ClassDeclaration", "Expression")
+      validate: (0, _utils.assertNodeType)("TSDeclareFunction", "FunctionDeclaration", "ClassDeclaration", "Expression")
     },
-    exportKind: validateOptional(assertOneOf("value"))
+    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("value"))
   }
@@ -1116,3 +1126,3 @@ });
       optional: true,
-      validate: chain(assertNodeType("Declaration"), Object.assign(function (node, key, val) {
+      validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function (node, key, val) {
         if (!process.env.BABEL_TYPES_8_BREAKING) return;
@@ -1133,9 +1143,9 @@ if (val && node.specifiers.length) {
       optional: true,
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("ImportAttribute")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
     },
     specifiers: {
       default: [],
-      validate: chain(assertValueType("array"), assertEach(function () {
-        const sourced = assertNodeType("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier");
-        const sourceless = assertNodeType("ExportSpecifier");
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function () {
+        const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier");
+        const sourceless = (0, _utils.assertNodeType)("ExportSpecifier");
         if (!process.env.BABEL_TYPES_8_BREAKING) return sourced;
@@ -1149,6 +1159,6 @@ return function (node, key, val) {
     source: {
-      validate: assertNodeType("StringLiteral"),
+      validate: (0, _utils.assertNodeType)("StringLiteral"),
       optional: true
     },
-    exportKind: validateOptional(assertOneOf("type", "value"))
+    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
   }
@@ -1161,9 +1171,9 @@ });
     local: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     },
     exported: {
-      validate: assertNodeType("Identifier", "StringLiteral")
+      validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
     },
     exportKind: {
-      validate: assertOneOf("type", "value"),
+      validate: (0, _utils.assertOneOf)("type", "value"),
       optional: true
@@ -1181,8 +1191,8 @@ }
         if (!process.env.BABEL_TYPES_8_BREAKING) {
-          return assertNodeType("VariableDeclaration", "LVal");
+          return (0, _utils.assertNodeType)("VariableDeclaration", "LVal");
         }
-        const declaration = assertNodeType("VariableDeclaration");
-        const lval = assertNodeType("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression");
+        const declaration = (0, _utils.assertNodeType)("VariableDeclaration");
+        const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression");
         return function (node, key, val) {
-          if (is("VariableDeclaration", val)) {
+          if ((0, _is.default)("VariableDeclaration", val)) {
             declaration(node, key, val);
@@ -1196,6 +1206,6 @@ } else {
     right: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     body: {
-      validate: assertNodeType("Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     },
@@ -1213,16 +1223,16 @@ await: {
       optional: true,
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("ImportAttribute")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
     },
     module: {
       optional: true,
-      validate: assertValueType("boolean")
+      validate: (0, _utils.assertValueType)("boolean")
     },
     specifiers: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
     },
     source: {
-      validate: assertNodeType("StringLiteral")
+      validate: (0, _utils.assertNodeType)("StringLiteral")
     },
     importKind: {
-      validate: assertOneOf("type", "typeof", "value"),
+      validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
       optional: true
@@ -1237,3 +1247,3 @@ }
     local: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     }
@@ -1247,3 +1257,3 @@ }
     local: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     }
@@ -1257,9 +1267,9 @@ }
     local: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     },
     imported: {
-      validate: assertNodeType("Identifier", "StringLiteral")
+      validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
     },
     importKind: {
-      validate: assertOneOf("type", "typeof", "value"),
+      validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
       optional: true
@@ -1274,3 +1284,3 @@ }
     meta: {
-      validate: chain(assertNodeType("Identifier"), Object.assign(function (node, key, val) {
+      validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function (node, key, val) {
         if (!process.env.BABEL_TYPES_8_BREAKING) return;
@@ -1289,3 +1299,3 @@ let property;
         }
-        if (!is("Identifier", node.property, {
+        if (!(0, _is.default)("Identifier", node.property, {
           name: property
@@ -1300,13 +1310,13 @@ })) {
     property: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     }
   }
 });
-export const classMethodOrPropertyCommon = () => ({
+const classMethodOrPropertyCommon = () => ({
   abstract: {
-    validate: assertValueType("boolean"),
+    validate: (0, _utils.assertValueType)("boolean"),
     optional: true
   },
   accessibility: {
-    validate: assertOneOf("public", "private", "protected"),
+    validate: (0, _utils.assertOneOf)("public", "private", "protected"),
     optional: true
@@ -1324,9 +1334,9 @@ },
   optional: {
-    validate: assertValueType("boolean"),
+    validate: (0, _utils.assertValueType)("boolean"),
     optional: true
   },
   key: {
-    validate: chain(function () {
-      const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral");
-      const computed = assertNodeType("Expression");
+    validate: (0, _utils.chain)(function () {
+      const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
+      const computed = (0, _utils.assertNodeType)("Expression");
       return function (node, key, val) {
@@ -1336,22 +1346,24 @@ const validator = node.computed ? computed : normal;
       };
-    }(), assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression"))
+    }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression"))
   }
 });
-export const classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(), classMethodOrPropertyCommon(), {
+exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
+const classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(), classMethodOrPropertyCommon(), {
   params: {
-    validate: chain(assertValueType("array"), assertEach(assertNodeType("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
   },
   kind: {
-    validate: assertOneOf("get", "set", "method", "constructor"),
+    validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"),
     default: "method"
   },
   access: {
-    validate: chain(assertValueType("string"), assertOneOf("public", "private", "protected")),
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
     optional: true
   },
   decorators: {
-    validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
     optional: true
   }
 });
+exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
 defineType("ClassMethod", {
@@ -1363,3 +1375,3 @@ aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
     body: {
-      validate: assertNodeType("BlockStatement")
+      validate: (0, _utils.assertNodeType)("BlockStatement")
     }
@@ -1374,3 +1386,3 @@ })
     properties: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("RestElement", "ObjectProperty")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
     }
@@ -1385,3 +1397,3 @@ })
     argument: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -1399,9 +1411,9 @@ }
     tag: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     quasi: {
-      validate: assertNodeType("TemplateLiteral")
+      validate: (0, _utils.assertNodeType)("TemplateLiteral")
     },
     typeParameters: {
-      validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
       optional: true
@@ -1415,8 +1427,8 @@ }
     value: {
-      validate: chain(assertShape({
+      validate: (0, _utils.chain)((0, _utils.assertShape)({
         raw: {
-          validate: assertValueType("string")
+          validate: (0, _utils.assertValueType)("string")
         },
         cooked: {
-          validate: assertValueType("string"),
+          validate: (0, _utils.assertValueType)("string"),
           optional: true
@@ -1433,3 +1445,3 @@ }
           firstInvalidLoc
-        } = readStringContents("template", raw, 0, 0, 0, {
+        } = (0, _helperStringParser.readStringContents)("template", raw, 0, 0, 0, {
           unterminated() {
@@ -1459,6 +1471,6 @@ unterminatedCalled = true;
     quasis: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("TemplateElement")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement")))
     },
     expressions: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Expression", "TSType")), function (node, key, val) {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function (node, key, val) {
         if (node.quasis.length !== val.length + 1) {
@@ -1477,3 +1489,3 @@ throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`);
     delegate: {
-      validate: chain(assertValueType("boolean"), Object.assign(function (node, key, val) {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
         if (!process.env.BABEL_TYPES_8_BREAKING) return;
@@ -1490,3 +1502,3 @@ if (val && !node.argument) {
       optional: true,
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -1501,3 +1513,3 @@ }
     argument: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -1513,3 +1525,3 @@ }
     value: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     }
@@ -1524,3 +1536,3 @@ },
     exported: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     }
@@ -1535,8 +1547,8 @@ }
     object: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     property: {
       validate: function () {
-        const normal = assertNodeType("Identifier");
-        const computed = assertNodeType("Expression");
+        const normal = (0, _utils.assertNodeType)("Identifier");
+        const computed = (0, _utils.assertNodeType)("Expression");
         const validator = Object.assign(function (node, key, val) {
@@ -1555,3 +1567,3 @@ const validator = node.computed ? computed : normal;
     optional: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? assertValueType("boolean") : chain(assertValueType("boolean"), assertOptionalChainStart())
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
     }
@@ -1566,16 +1578,16 @@ }
     callee: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     arguments: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
     },
     optional: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? assertValueType("boolean") : chain(assertValueType("boolean"), assertOptionalChainStart())
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
     },
     typeArguments: {
-      validate: assertNodeType("TypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
       optional: true
     },
     typeParameters: {
-      validate: assertNodeType("TSTypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
       optional: true
@@ -1591,27 +1603,27 @@ }
     value: {
-      validate: assertNodeType("Expression"),
+      validate: (0, _utils.assertNodeType)("Expression"),
       optional: true
     },
     definite: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     typeAnnotation: {
-      validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+      validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
       optional: true
     },
     decorators: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
     },
     readonly: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     declare: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     variance: {
-      validate: assertNodeType("Variance"),
+      validate: (0, _utils.assertNodeType)("Variance"),
       optional: true
@@ -1627,5 +1639,5 @@ }
     key: {
-      validate: chain(function () {
-        const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName");
-        const computed = assertNodeType("Expression");
+      validate: (0, _utils.chain)(function () {
+        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName");
+        const computed = (0, _utils.assertNodeType)("Expression");
         return function (node, key, val) {
@@ -1635,30 +1647,30 @@ const validator = node.computed ? computed : normal;
         };
-      }(), assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName"))
+      }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName"))
     },
     value: {
-      validate: assertNodeType("Expression"),
+      validate: (0, _utils.assertNodeType)("Expression"),
       optional: true
     },
     definite: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     typeAnnotation: {
-      validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+      validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
       optional: true
     },
     decorators: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
     },
     readonly: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     declare: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     variance: {
-      validate: assertNodeType("Variance"),
+      validate: (0, _utils.assertNodeType)("Variance"),
       optional: true
@@ -1674,30 +1686,30 @@ }
     key: {
-      validate: assertNodeType("PrivateName")
+      validate: (0, _utils.assertNodeType)("PrivateName")
     },
     value: {
-      validate: assertNodeType("Expression"),
+      validate: (0, _utils.assertNodeType)("Expression"),
       optional: true
     },
     typeAnnotation: {
-      validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+      validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
       optional: true
     },
     decorators: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
     },
     static: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       default: false
     },
     readonly: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     definite: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     variance: {
-      validate: assertNodeType("Variance"),
+      validate: (0, _utils.assertNodeType)("Variance"),
       optional: true
@@ -1713,10 +1725,10 @@ }
     kind: {
-      validate: assertOneOf("get", "set", "method"),
+      validate: (0, _utils.assertOneOf)("get", "set", "method"),
       default: "method"
     },
     key: {
-      validate: assertNodeType("PrivateName")
+      validate: (0, _utils.assertNodeType)("PrivateName")
     },
     body: {
-      validate: assertNodeType("BlockStatement")
+      validate: (0, _utils.assertNodeType)("BlockStatement")
     }
@@ -1730,3 +1742,3 @@ })
     id: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     }
@@ -1739,3 +1751,3 @@ }
     body: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Statement")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
     }
@@ -1742,0 +1754,0 @@ },

lib/definitions/deprecated-aliases.js

@@ -1,5 +0,12 @@
-export const DEPRECATED_ALIASES = {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEPRECATED_ALIASES = void 0;
+const DEPRECATED_ALIASES = {
   ModuleDeclaration: "ImportOrExportDeclaration"
 };
+exports.DEPRECATED_ALIASES = DEPRECATED_ALIASES;
 
 //# sourceMappingURL=deprecated-aliases.js.map

lib/definitions/experimental.js

@@ -1,4 +0,6 @@
-import defineType, { assertEach, assertNodeType, assertValueType, chain } from "./utils.js";
-defineType("ArgumentPlaceholder", {});
-defineType("BindExpression", {
+"use strict";
+
+var _utils = require("./utils");
+(0, _utils.default)("ArgumentPlaceholder", {});
+(0, _utils.default)("BindExpression", {
   visitor: ["object", "callee"],
@@ -19,29 +21,29 @@ aliases: ["Expression"],
     object: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     },
     callee: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
   }
 });
-defineType("ImportAttribute", {
+(0, _utils.default)("ImportAttribute", {
   visitor: ["key", "value"],
   fields: {
     key: {
-      validate: assertNodeType("Identifier", "StringLiteral")
+      validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
     },
     value: {
-      validate: assertNodeType("StringLiteral")
+      validate: (0, _utils.assertNodeType)("StringLiteral")
     }
   }
 });
-defineType("Decorator", {
+(0, _utils.default)("Decorator", {
   visitor: ["expression"],
   fields: {
     expression: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
   }
 });
-defineType("DoExpression", {
+(0, _utils.default)("DoExpression", {
   visitor: ["body"],
@@ -52,6 +54,6 @@ builder: ["body", "async"],
     body: {
-      validate: assertNodeType("BlockStatement")
+      validate: (0, _utils.assertNodeType)("BlockStatement")
     },
     async: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       default: false
@@ -61,3 +63,3 @@ }
 });
-defineType("ExportDefaultSpecifier", {
+(0, _utils.default)("ExportDefaultSpecifier", {
   visitor: ["exported"],
@@ -67,7 +69,7 @@ aliases: ["ModuleSpecifier"],
     exported: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     }
   }
 });
-defineType("RecordExpression", {
+(0, _utils.default)("RecordExpression", {
   visitor: ["properties"],
@@ -77,10 +79,10 @@ aliases: ["Expression"],
     properties: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("ObjectProperty", "SpreadElement")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "SpreadElement")))
     }
   }
 });
-defineType("TupleExpression", {
+(0, _utils.default)("TupleExpression", {
   fields: {
     elements: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Expression", "SpreadElement"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))),
       default: []
@@ -92,7 +94,7 @@ }
 });
-defineType("DecimalLiteral", {
+(0, _utils.default)("DecimalLiteral", {
   builder: ["value"],
   fields: {
     value: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     }
@@ -102,7 +104,7 @@ },
 });
-defineType("ModuleExpression", {
+(0, _utils.default)("ModuleExpression", {
   visitor: ["body"],
   fields: {
     body: {
-      validate: assertNodeType("Program")
+      validate: (0, _utils.assertNodeType)("Program")
     }
@@ -112,6 +114,6 @@ },
 });
-defineType("TopicReference", {
+(0, _utils.default)("TopicReference", {
   aliases: ["Expression"]
 });
-defineType("PipelineTopicExpression", {
+(0, _utils.default)("PipelineTopicExpression", {
   builder: ["expression"],
@@ -121,3 +123,3 @@ visitor: ["expression"],
     expression: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -127,3 +129,3 @@ },
 });
-defineType("PipelineBareFunction", {
+(0, _utils.default)("PipelineBareFunction", {
   builder: ["callee"],
@@ -133,3 +135,3 @@ visitor: ["callee"],
     callee: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -139,3 +141,3 @@ },
 });
-defineType("PipelinePrimaryTopicReference", {
+(0, _utils.default)("PipelinePrimaryTopicReference", {
   aliases: ["Expression"]
@@ -142,0 +144,0 @@ });

lib/definitions/flow.js

@@ -1,3 +0,5 @@
-import { defineAliasedType, arrayOfType, assertOneOf, assertValueType, validate, validateArrayOfType, validateOptional, validateOptionalType, validateType } from "./utils.js";
-const defineType = defineAliasedType("Flow");
+"use strict";
+
+var _utils = require("./utils");
+const defineType = (0, _utils.defineAliasedType)("Flow");
 const defineInterfaceishType = name => {
@@ -9,8 +11,8 @@ defineType(name, {
     fields: {
-      id: validateType("Identifier"),
-      typeParameters: validateOptionalType("TypeParameterDeclaration"),
-      extends: validateOptional(arrayOfType("InterfaceExtends")),
-      mixins: validateOptional(arrayOfType("InterfaceExtends")),
-      implements: validateOptional(arrayOfType("ClassImplements")),
-      body: validateType("ObjectTypeAnnotation")
+      id: (0, _utils.validateType)("Identifier"),
+      typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+      extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+      mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+      implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")),
+      body: (0, _utils.validateType)("ObjectTypeAnnotation")
     }
@@ -26,3 +28,3 @@ });
   fields: {
-    elementType: validateType("FlowType")
+    elementType: (0, _utils.validateType)("FlowType")
   }
@@ -37,3 +39,3 @@ });
   fields: {
-    value: validate(assertValueType("boolean"))
+    value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
   }
@@ -47,4 +49,4 @@ });
   fields: {
-    id: validateType("Identifier"),
-    typeParameters: validateOptionalType("TypeParameterInstantiation")
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
   }
@@ -57,4 +59,4 @@ });
   fields: {
-    id: validateType("Identifier"),
-    predicate: validateOptionalType("DeclaredPredicate")
+    id: (0, _utils.validateType)("Identifier"),
+    predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
   }
@@ -68,5 +70,5 @@ });
   fields: {
-    id: validateType(["Identifier", "StringLiteral"]),
-    body: validateType("BlockStatement"),
-    kind: validateOptional(assertOneOf("CommonJS", "ES"))
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    body: (0, _utils.validateType)("BlockStatement"),
+    kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
   }
@@ -78,3 +80,3 @@ });
   fields: {
-    typeAnnotation: validateType("TypeAnnotation")
+    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
   }
@@ -86,5 +88,5 @@ });
   fields: {
-    id: validateType("Identifier"),
-    typeParameters: validateOptionalType("TypeParameterDeclaration"),
-    right: validateType("FlowType")
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    right: (0, _utils.validateType)("FlowType")
   }
@@ -96,6 +98,6 @@ });
   fields: {
-    id: validateType("Identifier"),
-    typeParameters: validateOptionalType("TypeParameterDeclaration"),
-    supertype: validateOptionalType("FlowType"),
-    impltype: validateOptionalType("FlowType")
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    supertype: (0, _utils.validateOptionalType)("FlowType"),
+    impltype: (0, _utils.validateOptionalType)("FlowType")
   }
@@ -107,3 +109,3 @@ });
   fields: {
-    id: validateType("Identifier")
+    id: (0, _utils.validateType)("Identifier")
   }
@@ -115,6 +117,6 @@ });
   fields: {
-    declaration: validateOptionalType("Flow"),
-    specifiers: validateOptional(arrayOfType(["ExportSpecifier", "ExportNamespaceSpecifier"])),
-    source: validateOptionalType("StringLiteral"),
-    default: validateOptional(assertValueType("boolean"))
+    declaration: (0, _utils.validateOptionalType)("Flow"),
+    specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
+    source: (0, _utils.validateOptionalType)("StringLiteral"),
+    default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
   }
@@ -126,4 +128,4 @@ });
   fields: {
-    source: validateType("StringLiteral"),
-    exportKind: validateOptional(assertOneOf("type", "value"))
+    source: (0, _utils.validateType)("StringLiteral"),
+    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
   }
@@ -135,3 +137,3 @@ });
   fields: {
-    value: validateType("Flow")
+    value: (0, _utils.validateType)("Flow")
   }
@@ -146,7 +148,7 @@ });
   fields: {
-    typeParameters: validateOptionalType("TypeParameterDeclaration"),
-    params: validate(arrayOfType("FunctionTypeParam")),
-    rest: validateOptionalType("FunctionTypeParam"),
-    this: validateOptionalType("FunctionTypeParam"),
-    returnType: validateType("FlowType")
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
+    rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
+    this: (0, _utils.validateOptionalType)("FunctionTypeParam"),
+    returnType: (0, _utils.validateType)("FlowType")
   }
@@ -157,5 +159,5 @@ });
   fields: {
-    name: validateOptionalType("Identifier"),
-    typeAnnotation: validateType("FlowType"),
-    optional: validateOptional(assertValueType("boolean"))
+    name: (0, _utils.validateOptionalType)("Identifier"),
+    typeAnnotation: (0, _utils.validateType)("FlowType"),
+    optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
   }
@@ -167,4 +169,4 @@ });
   fields: {
-    id: validateType(["Identifier", "QualifiedTypeIdentifier"]),
-    typeParameters: validateOptionalType("TypeParameterInstantiation")
+    id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
   }
@@ -178,4 +180,4 @@ });
   fields: {
-    id: validateType(["Identifier", "QualifiedTypeIdentifier"]),
-    typeParameters: validateOptionalType("TypeParameterInstantiation")
+    id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
   }
@@ -188,4 +190,4 @@ });
   fields: {
-    extends: validateOptional(arrayOfType("InterfaceExtends")),
-    body: validateType("ObjectTypeAnnotation")
+    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+    body: (0, _utils.validateType)("ObjectTypeAnnotation")
   }
@@ -197,3 +199,3 @@ });
   fields: {
-    types: validate(arrayOfType("FlowType"))
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
   }
@@ -211,3 +213,3 @@ });
   fields: {
-    typeAnnotation: validateType("FlowType")
+    typeAnnotation: (0, _utils.validateType)("FlowType")
   }
@@ -219,3 +221,3 @@ });
   fields: {
-    value: validate(assertValueType("number"))
+    value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
   }
@@ -231,5 +233,5 @@ });
   fields: {
-    properties: validate(arrayOfType(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
+    properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
     indexers: {
-      validate: arrayOfType("ObjectTypeIndexer"),
+      validate: (0, _utils.arrayOfType)("ObjectTypeIndexer"),
       optional: true,
@@ -239,3 +241,3 @@ default: []
     callProperties: {
-      validate: arrayOfType("ObjectTypeCallProperty"),
+      validate: (0, _utils.arrayOfType)("ObjectTypeCallProperty"),
       optional: true,
@@ -245,3 +247,3 @@ default: []
     internalSlots: {
-      validate: arrayOfType("ObjectTypeInternalSlot"),
+      validate: (0, _utils.arrayOfType)("ObjectTypeInternalSlot"),
       optional: true,
@@ -251,6 +253,6 @@ default: []
     exact: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       default: false
     },
-    inexact: validateOptional(assertValueType("boolean"))
+    inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
   }
@@ -262,7 +264,7 @@ });
   fields: {
-    id: validateType("Identifier"),
-    value: validateType("FlowType"),
-    optional: validate(assertValueType("boolean")),
-    static: validate(assertValueType("boolean")),
-    method: validate(assertValueType("boolean"))
+    id: (0, _utils.validateType)("Identifier"),
+    value: (0, _utils.validateType)("FlowType"),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
   }
@@ -274,4 +276,4 @@ });
   fields: {
-    value: validateType("FlowType"),
-    static: validate(assertValueType("boolean"))
+    value: (0, _utils.validateType)("FlowType"),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
   }
@@ -283,7 +285,7 @@ });
   fields: {
-    id: validateOptionalType("Identifier"),
-    key: validateType("FlowType"),
-    value: validateType("FlowType"),
-    static: validate(assertValueType("boolean")),
-    variance: validateOptionalType("Variance")
+    id: (0, _utils.validateOptionalType)("Identifier"),
+    key: (0, _utils.validateType)("FlowType"),
+    value: (0, _utils.validateType)("FlowType"),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    variance: (0, _utils.validateOptionalType)("Variance")
   }
@@ -295,10 +297,10 @@ });
   fields: {
-    key: validateType(["Identifier", "StringLiteral"]),
-    value: validateType("FlowType"),
-    kind: validate(assertOneOf("init", "get", "set")),
-    static: validate(assertValueType("boolean")),
-    proto: validate(assertValueType("boolean")),
-    optional: validate(assertValueType("boolean")),
-    variance: validateOptionalType("Variance"),
-    method: validate(assertValueType("boolean"))
+    key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    value: (0, _utils.validateType)("FlowType"),
+    kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    variance: (0, _utils.validateOptionalType)("Variance"),
+    method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
   }
@@ -310,3 +312,3 @@ });
   fields: {
-    argument: validateType("FlowType")
+    argument: (0, _utils.validateType)("FlowType")
   }
@@ -318,6 +320,6 @@ });
   fields: {
-    id: validateType("Identifier"),
-    typeParameters: validateOptionalType("TypeParameterDeclaration"),
-    supertype: validateOptionalType("FlowType"),
-    impltype: validateType("FlowType")
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    supertype: (0, _utils.validateOptionalType)("FlowType"),
+    impltype: (0, _utils.validateType)("FlowType")
   }
@@ -328,4 +330,4 @@ });
   fields: {
-    id: validateType("Identifier"),
-    qualification: validateType(["Identifier", "QualifiedTypeIdentifier"])
+    id: (0, _utils.validateType)("Identifier"),
+    qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
   }
@@ -337,3 +339,3 @@ });
   fields: {
-    value: validate(assertValueType("string"))
+    value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
   }
@@ -354,3 +356,3 @@ });
   fields: {
-    types: validate(arrayOfType("FlowType"))
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
   }
@@ -362,3 +364,3 @@ });
   fields: {
-    argument: validateType("FlowType")
+    argument: (0, _utils.validateType)("FlowType")
   }
@@ -370,5 +372,5 @@ });
   fields: {
-    id: validateType("Identifier"),
-    typeParameters: validateOptionalType("TypeParameterDeclaration"),
-    right: validateType("FlowType")
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    right: (0, _utils.validateType)("FlowType")
   }
@@ -379,3 +381,3 @@ });
   fields: {
-    typeAnnotation: validateType("FlowType")
+    typeAnnotation: (0, _utils.validateType)("FlowType")
   }
@@ -387,4 +389,4 @@ });
   fields: {
-    expression: validateType("Expression"),
-    typeAnnotation: validateType("TypeAnnotation")
+    expression: (0, _utils.validateType)("Expression"),
+    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
   }
@@ -395,6 +397,6 @@ });
   fields: {
-    name: validate(assertValueType("string")),
-    bound: validateOptionalType("TypeAnnotation"),
-    default: validateOptionalType("FlowType"),
-    variance: validateOptionalType("Variance")
+    name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+    bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
+    default: (0, _utils.validateOptionalType)("FlowType"),
+    variance: (0, _utils.validateOptionalType)("Variance")
   }
@@ -405,3 +407,3 @@ });
   fields: {
-    params: validate(arrayOfType("TypeParameter"))
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
   }
@@ -412,3 +414,3 @@ });
   fields: {
-    params: validate(arrayOfType("FlowType"))
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
   }
@@ -420,3 +422,3 @@ });
   fields: {
-    types: validate(arrayOfType("FlowType"))
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
   }
@@ -427,3 +429,3 @@ });
   fields: {
-    kind: validate(assertOneOf("minus", "plus"))
+    kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus"))
   }
@@ -438,4 +440,4 @@ });
   fields: {
-    id: validateType("Identifier"),
-    body: validateType(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"])
+    id: (0, _utils.validateType)("Identifier"),
+    body: (0, _utils.validateType)(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"])
   }
@@ -447,5 +449,5 @@ });
   fields: {
-    explicitType: validate(assertValueType("boolean")),
-    members: validateArrayOfType("EnumBooleanMember"),
-    hasUnknownMembers: validate(assertValueType("boolean"))
+    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    members: (0, _utils.validateArrayOfType)("EnumBooleanMember"),
+    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
   }
@@ -457,5 +459,5 @@ });
   fields: {
-    explicitType: validate(assertValueType("boolean")),
-    members: validateArrayOfType("EnumNumberMember"),
-    hasUnknownMembers: validate(assertValueType("boolean"))
+    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    members: (0, _utils.validateArrayOfType)("EnumNumberMember"),
+    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
   }
@@ -467,5 +469,5 @@ });
   fields: {
-    explicitType: validate(assertValueType("boolean")),
-    members: validateArrayOfType(["EnumStringMember", "EnumDefaultedMember"]),
-    hasUnknownMembers: validate(assertValueType("boolean"))
+    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    members: (0, _utils.validateArrayOfType)(["EnumStringMember", "EnumDefaultedMember"]),
+    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
   }
@@ -477,4 +479,4 @@ });
   fields: {
-    members: validateArrayOfType("EnumDefaultedMember"),
-    hasUnknownMembers: validate(assertValueType("boolean"))
+    members: (0, _utils.validateArrayOfType)("EnumDefaultedMember"),
+    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
   }
@@ -486,4 +488,4 @@ });
   fields: {
-    id: validateType("Identifier"),
-    init: validateType("BooleanLiteral")
+    id: (0, _utils.validateType)("Identifier"),
+    init: (0, _utils.validateType)("BooleanLiteral")
   }
@@ -495,4 +497,4 @@ });
   fields: {
-    id: validateType("Identifier"),
-    init: validateType("NumericLiteral")
+    id: (0, _utils.validateType)("Identifier"),
+    init: (0, _utils.validateType)("NumericLiteral")
   }
@@ -504,4 +506,4 @@ });
   fields: {
-    id: validateType("Identifier"),
-    init: validateType("StringLiteral")
+    id: (0, _utils.validateType)("Identifier"),
+    init: (0, _utils.validateType)("StringLiteral")
   }
@@ -513,3 +515,3 @@ });
   fields: {
-    id: validateType("Identifier")
+    id: (0, _utils.validateType)("Identifier")
   }
@@ -521,4 +523,4 @@ });
   fields: {
-    objectType: validateType("FlowType"),
-    indexType: validateType("FlowType")
+    objectType: (0, _utils.validateType)("FlowType"),
+    indexType: (0, _utils.validateType)("FlowType")
   }
@@ -530,5 +532,5 @@ });
   fields: {
-    objectType: validateType("FlowType"),
-    indexType: validateType("FlowType"),
-    optional: validate(assertValueType("boolean"))
+    objectType: (0, _utils.validateType)("FlowType"),
+    indexType: (0, _utils.validateType)("FlowType"),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
   }
@@ -535,0 +537,0 @@ });

lib/definitions/index.js

@@ -1,25 +0,97 @@
-import toFastProperties from "to-fast-properties";
-import "./core.js";
-import "./flow.js";
-import "./jsx.js";
-import "./misc.js";
-import "./experimental.js";
-import "./typescript.js";
-import { VISITOR_KEYS, ALIAS_KEYS, FLIPPED_ALIAS_KEYS, NODE_FIELDS, BUILDER_KEYS, DEPRECATED_KEYS, NODE_PARENT_VALIDATIONS } from "./utils.js";
-import { PLACEHOLDERS, PLACEHOLDERS_ALIAS, PLACEHOLDERS_FLIPPED_ALIAS } from "./placeholders.js";
-import { DEPRECATED_ALIASES } from "./deprecated-aliases.js";
-Object.keys(DEPRECATED_ALIASES).forEach(deprecatedAlias => {
-  FLIPPED_ALIAS_KEYS[deprecatedAlias] = FLIPPED_ALIAS_KEYS[DEPRECATED_ALIASES[deprecatedAlias]];
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-toFastProperties(VISITOR_KEYS);
-toFastProperties(ALIAS_KEYS);
-toFastProperties(FLIPPED_ALIAS_KEYS);
-toFastProperties(NODE_FIELDS);
-toFastProperties(BUILDER_KEYS);
-toFastProperties(DEPRECATED_KEYS);
-toFastProperties(PLACEHOLDERS_ALIAS);
-toFastProperties(PLACEHOLDERS_FLIPPED_ALIAS);
-const TYPES = [].concat(Object.keys(VISITOR_KEYS), Object.keys(FLIPPED_ALIAS_KEYS), Object.keys(DEPRECATED_KEYS));
-export { VISITOR_KEYS, ALIAS_KEYS, FLIPPED_ALIAS_KEYS, NODE_FIELDS, BUILDER_KEYS, DEPRECATED_ALIASES, DEPRECATED_KEYS, NODE_PARENT_VALIDATIONS, PLACEHOLDERS, PLACEHOLDERS_ALIAS, PLACEHOLDERS_FLIPPED_ALIAS, TYPES };
+Object.defineProperty(exports, "ALIAS_KEYS", {
+  enumerable: true,
+  get: function () {
+    return _utils.ALIAS_KEYS;
+  }
+});
+Object.defineProperty(exports, "BUILDER_KEYS", {
+  enumerable: true,
+  get: function () {
+    return _utils.BUILDER_KEYS;
+  }
+});
+Object.defineProperty(exports, "DEPRECATED_ALIASES", {
+  enumerable: true,
+  get: function () {
+    return _deprecatedAliases.DEPRECATED_ALIASES;
+  }
+});
+Object.defineProperty(exports, "DEPRECATED_KEYS", {
+  enumerable: true,
+  get: function () {
+    return _utils.DEPRECATED_KEYS;
+  }
+});
+Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
+  enumerable: true,
+  get: function () {
+    return _utils.FLIPPED_ALIAS_KEYS;
+  }
+});
+Object.defineProperty(exports, "NODE_FIELDS", {
+  enumerable: true,
+  get: function () {
+    return _utils.NODE_FIELDS;
+  }
+});
+Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", {
+  enumerable: true,
+  get: function () {
+    return _utils.NODE_PARENT_VALIDATIONS;
+  }
+});
+Object.defineProperty(exports, "PLACEHOLDERS", {
+  enumerable: true,
+  get: function () {
+    return _placeholders.PLACEHOLDERS;
+  }
+});
+Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", {
+  enumerable: true,
+  get: function () {
+    return _placeholders.PLACEHOLDERS_ALIAS;
+  }
+});
+Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", {
+  enumerable: true,
+  get: function () {
+    return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS;
+  }
+});
+exports.TYPES = void 0;
+Object.defineProperty(exports, "VISITOR_KEYS", {
+  enumerable: true,
+  get: function () {
+    return _utils.VISITOR_KEYS;
+  }
+});
+var _toFastProperties = require("to-fast-properties");
+require("./core");
+require("./flow");
+require("./jsx");
+require("./misc");
+require("./experimental");
+require("./typescript");
+var _utils = require("./utils");
+var _placeholders = require("./placeholders");
+var _deprecatedAliases = require("./deprecated-aliases");
+Object.keys(_deprecatedAliases.DEPRECATED_ALIASES).forEach(deprecatedAlias => {
+  _utils.FLIPPED_ALIAS_KEYS[deprecatedAlias] = _utils.FLIPPED_ALIAS_KEYS[_deprecatedAliases.DEPRECATED_ALIASES[deprecatedAlias]];
+});
+_toFastProperties(_utils.VISITOR_KEYS);
+_toFastProperties(_utils.ALIAS_KEYS);
+_toFastProperties(_utils.FLIPPED_ALIAS_KEYS);
+_toFastProperties(_utils.NODE_FIELDS);
+_toFastProperties(_utils.BUILDER_KEYS);
+_toFastProperties(_utils.DEPRECATED_KEYS);
+_toFastProperties(_placeholders.PLACEHOLDERS_ALIAS);
+_toFastProperties(_placeholders.PLACEHOLDERS_FLIPPED_ALIAS);
+const TYPES = [].concat(Object.keys(_utils.VISITOR_KEYS), Object.keys(_utils.FLIPPED_ALIAS_KEYS), Object.keys(_utils.DEPRECATED_KEYS));
+exports.TYPES = TYPES;
 
 //# sourceMappingURL=index.js.map

lib/definitions/jsx.js

@@ -1,3 +0,5 @@
-import { defineAliasedType, assertNodeType, assertValueType, chain, assertEach } from "./utils.js";
-const defineType = defineAliasedType("JSX");
+"use strict";
+
+var _utils = require("./utils");
+const defineType = (0, _utils.defineAliasedType)("JSX");
 defineType("JSXAttribute", {
@@ -8,7 +10,7 @@ visitor: ["name", "value"],
     name: {
-      validate: assertNodeType("JSXIdentifier", "JSXNamespacedName")
+      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
     },
     value: {
       optional: true,
-      validate: assertNodeType("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
+      validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
     }
@@ -22,3 +24,3 @@ }
     name: {
-      validate: assertNodeType("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
+      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
     }
@@ -33,14 +35,14 @@ }
     openingElement: {
-      validate: assertNodeType("JSXOpeningElement")
+      validate: (0, _utils.assertNodeType)("JSXOpeningElement")
     },
     closingElement: {
       optional: true,
-      validate: assertNodeType("JSXClosingElement")
+      validate: (0, _utils.assertNodeType)("JSXClosingElement")
     },
     children: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
     }
   }, {
     selfClosing: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
@@ -56,3 +58,3 @@ }
     expression: {
-      validate: assertNodeType("Expression", "JSXEmptyExpression")
+      validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression")
     }
@@ -66,3 +68,3 @@ }
     expression: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -75,3 +77,3 @@ }
     name: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     }
@@ -84,6 +86,6 @@ }
     object: {
-      validate: assertNodeType("JSXMemberExpression", "JSXIdentifier")
+      validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
     },
     property: {
-      validate: assertNodeType("JSXIdentifier")
+      validate: (0, _utils.assertNodeType)("JSXIdentifier")
     }
@@ -96,6 +98,6 @@ }
     namespace: {
-      validate: assertNodeType("JSXIdentifier")
+      validate: (0, _utils.assertNodeType)("JSXIdentifier")
     },
     name: {
-      validate: assertNodeType("JSXIdentifier")
+      validate: (0, _utils.assertNodeType)("JSXIdentifier")
     }
@@ -110,3 +112,3 @@ }
     name: {
-      validate: assertNodeType("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
+      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
     },
@@ -117,6 +119,6 @@ selfClosing: {
     attributes: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("JSXAttribute", "JSXSpreadAttribute")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
     },
     typeParameters: {
-      validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
       optional: true
@@ -130,3 +132,3 @@ }
     argument: {
-      validate: assertNodeType("Expression")
+      validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -140,3 +142,3 @@ }
     value: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     }
@@ -151,9 +153,9 @@ }
     openingFragment: {
-      validate: assertNodeType("JSXOpeningFragment")
+      validate: (0, _utils.assertNodeType)("JSXOpeningFragment")
     },
     closingFragment: {
-      validate: assertNodeType("JSXClosingFragment")
+      validate: (0, _utils.assertNodeType)("JSXClosingFragment")
     },
     children: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
     }
@@ -160,0 +162,0 @@ }

lib/definitions/misc.js

@@ -1,4 +0,6 @@
-import { defineAliasedType, assertNodeType, assertOneOf, assertValueType } from "./utils.js";
-import { PLACEHOLDERS } from "./placeholders.js";
-const defineType = defineAliasedType("Miscellaneous");
+"use strict";
+
+var _utils = require("./utils");
+var _placeholders = require("./placeholders");
+const defineType = (0, _utils.defineAliasedType)("Miscellaneous");
 {
@@ -14,6 +16,6 @@ defineType("Noop", {
     name: {
-      validate: assertNodeType("Identifier")
+      validate: (0, _utils.assertNodeType)("Identifier")
     },
     expectedNode: {
-      validate: assertOneOf(...PLACEHOLDERS)
+      validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS)
     }
@@ -26,3 +28,3 @@ }
     name: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     }
@@ -29,0 +31,0 @@ }

lib/definitions/placeholders.js

@@ -1,12 +0,21 @@
-import { ALIAS_KEYS } from "./utils.js";
-export const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
-export const PLACEHOLDERS_ALIAS = {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0;
+var _utils = require("./utils");
+const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
+exports.PLACEHOLDERS = PLACEHOLDERS;
+const PLACEHOLDERS_ALIAS = {
   Declaration: ["Statement"],
   Pattern: ["PatternLike", "LVal"]
 };
+exports.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS;
 for (const type of PLACEHOLDERS) {
-  const alias = ALIAS_KEYS[type];
+  const alias = _utils.ALIAS_KEYS[type];
   if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias;
 }
-export const PLACEHOLDERS_FLIPPED_ALIAS = {};
+const PLACEHOLDERS_FLIPPED_ALIAS = {};
+exports.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS;
 Object.keys(PLACEHOLDERS_ALIAS).forEach(type => {
@@ -13,0 +22,0 @@ PLACEHOLDERS_ALIAS[type].forEach(alias => {

lib/definitions/typescript.js

@@ -1,13 +0,15 @@
-import { defineAliasedType, arrayOfType, assertEach, assertNodeType, assertOneOf, assertValueType, chain, validate, validateArrayOfType, validateOptional, validateOptionalType, validateType } from "./utils.js";
-import { functionDeclarationCommon, classMethodOrDeclareMethodCommon } from "./core.js";
-import is from "../validators/is.js";
-const defineType = defineAliasedType("TypeScript");
-const bool = assertValueType("boolean");
+"use strict";
+
+var _utils = require("./utils");
+var _core = require("./core");
+var _is = require("../validators/is");
+const defineType = (0, _utils.defineAliasedType)("TypeScript");
+const bool = (0, _utils.assertValueType)("boolean");
 const tSFunctionTypeAnnotationCommon = () => ({
   returnType: {
-    validate: assertNodeType("TSTypeAnnotation", "Noop"),
+    validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
     optional: true
   },
   typeParameters: {
-    validate: assertNodeType("TSTypeParameterDeclaration", "Noop"),
+    validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
     optional: true
@@ -21,18 +23,18 @@ }
     accessibility: {
-      validate: assertOneOf("public", "private", "protected"),
+      validate: (0, _utils.assertOneOf)("public", "private", "protected"),
       optional: true
     },
     readonly: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     parameter: {
-      validate: assertNodeType("Identifier", "AssignmentPattern")
+      validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
     },
     override: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     decorators: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("Decorator"))),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
@@ -45,7 +47,7 @@ }
   visitor: ["id", "typeParameters", "params", "returnType"],
-  fields: Object.assign({}, functionDeclarationCommon(), tSFunctionTypeAnnotationCommon())
+  fields: Object.assign({}, (0, _core.functionDeclarationCommon)(), tSFunctionTypeAnnotationCommon())
 });
 defineType("TSDeclareMethod", {
   visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
-  fields: Object.assign({}, classMethodOrDeclareMethodCommon(), tSFunctionTypeAnnotationCommon())
+  fields: Object.assign({}, (0, _core.classMethodOrDeclareMethodCommon)(), tSFunctionTypeAnnotationCommon())
 });
@@ -56,10 +58,10 @@ defineType("TSQualifiedName", {
   fields: {
-    left: validateType("TSEntityName"),
-    right: validateType("Identifier")
+    left: (0, _utils.validateType)("TSEntityName"),
+    right: (0, _utils.validateType)("Identifier")
   }
 });
 const signatureDeclarationCommon = () => ({
-  typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
-  ["parameters"]: validateArrayOfType(["Identifier", "RestElement"]),
-  ["typeAnnotation"]: validateOptionalType("TSTypeAnnotation")
+  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+  ["parameters"]: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
+  ["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation")
 });
@@ -74,7 +76,7 @@ const callConstructSignatureDeclaration = {
 const namedTypeElementCommon = () => ({
-  key: validateType("Expression"),
+  key: (0, _utils.validateType)("Expression"),
   computed: {
     default: false
   },
-  optional: validateOptional(bool)
+  optional: (0, _utils.validateOptional)(bool)
 });
@@ -85,7 +87,7 @@ defineType("TSPropertySignature", {
   fields: Object.assign({}, namedTypeElementCommon(), {
-    readonly: validateOptional(bool),
-    typeAnnotation: validateOptionalType("TSTypeAnnotation"),
-    initializer: validateOptionalType("Expression"),
+    readonly: (0, _utils.validateOptional)(bool),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
+    initializer: (0, _utils.validateOptionalType)("Expression"),
     kind: {
-      validate: assertOneOf("get", "set")
+      validate: (0, _utils.assertOneOf)("get", "set")
     }
@@ -99,3 +101,3 @@ })
     kind: {
-      validate: assertOneOf("method", "get", "set")
+      validate: (0, _utils.assertOneOf)("method", "get", "set")
     }
@@ -108,6 +110,6 @@ })
   fields: {
-    readonly: validateOptional(bool),
-    static: validateOptional(bool),
-    parameters: validateArrayOfType("Identifier"),
-    typeAnnotation: validateOptionalType("TSTypeAnnotation")
+    readonly: (0, _utils.validateOptional)(bool),
+    static: (0, _utils.validateOptional)(bool),
+    parameters: (0, _utils.validateArrayOfType)("Identifier"),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
   }
@@ -137,3 +139,3 @@ });
   fields: Object.assign({}, signatureDeclarationCommon(), {
-    abstract: validateOptional(bool)
+    abstract: (0, _utils.validateOptional)(bool)
   })
@@ -145,4 +147,4 @@ }));
   fields: {
-    typeName: validateType("TSEntityName"),
-    typeParameters: validateOptionalType("TSTypeParameterInstantiation")
+    typeName: (0, _utils.validateType)("TSEntityName"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
   }
@@ -155,5 +157,5 @@ });
   fields: {
-    parameterName: validateType(["Identifier", "TSThisType"]),
-    typeAnnotation: validateOptionalType("TSTypeAnnotation"),
-    asserts: validateOptional(bool)
+    parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
+    asserts: (0, _utils.validateOptional)(bool)
   }
@@ -165,4 +167,4 @@ });
   fields: {
-    exprName: validateType(["TSEntityName", "TSImportType"]),
-    typeParameters: validateOptionalType("TSTypeParameterInstantiation")
+    exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"]),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
   }
@@ -174,3 +176,3 @@ });
   fields: {
-    members: validateArrayOfType("TSTypeElement")
+    members: (0, _utils.validateArrayOfType)("TSTypeElement")
   }
@@ -182,3 +184,3 @@ });
   fields: {
-    elementType: validateType("TSType")
+    elementType: (0, _utils.validateType)("TSType")
   }
@@ -190,3 +192,3 @@ });
   fields: {
-    elementTypes: validateArrayOfType(["TSType", "TSNamedTupleMember"])
+    elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
   }
@@ -198,3 +200,3 @@ });
   fields: {
-    typeAnnotation: validateType("TSType")
+    typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -206,3 +208,3 @@ });
   fields: {
-    typeAnnotation: validateType("TSType")
+    typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -214,3 +216,3 @@ });
   fields: {
-    label: validateType("Identifier"),
+    label: (0, _utils.validateType)("Identifier"),
     optional: {
@@ -220,3 +222,3 @@ validate: bool,
     },
-    elementType: validateType("TSType")
+    elementType: (0, _utils.validateType)("TSType")
   }
@@ -228,3 +230,3 @@ });
   fields: {
-    types: validateArrayOfType("TSType")
+    types: (0, _utils.validateArrayOfType)("TSType")
   }
@@ -238,6 +240,6 @@ };
   fields: {
-    checkType: validateType("TSType"),
-    extendsType: validateType("TSType"),
-    trueType: validateType("TSType"),
-    falseType: validateType("TSType")
+    checkType: (0, _utils.validateType)("TSType"),
+    extendsType: (0, _utils.validateType)("TSType"),
+    trueType: (0, _utils.validateType)("TSType"),
+    falseType: (0, _utils.validateType)("TSType")
   }
@@ -249,3 +251,3 @@ });
   fields: {
-    typeParameter: validateType("TSTypeParameter")
+    typeParameter: (0, _utils.validateType)("TSTypeParameter")
   }
@@ -257,3 +259,3 @@ });
   fields: {
-    typeAnnotation: validateType("TSType")
+    typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -265,4 +267,4 @@ });
   fields: {
-    operator: validate(assertValueType("string")),
-    typeAnnotation: validateType("TSType")
+    operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+    typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -274,4 +276,4 @@ });
   fields: {
-    objectType: validateType("TSType"),
-    indexType: validateType("TSType")
+    objectType: (0, _utils.validateType)("TSType"),
+    indexType: (0, _utils.validateType)("TSType")
   }
@@ -283,7 +285,7 @@ });
   fields: {
-    readonly: validateOptional(assertOneOf(true, false, "+", "-")),
-    typeParameter: validateType("TSTypeParameter"),
-    optional: validateOptional(assertOneOf(true, false, "+", "-")),
-    typeAnnotation: validateOptionalType("TSType"),
-    nameType: validateOptionalType("TSType")
+    readonly: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")),
+    typeParameter: (0, _utils.validateType)("TSTypeParameter"),
+    optional: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSType"),
+    nameType: (0, _utils.validateOptionalType)("TSType")
   }
@@ -297,7 +299,7 @@ });
       validate: function () {
-        const unaryExpression = assertNodeType("NumericLiteral", "BigIntLiteral");
-        const unaryOperator = assertOneOf("-");
-        const literal = assertNodeType("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
+        const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral");
+        const unaryOperator = (0, _utils.assertOneOf)("-");
+        const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
         function validator(parent, key, node) {
-          if (is("UnaryExpression", node)) {
+          if ((0, _is.default)("UnaryExpression", node)) {
             unaryOperator(node, "operator", node.operator);
@@ -319,4 +321,4 @@ unaryExpression(node, "argument", node.argument);
   fields: {
-    expression: validateType("TSEntityName"),
-    typeParameters: validateOptionalType("TSTypeParameterInstantiation")
+    expression: (0, _utils.validateType)("TSEntityName"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
   }
@@ -328,7 +330,7 @@ });
   fields: {
-    declare: validateOptional(bool),
-    id: validateType("Identifier"),
-    typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
-    extends: validateOptional(arrayOfType("TSExpressionWithTypeArguments")),
-    body: validateType("TSInterfaceBody")
+    declare: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
+    body: (0, _utils.validateType)("TSInterfaceBody")
   }
@@ -339,3 +341,3 @@ });
   fields: {
-    body: validateArrayOfType("TSTypeElement")
+    body: (0, _utils.validateArrayOfType)("TSTypeElement")
   }
@@ -347,6 +349,6 @@ });
   fields: {
-    declare: validateOptional(bool),
-    id: validateType("Identifier"),
-    typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
-    typeAnnotation: validateType("TSType")
+    declare: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+    typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -358,4 +360,4 @@ });
   fields: {
-    expression: validateType("Expression"),
-    typeParameters: validateOptionalType("TSTypeParameterInstantiation")
+    expression: (0, _utils.validateType)("Expression"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
   }
@@ -367,4 +369,4 @@ });
   fields: {
-    expression: validateType("Expression"),
-    typeAnnotation: validateType("TSType")
+    expression: (0, _utils.validateType)("Expression"),
+    typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -378,4 +380,4 @@ };
   fields: {
-    typeAnnotation: validateType("TSType"),
-    expression: validateType("Expression")
+    typeAnnotation: (0, _utils.validateType)("TSType"),
+    expression: (0, _utils.validateType)("Expression")
   }
@@ -387,7 +389,7 @@ });
   fields: {
-    declare: validateOptional(bool),
-    const: validateOptional(bool),
-    id: validateType("Identifier"),
-    members: validateArrayOfType("TSEnumMember"),
-    initializer: validateOptionalType("Expression")
+    declare: (0, _utils.validateOptional)(bool),
+    const: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    members: (0, _utils.validateArrayOfType)("TSEnumMember"),
+    initializer: (0, _utils.validateOptionalType)("Expression")
   }
@@ -398,4 +400,4 @@ });
   fields: {
-    id: validateType(["Identifier", "StringLiteral"]),
-    initializer: validateOptionalType("Expression")
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    initializer: (0, _utils.validateOptionalType)("Expression")
   }
@@ -407,6 +409,6 @@ });
   fields: {
-    declare: validateOptional(bool),
-    global: validateOptional(bool),
-    id: validateType(["Identifier", "StringLiteral"]),
-    body: validateType(["TSModuleBlock", "TSModuleDeclaration"])
+    declare: (0, _utils.validateOptional)(bool),
+    global: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
   }
@@ -418,3 +420,3 @@ });
   fields: {
-    body: validateArrayOfType("Statement")
+    body: (0, _utils.validateArrayOfType)("Statement")
   }
@@ -426,5 +428,5 @@ });
   fields: {
-    argument: validateType("StringLiteral"),
-    qualifier: validateOptionalType("TSEntityName"),
-    typeParameters: validateOptionalType("TSTypeParameterInstantiation")
+    argument: (0, _utils.validateType)("StringLiteral"),
+    qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
   }
@@ -436,7 +438,7 @@ });
   fields: {
-    isExport: validate(bool),
-    id: validateType("Identifier"),
-    moduleReference: validateType(["TSEntityName", "TSExternalModuleReference"]),
+    isExport: (0, _utils.validate)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]),
     importKind: {
-      validate: assertOneOf("type", "value"),
+      validate: (0, _utils.assertOneOf)("type", "value"),
       optional: true
@@ -449,3 +451,3 @@ }
   fields: {
-    expression: validateType("StringLiteral")
+    expression: (0, _utils.validateType)("StringLiteral")
   }
@@ -457,3 +459,3 @@ });
   fields: {
-    expression: validateType("Expression")
+    expression: (0, _utils.validateType)("Expression")
   }
@@ -465,3 +467,3 @@ });
   fields: {
-    expression: validateType("Expression")
+    expression: (0, _utils.validateType)("Expression")
   }
@@ -473,3 +475,3 @@ });
   fields: {
-    id: validateType("Identifier")
+    id: (0, _utils.validateType)("Identifier")
   }
@@ -481,3 +483,3 @@ });
     typeAnnotation: {
-      validate: assertNodeType("TSType")
+      validate: (0, _utils.assertNodeType)("TSType")
     }
@@ -490,3 +492,3 @@ }
     params: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("TSType")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
     }
@@ -499,3 +501,3 @@ }
     params: {
-      validate: chain(assertValueType("array"), assertEach(assertNodeType("TSTypeParameter")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
     }
@@ -509,22 +511,22 @@ }
     name: {
-      validate: assertValueType("string")
+      validate: (0, _utils.assertValueType)("string")
     },
     in: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     out: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     const: {
-      validate: assertValueType("boolean"),
+      validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     constraint: {
-      validate: assertNodeType("TSType"),
+      validate: (0, _utils.assertNodeType)("TSType"),
       optional: true
     },
     default: {
-      validate: assertNodeType("TSType"),
+      validate: (0, _utils.assertNodeType)("TSType"),
       optional: true
@@ -531,0 +533,0 @@ }

lib/definitions/utils.js

@@ -1,10 +0,41 @@
-import is from "../validators/is.js";
-import { validateField, validateChild } from "../validators/validate.js";
-export const VISITOR_KEYS = {};
-export const ALIAS_KEYS = {};
-export const FLIPPED_ALIAS_KEYS = {};
-export const NODE_FIELDS = {};
-export const BUILDER_KEYS = {};
-export const DEPRECATED_KEYS = {};
-export const NODE_PARENT_VALIDATIONS = {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VISITOR_KEYS = exports.NODE_PARENT_VALIDATIONS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.ALIAS_KEYS = void 0;
+exports.arrayOf = arrayOf;
+exports.arrayOfType = arrayOfType;
+exports.assertEach = assertEach;
+exports.assertNodeOrValueType = assertNodeOrValueType;
+exports.assertNodeType = assertNodeType;
+exports.assertOneOf = assertOneOf;
+exports.assertOptionalChainStart = assertOptionalChainStart;
+exports.assertShape = assertShape;
+exports.assertValueType = assertValueType;
+exports.chain = chain;
+exports.default = defineType;
+exports.defineAliasedType = defineAliasedType;
+exports.typeIs = typeIs;
+exports.validate = validate;
+exports.validateArrayOfType = validateArrayOfType;
+exports.validateOptional = validateOptional;
+exports.validateOptionalType = validateOptionalType;
+exports.validateType = validateType;
+var _is = require("../validators/is");
+var _validate = require("../validators/validate");
+const VISITOR_KEYS = {};
+exports.VISITOR_KEYS = VISITOR_KEYS;
+const ALIAS_KEYS = {};
+exports.ALIAS_KEYS = ALIAS_KEYS;
+const FLIPPED_ALIAS_KEYS = {};
+exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
+const NODE_FIELDS = {};
+exports.NODE_FIELDS = NODE_FIELDS;
+const BUILDER_KEYS = {};
+exports.BUILDER_KEYS = BUILDER_KEYS;
+const DEPRECATED_KEYS = {};
+exports.DEPRECATED_KEYS = DEPRECATED_KEYS;
+const NODE_PARENT_VALIDATIONS = {};
+exports.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
 function getType(val) {
@@ -19,3 +50,3 @@ if (Array.isArray(val)) {
 }
-export function validate(validate) {
+function validate(validate) {
   return {
@@ -25,9 +56,9 @@ validate
 }
-export function typeIs(typeName) {
+function typeIs(typeName) {
   return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
 }
-export function validateType(typeName) {
+function validateType(typeName) {
   return validate(typeIs(typeName));
 }
-export function validateOptional(validate) {
+function validateOptional(validate) {
   return {
@@ -38,3 +69,3 @@ validate,
 }
-export function validateOptionalType(typeName) {
+function validateOptionalType(typeName) {
   return {
@@ -45,12 +76,12 @@ validate: typeIs(typeName),
 }
-export function arrayOf(elementType) {
+function arrayOf(elementType) {
   return chain(assertValueType("array"), assertEach(elementType));
 }
-export function arrayOfType(typeName) {
+function arrayOfType(typeName) {
   return arrayOf(typeIs(typeName));
 }
-export function validateArrayOfType(typeName) {
+function validateArrayOfType(typeName) {
   return validate(arrayOfType(typeName));
 }
-export function assertEach(callback) {
+function assertEach(callback) {
   function validator(node, key, val) {
@@ -62,3 +93,3 @@ if (!Array.isArray(val)) return;
       callback(node, subkey, v);
-      if (process.env.BABEL_TYPES_8_BREAKING) validateChild(node, subkey, v);
+      if (process.env.BABEL_TYPES_8_BREAKING) (0, _validate.validateChild)(node, subkey, v);
     }
@@ -69,3 +100,3 @@ }
 }
-export function assertOneOf(...values) {
+function assertOneOf(...values) {
   function validate(node, key, val) {
@@ -79,7 +110,7 @@ if (values.indexOf(val) < 0) {
 }
-export function assertNodeType(...types) {
+function assertNodeType(...types) {
   function validate(node, key, val) {
     for (const type of types) {
-      if (is(type, val)) {
-        validateChild(node, key, val);
+      if ((0, _is.default)(type, val)) {
+        (0, _validate.validateChild)(node, key, val);
         return;
@@ -93,7 +124,7 @@ }
 }
-export function assertNodeOrValueType(...types) {
+function assertNodeOrValueType(...types) {
   function validate(node, key, val) {
     for (const type of types) {
-      if (getType(val) === type || is(type, val)) {
-        validateChild(node, key, val);
+      if (getType(val) === type || (0, _is.default)(type, val)) {
+        (0, _validate.validateChild)(node, key, val);
         return;
@@ -107,3 +138,3 @@ }
 }
-export function assertValueType(type) {
+function assertValueType(type) {
   function validate(node, key, val) {
@@ -118,3 +149,3 @@ const valid = getType(val) === type;
 }
-export function assertShape(shape) {
+function assertShape(shape) {
   function validate(node, key, val) {
@@ -124,3 +155,3 @@ const errors = [];
       try {
-        validateField(node, property, val[property], shape[property]);
+        (0, _validate.validateField)(node, property, val[property], shape[property]);
       } catch (error) {
@@ -141,3 +172,3 @@ if (error instanceof TypeError) {
 }
-export function assertOptionalChainStart() {
+function assertOptionalChainStart() {
   function validate(node) {
@@ -166,3 +197,3 @@ var _current;
 }
-export function chain(...fns) {
+function chain(...fns) {
   function validate(...args) {
@@ -182,3 +213,3 @@ for (const fn of fns) {
 const store = {};
-export function defineAliasedType(...aliases) {
+function defineAliasedType(...aliases) {
   return (type, opts = {}) => {
@@ -197,3 +228,3 @@ let defined = opts.aliases;
 }
-export default function defineType(type, opts = {}) {
+function defineType(type, opts = {}) {
   const inherits = opts.inherits && store[opts.inherits] || {};
@@ -200,0 +231,0 @@ let fields = opts.fields;

lib/index.js

@@ -1,75 +0,570 @@
-import isReactComponent from "./validators/react/isReactComponent.js";
-import isCompatTag from "./validators/react/isCompatTag.js";
-import buildChildren from "./builders/react/buildChildren.js";
-export { default as assertNode } from "./asserts/assertNode.js";
-export * from "./asserts/generated/index.js";
-export { default as createTypeAnnotationBasedOnTypeof } from "./builders/flow/createTypeAnnotationBasedOnTypeof.js";
-export { default as createUnionTypeAnnotation } from "./builders/flow/createFlowUnionType.js";
-export { default as createFlowUnionType } from "./builders/flow/createFlowUnionType.js";
-export { default as createTSUnionType } from "./builders/typescript/createTSUnionType.js";
-export * from "./builders/generated/index.js";
-export * from "./builders/generated/uppercase.js";
-export { default as cloneNode } from "./clone/cloneNode.js";
-export { default as clone } from "./clone/clone.js";
-export { default as cloneDeep } from "./clone/cloneDeep.js";
-export { default as cloneDeepWithoutLoc } from "./clone/cloneDeepWithoutLoc.js";
-export { default as cloneWithoutLoc } from "./clone/cloneWithoutLoc.js";
-export { default as addComment } from "./comments/addComment.js";
-export { default as addComments } from "./comments/addComments.js";
-export { default as inheritInnerComments } from "./comments/inheritInnerComments.js";
-export { default as inheritLeadingComments } from "./comments/inheritLeadingComments.js";
-export { default as inheritsComments } from "./comments/inheritsComments.js";
-export { default as inheritTrailingComments } from "./comments/inheritTrailingComments.js";
-export { default as removeComments } from "./comments/removeComments.js";
-export * from "./constants/generated/index.js";
-export * from "./constants/index.js";
-export { default as ensureBlock } from "./converters/ensureBlock.js";
-export { default as toBindingIdentifierName } from "./converters/toBindingIdentifierName.js";
-export { default as toBlock } from "./converters/toBlock.js";
-export { default as toComputedKey } from "./converters/toComputedKey.js";
-export { default as toExpression } from "./converters/toExpression.js";
-export { default as toIdentifier } from "./converters/toIdentifier.js";
-export { default as toKeyAlias } from "./converters/toKeyAlias.js";
-export { default as toSequenceExpression } from "./converters/toSequenceExpression.js";
-export { default as toStatement } from "./converters/toStatement.js";
-export { default as valueToNode } from "./converters/valueToNode.js";
-export * from "./definitions/index.js";
-export { default as appendToMemberExpression } from "./modifications/appendToMemberExpression.js";
-export { default as inherits } from "./modifications/inherits.js";
-export { default as prependToMemberExpression } from "./modifications/prependToMemberExpression.js";
-export { default as removeProperties } from "./modifications/removeProperties.js";
-export { default as removePropertiesDeep } from "./modifications/removePropertiesDeep.js";
-export { default as removeTypeDuplicates } from "./modifications/flow/removeTypeDuplicates.js";
-export { default as getBindingIdentifiers } from "./retrievers/getBindingIdentifiers.js";
-export { default as getOuterBindingIdentifiers } from "./retrievers/getOuterBindingIdentifiers.js";
-export { default as traverse } from "./traverse/traverse.js";
-export * from "./traverse/traverse.js";
-export { default as traverseFast } from "./traverse/traverseFast.js";
-export { default as shallowEqual } from "./utils/shallowEqual.js";
-export { default as is } from "./validators/is.js";
-export { default as isBinding } from "./validators/isBinding.js";
-export { default as isBlockScoped } from "./validators/isBlockScoped.js";
-export { default as isImmutable } from "./validators/isImmutable.js";
-export { default as isLet } from "./validators/isLet.js";
-export { default as isNode } from "./validators/isNode.js";
-export { default as isNodesEquivalent } from "./validators/isNodesEquivalent.js";
-export { default as isPlaceholderType } from "./validators/isPlaceholderType.js";
-export { default as isReferenced } from "./validators/isReferenced.js";
-export { default as isScope } from "./validators/isScope.js";
-export { default as isSpecifierDefault } from "./validators/isSpecifierDefault.js";
-export { default as isType } from "./validators/isType.js";
-export { default as isValidES3Identifier } from "./validators/isValidES3Identifier.js";
-export { default as isValidIdentifier } from "./validators/isValidIdentifier.js";
-export { default as isVar } from "./validators/isVar.js";
-export { default as matchesPattern } from "./validators/matchesPattern.js";
-export { default as validate } from "./validators/validate.js";
-export { default as buildMatchMemberExpression } from "./validators/buildMatchMemberExpression.js";
-export * from "./validators/generated/index.js";
-export const react = {
-  isReactComponent,
-  isCompatTag,
-  buildChildren
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  react: true,
+  assertNode: true,
+  createTypeAnnotationBasedOnTypeof: true,
+  createUnionTypeAnnotation: true,
+  createFlowUnionType: true,
+  createTSUnionType: true,
+  cloneNode: true,
+  clone: true,
+  cloneDeep: true,
+  cloneDeepWithoutLoc: true,
+  cloneWithoutLoc: true,
+  addComment: true,
+  addComments: true,
+  inheritInnerComments: true,
+  inheritLeadingComments: true,
+  inheritsComments: true,
+  inheritTrailingComments: true,
+  removeComments: true,
+  ensureBlock: true,
+  toBindingIdentifierName: true,
+  toBlock: true,
+  toComputedKey: true,
+  toExpression: true,
+  toIdentifier: true,
+  toKeyAlias: true,
+  toSequenceExpression: true,
+  toStatement: true,
+  valueToNode: true,
+  appendToMemberExpression: true,
+  inherits: true,
+  prependToMemberExpression: true,
+  removeProperties: true,
+  removePropertiesDeep: true,
+  removeTypeDuplicates: true,
+  getBindingIdentifiers: true,
+  getOuterBindingIdentifiers: true,
+  traverse: true,
+  traverseFast: true,
+  shallowEqual: true,
+  is: true,
+  isBinding: true,
+  isBlockScoped: true,
+  isImmutable: true,
+  isLet: true,
+  isNode: true,
+  isNodesEquivalent: true,
+  isPlaceholderType: true,
+  isReferenced: true,
+  isScope: true,
+  isSpecifierDefault: true,
+  isType: true,
+  isValidES3Identifier: true,
+  isValidIdentifier: true,
+  isVar: true,
+  matchesPattern: true,
+  validate: true,
+  buildMatchMemberExpression: true,
+  __internal__deprecationWarning: true
 };
-export { default as __internal__deprecationWarning } from "./utils/deprecationWarning.js";
+Object.defineProperty(exports, "__internal__deprecationWarning", {
+  enumerable: true,
+  get: function () {
+    return _deprecationWarning.default;
+  }
+});
+Object.defineProperty(exports, "addComment", {
+  enumerable: true,
+  get: function () {
+    return _addComment.default;
+  }
+});
+Object.defineProperty(exports, "addComments", {
+  enumerable: true,
+  get: function () {
+    return _addComments.default;
+  }
+});
+Object.defineProperty(exports, "appendToMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _appendToMemberExpression.default;
+  }
+});
+Object.defineProperty(exports, "assertNode", {
+  enumerable: true,
+  get: function () {
+    return _assertNode.default;
+  }
+});
+Object.defineProperty(exports, "buildMatchMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _buildMatchMemberExpression.default;
+  }
+});
+Object.defineProperty(exports, "clone", {
+  enumerable: true,
+  get: function () {
+    return _clone.default;
+  }
+});
+Object.defineProperty(exports, "cloneDeep", {
+  enumerable: true,
+  get: function () {
+    return _cloneDeep.default;
+  }
+});
+Object.defineProperty(exports, "cloneDeepWithoutLoc", {
+  enumerable: true,
+  get: function () {
+    return _cloneDeepWithoutLoc.default;
+  }
+});
+Object.defineProperty(exports, "cloneNode", {
+  enumerable: true,
+  get: function () {
+    return _cloneNode.default;
+  }
+});
+Object.defineProperty(exports, "cloneWithoutLoc", {
+  enumerable: true,
+  get: function () {
+    return _cloneWithoutLoc.default;
+  }
+});
+Object.defineProperty(exports, "createFlowUnionType", {
+  enumerable: true,
+  get: function () {
+    return _createFlowUnionType.default;
+  }
+});
+Object.defineProperty(exports, "createTSUnionType", {
+  enumerable: true,
+  get: function () {
+    return _createTSUnionType.default;
+  }
+});
+Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
+  enumerable: true,
+  get: function () {
+    return _createTypeAnnotationBasedOnTypeof.default;
+  }
+});
+Object.defineProperty(exports, "createUnionTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _createFlowUnionType.default;
+  }
+});
+Object.defineProperty(exports, "ensureBlock", {
+  enumerable: true,
+  get: function () {
+    return _ensureBlock.default;
+  }
+});
+Object.defineProperty(exports, "getBindingIdentifiers", {
+  enumerable: true,
+  get: function () {
+    return _getBindingIdentifiers.default;
+  }
+});
+Object.defineProperty(exports, "getOuterBindingIdentifiers", {
+  enumerable: true,
+  get: function () {
+    return _getOuterBindingIdentifiers.default;
+  }
+});
+Object.defineProperty(exports, "inheritInnerComments", {
+  enumerable: true,
+  get: function () {
+    return _inheritInnerComments.default;
+  }
+});
+Object.defineProperty(exports, "inheritLeadingComments", {
+  enumerable: true,
+  get: function () {
+    return _inheritLeadingComments.default;
+  }
+});
+Object.defineProperty(exports, "inheritTrailingComments", {
+  enumerable: true,
+  get: function () {
+    return _inheritTrailingComments.default;
+  }
+});
+Object.defineProperty(exports, "inherits", {
+  enumerable: true,
+  get: function () {
+    return _inherits.default;
+  }
+});
+Object.defineProperty(exports, "inheritsComments", {
+  enumerable: true,
+  get: function () {
+    return _inheritsComments.default;
+  }
+});
+Object.defineProperty(exports, "is", {
+  enumerable: true,
+  get: function () {
+    return _is.default;
+  }
+});
+Object.defineProperty(exports, "isBinding", {
+  enumerable: true,
+  get: function () {
+    return _isBinding.default;
+  }
+});
+Object.defineProperty(exports, "isBlockScoped", {
+  enumerable: true,
+  get: function () {
+    return _isBlockScoped.default;
+  }
+});
+Object.defineProperty(exports, "isImmutable", {
+  enumerable: true,
+  get: function () {
+    return _isImmutable.default;
+  }
+});
+Object.defineProperty(exports, "isLet", {
+  enumerable: true,
+  get: function () {
+    return _isLet.default;
+  }
+});
+Object.defineProperty(exports, "isNode", {
+  enumerable: true,
+  get: function () {
+    return _isNode.default;
+  }
+});
+Object.defineProperty(exports, "isNodesEquivalent", {
+  enumerable: true,
+  get: function () {
+    return _isNodesEquivalent.default;
+  }
+});
+Object.defineProperty(exports, "isPlaceholderType", {
+  enumerable: true,
+  get: function () {
+    return _isPlaceholderType.default;
+  }
+});
+Object.defineProperty(exports, "isReferenced", {
+  enumerable: true,
+  get: function () {
+    return _isReferenced.default;
+  }
+});
+Object.defineProperty(exports, "isScope", {
+  enumerable: true,
+  get: function () {
+    return _isScope.default;
+  }
+});
+Object.defineProperty(exports, "isSpecifierDefault", {
+  enumerable: true,
+  get: function () {
+    return _isSpecifierDefault.default;
+  }
+});
+Object.defineProperty(exports, "isType", {
+  enumerable: true,
+  get: function () {
+    return _isType.default;
+  }
+});
+Object.defineProperty(exports, "isValidES3Identifier", {
+  enumerable: true,
+  get: function () {
+    return _isValidES3Identifier.default;
+  }
+});
+Object.defineProperty(exports, "isValidIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _isValidIdentifier.default;
+  }
+});
+Object.defineProperty(exports, "isVar", {
+  enumerable: true,
+  get: function () {
+    return _isVar.default;
+  }
+});
+Object.defineProperty(exports, "matchesPattern", {
+  enumerable: true,
+  get: function () {
+    return _matchesPattern.default;
+  }
+});
+Object.defineProperty(exports, "prependToMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _prependToMemberExpression.default;
+  }
+});
+exports.react = void 0;
+Object.defineProperty(exports, "removeComments", {
+  enumerable: true,
+  get: function () {
+    return _removeComments.default;
+  }
+});
+Object.defineProperty(exports, "removeProperties", {
+  enumerable: true,
+  get: function () {
+    return _removeProperties.default;
+  }
+});
+Object.defineProperty(exports, "removePropertiesDeep", {
+  enumerable: true,
+  get: function () {
+    return _removePropertiesDeep.default;
+  }
+});
+Object.defineProperty(exports, "removeTypeDuplicates", {
+  enumerable: true,
+  get: function () {
+    return _removeTypeDuplicates.default;
+  }
+});
+Object.defineProperty(exports, "shallowEqual", {
+  enumerable: true,
+  get: function () {
+    return _shallowEqual.default;
+  }
+});
+Object.defineProperty(exports, "toBindingIdentifierName", {
+  enumerable: true,
+  get: function () {
+    return _toBindingIdentifierName.default;
+  }
+});
+Object.defineProperty(exports, "toBlock", {
+  enumerable: true,
+  get: function () {
+    return _toBlock.default;
+  }
+});
+Object.defineProperty(exports, "toComputedKey", {
+  enumerable: true,
+  get: function () {
+    return _toComputedKey.default;
+  }
+});
+Object.defineProperty(exports, "toExpression", {
+  enumerable: true,
+  get: function () {
+    return _toExpression.default;
+  }
+});
+Object.defineProperty(exports, "toIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _toIdentifier.default;
+  }
+});
+Object.defineProperty(exports, "toKeyAlias", {
+  enumerable: true,
+  get: function () {
+    return _toKeyAlias.default;
+  }
+});
+Object.defineProperty(exports, "toSequenceExpression", {
+  enumerable: true,
+  get: function () {
+    return _toSequenceExpression.default;
+  }
+});
+Object.defineProperty(exports, "toStatement", {
+  enumerable: true,
+  get: function () {
+    return _toStatement.default;
+  }
+});
+Object.defineProperty(exports, "traverse", {
+  enumerable: true,
+  get: function () {
+    return _traverse.default;
+  }
+});
+Object.defineProperty(exports, "traverseFast", {
+  enumerable: true,
+  get: function () {
+    return _traverseFast.default;
+  }
+});
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function () {
+    return _validate.default;
+  }
+});
+Object.defineProperty(exports, "valueToNode", {
+  enumerable: true,
+  get: function () {
+    return _valueToNode.default;
+  }
+});
+var _isReactComponent = require("./validators/react/isReactComponent");
+var _isCompatTag = require("./validators/react/isCompatTag");
+var _buildChildren = require("./builders/react/buildChildren");
+var _assertNode = require("./asserts/assertNode");
+var _generated = require("./asserts/generated");
+Object.keys(_generated).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _generated[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generated[key];
+    }
+  });
+});
+var _createTypeAnnotationBasedOnTypeof = require("./builders/flow/createTypeAnnotationBasedOnTypeof");
+var _createFlowUnionType = require("./builders/flow/createFlowUnionType");
+var _createTSUnionType = require("./builders/typescript/createTSUnionType");
+var _generated2 = require("./builders/generated");
+Object.keys(_generated2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _generated2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generated2[key];
+    }
+  });
+});
+var _uppercase = require("./builders/generated/uppercase");
+Object.keys(_uppercase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _uppercase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _uppercase[key];
+    }
+  });
+});
+var _cloneNode = require("./clone/cloneNode");
+var _clone = require("./clone/clone");
+var _cloneDeep = require("./clone/cloneDeep");
+var _cloneDeepWithoutLoc = require("./clone/cloneDeepWithoutLoc");
+var _cloneWithoutLoc = require("./clone/cloneWithoutLoc");
+var _addComment = require("./comments/addComment");
+var _addComments = require("./comments/addComments");
+var _inheritInnerComments = require("./comments/inheritInnerComments");
+var _inheritLeadingComments = require("./comments/inheritLeadingComments");
+var _inheritsComments = require("./comments/inheritsComments");
+var _inheritTrailingComments = require("./comments/inheritTrailingComments");
+var _removeComments = require("./comments/removeComments");
+var _generated3 = require("./constants/generated");
+Object.keys(_generated3).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _generated3[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generated3[key];
+    }
+  });
+});
+var _constants = require("./constants");
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _constants[key];
+    }
+  });
+});
+var _ensureBlock = require("./converters/ensureBlock");
+var _toBindingIdentifierName = require("./converters/toBindingIdentifierName");
+var _toBlock = require("./converters/toBlock");
+var _toComputedKey = require("./converters/toComputedKey");
+var _toExpression = require("./converters/toExpression");
+var _toIdentifier = require("./converters/toIdentifier");
+var _toKeyAlias = require("./converters/toKeyAlias");
+var _toSequenceExpression = require("./converters/toSequenceExpression");
+var _toStatement = require("./converters/toStatement");
+var _valueToNode = require("./converters/valueToNode");
+var _definitions = require("./definitions");
+Object.keys(_definitions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _definitions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _definitions[key];
+    }
+  });
+});
+var _appendToMemberExpression = require("./modifications/appendToMemberExpression");
+var _inherits = require("./modifications/inherits");
+var _prependToMemberExpression = require("./modifications/prependToMemberExpression");
+var _removeProperties = require("./modifications/removeProperties");
+var _removePropertiesDeep = require("./modifications/removePropertiesDeep");
+var _removeTypeDuplicates = require("./modifications/flow/removeTypeDuplicates");
+var _getBindingIdentifiers = require("./retrievers/getBindingIdentifiers");
+var _getOuterBindingIdentifiers = require("./retrievers/getOuterBindingIdentifiers");
+var _traverse = require("./traverse/traverse");
+Object.keys(_traverse).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _traverse[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _traverse[key];
+    }
+  });
+});
+var _traverseFast = require("./traverse/traverseFast");
+var _shallowEqual = require("./utils/shallowEqual");
+var _is = require("./validators/is");
+var _isBinding = require("./validators/isBinding");
+var _isBlockScoped = require("./validators/isBlockScoped");
+var _isImmutable = require("./validators/isImmutable");
+var _isLet = require("./validators/isLet");
+var _isNode = require("./validators/isNode");
+var _isNodesEquivalent = require("./validators/isNodesEquivalent");
+var _isPlaceholderType = require("./validators/isPlaceholderType");
+var _isReferenced = require("./validators/isReferenced");
+var _isScope = require("./validators/isScope");
+var _isSpecifierDefault = require("./validators/isSpecifierDefault");
+var _isType = require("./validators/isType");
+var _isValidES3Identifier = require("./validators/isValidES3Identifier");
+var _isValidIdentifier = require("./validators/isValidIdentifier");
+var _isVar = require("./validators/isVar");
+var _matchesPattern = require("./validators/matchesPattern");
+var _validate = require("./validators/validate");
+var _buildMatchMemberExpression = require("./validators/buildMatchMemberExpression");
+var _generated4 = require("./validators/generated");
+Object.keys(_generated4).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _generated4[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generated4[key];
+    }
+  });
+});
+var _deprecationWarning = require("./utils/deprecationWarning");
+const react = {
+  isReactComponent: _isReactComponent.default,
+  isCompatTag: _isCompatTag.default,
+  buildChildren: _buildChildren.default
+};
+exports.react = react;
 
 //# sourceMappingURL=index.js.map

lib/modifications/appendToMemberExpression.js

@@ -1,4 +0,10 @@
-import { memberExpression } from "../builders/generated/index.js";
-export default function appendToMemberExpression(member, append, computed = false) {
-  member.object = memberExpression(member.object, member.property, member.computed);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = appendToMemberExpression;
+var _generated = require("../builders/generated");
+function appendToMemberExpression(member, append, computed = false) {
+  member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed);
   member.property = append;
@@ -5,0 +11,0 @@ member.computed = !!computed;

lib/modifications/flow/removeTypeDuplicates.js

@@ -1,6 +0,12 @@
-import { isAnyTypeAnnotation, isGenericTypeAnnotation, isUnionTypeAnnotation, isFlowBaseAnnotation, isIdentifier } from "../../validators/generated/index.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeTypeDuplicates;
+var _generated = require("../../validators/generated");
 function getQualifiedName(node) {
-  return isIdentifier(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;
+  return (0, _generated.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;
 }
-export default function removeTypeDuplicates(nodes) {
+function removeTypeDuplicates(nodes) {
   const generics = new Map();
@@ -16,10 +22,10 @@ const bases = new Map();
     }
-    if (isAnyTypeAnnotation(node)) {
+    if ((0, _generated.isAnyTypeAnnotation)(node)) {
       return [node];
     }
-    if (isFlowBaseAnnotation(node)) {
+    if ((0, _generated.isFlowBaseAnnotation)(node)) {
       bases.set(node.type, node);
       continue;
     }
-    if (isUnionTypeAnnotation(node)) {
+    if ((0, _generated.isUnionTypeAnnotation)(node)) {
       if (!typeGroups.has(node.types)) {
@@ -31,3 +37,3 @@ nodes = nodes.concat(node.types);
     }
-    if (isGenericTypeAnnotation(node)) {
+    if ((0, _generated.isGenericTypeAnnotation)(node)) {
       const name = getQualifiedName(node.id);
@@ -34,0 +40,0 @@ if (generics.has(name)) {

lib/modifications/inherits.js

@@ -1,6 +0,12 @@
-import { INHERIT_KEYS } from "../constants/index.js";
-import inheritsComments from "../comments/inheritsComments.js";
-export default function inherits(child, parent) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inherits;
+var _constants = require("../constants");
+var _inheritsComments = require("../comments/inheritsComments");
+function inherits(child, parent) {
   if (!child || !parent) return child;
-  for (const key of INHERIT_KEYS.optional) {
+  for (const key of _constants.INHERIT_KEYS.optional) {
     if (child[key] == null) {
@@ -15,6 +21,6 @@ child[key] = parent[key];
   }
-  for (const key of INHERIT_KEYS.force) {
+  for (const key of _constants.INHERIT_KEYS.force) {
     child[key] = parent[key];
   }
-  inheritsComments(child, parent);
+  (0, _inheritsComments.default)(child, parent);
   return child;
@@ -21,0 +27,0 @@ }

lib/modifications/prependToMemberExpression.js

@@ -1,8 +0,14 @@
-import { memberExpression } from "../builders/generated/index.js";
-import { isSuper } from "../index.js";
-export default function prependToMemberExpression(member, prepend) {
-  if (isSuper(member.object)) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = prependToMemberExpression;
+var _generated = require("../builders/generated");
+var _ = require("..");
+function prependToMemberExpression(member, prepend) {
+  if ((0, _.isSuper)(member.object)) {
     throw new Error("Cannot prepend node to super property access (`super.foo`).");
   }
-  member.object = memberExpression(prepend, member.object);
+  member.object = (0, _generated.memberExpression)(prepend, member.object);
   return member;
@@ -9,0 +15,0 @@ }

lib/modifications/removeProperties.js

@@ -1,5 +0,11 @@
-import { COMMENT_KEYS } from "../constants/index.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeProperties;
+var _constants = require("../constants");
 const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
-const CLEAR_KEYS_PLUS_COMMENTS = [...COMMENT_KEYS, "comments", ...CLEAR_KEYS];
-export default function removeProperties(node, opts = {}) {
+const CLEAR_KEYS_PLUS_COMMENTS = [..._constants.COMMENT_KEYS, "comments", ...CLEAR_KEYS];
+function removeProperties(node, opts = {}) {
   const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
@@ -6,0 +12,0 @@ for (const key of map) {

lib/modifications/removePropertiesDeep.js

@@ -1,5 +0,11 @@
-import traverseFast from "../traverse/traverseFast.js";
-import removeProperties from "./removeProperties.js";
-export default function removePropertiesDeep(tree, opts) {
-  traverseFast(tree, removeProperties, opts);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removePropertiesDeep;
+var _traverseFast = require("../traverse/traverseFast");
+var _removeProperties = require("./removeProperties");
+function removePropertiesDeep(tree, opts) {
+  (0, _traverseFast.default)(tree, _removeProperties.default, opts);
   return tree;
@@ -6,0 +12,0 @@ }

lib/modifications/typescript/removeTypeDuplicates.js

@@ -1,6 +0,12 @@
-import { isIdentifier, isTSAnyKeyword, isTSTypeReference, isTSUnionType, isTSBaseType } from "../../validators/generated/index.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeTypeDuplicates;
+var _generated = require("../../validators/generated");
 function getQualifiedName(node) {
-  return isIdentifier(node) ? node.name : `${node.right.name}.${getQualifiedName(node.left)}`;
+  return (0, _generated.isIdentifier)(node) ? node.name : `${node.right.name}.${getQualifiedName(node.left)}`;
 }
-export default function removeTypeDuplicates(nodes) {
+function removeTypeDuplicates(nodes) {
   const generics = new Map();
@@ -16,10 +22,10 @@ const bases = new Map();
     }
-    if (isTSAnyKeyword(node)) {
+    if ((0, _generated.isTSAnyKeyword)(node)) {
       return [node];
     }
-    if (isTSBaseType(node)) {
+    if ((0, _generated.isTSBaseType)(node)) {
       bases.set(node.type, node);
       continue;
     }
-    if (isTSUnionType(node)) {
+    if ((0, _generated.isTSUnionType)(node)) {
       if (!typeGroups.has(node.types)) {
@@ -31,3 +37,3 @@ nodes.push(...node.types);
     }
-    if (isTSTypeReference(node) && node.typeParameters) {
+    if ((0, _generated.isTSTypeReference)(node) && node.typeParameters) {
       const name = getQualifiedName(node.typeName);
@@ -34,0 +40,0 @@ if (generics.has(name)) {

lib/retrievers/getBindingIdentifiers.js

@@ -1,3 +0,8 @@
-import { isExportDeclaration, isIdentifier, isDeclaration, isFunctionDeclaration, isFunctionExpression, isExportAllDeclaration } from "../validators/generated/index.js";
-export { getBindingIdentifiers as default };
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getBindingIdentifiers;
+var _generated = require("../validators/generated");
 function getBindingIdentifiers(node, duplicates, outerOnly) {
@@ -10,3 +15,3 @@ const search = [].concat(node);
     const keys = getBindingIdentifiers.keys[id.type];
-    if (isIdentifier(id)) {
+    if ((0, _generated.isIdentifier)(id)) {
       if (duplicates) {
@@ -20,4 +25,4 @@ const _ids = ids[id.name] = ids[id.name] || [];
     }
-    if (isExportDeclaration(id) && !isExportAllDeclaration(id)) {
-      if (isDeclaration(id.declaration)) {
+    if ((0, _generated.isExportDeclaration)(id) && !(0, _generated.isExportAllDeclaration)(id)) {
+      if ((0, _generated.isDeclaration)(id.declaration)) {
         search.push(id.declaration);
@@ -28,7 +33,7 @@ }
     if (outerOnly) {
-      if (isFunctionDeclaration(id)) {
+      if ((0, _generated.isFunctionDeclaration)(id)) {
         search.push(id.id);
         continue;
       }
-      if (isFunctionExpression(id)) {
+      if ((0, _generated.isFunctionExpression)(id)) {
         continue;
@@ -35,0 +40,0 @@ }

lib/retrievers/getOuterBindingIdentifiers.js

@@ -1,7 +0,14 @@
-import getBindingIdentifiers from "./getBindingIdentifiers.js";
-export default getOuterBindingIdentifiers;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _getBindingIdentifiers = require("./getBindingIdentifiers");
+var _default = getOuterBindingIdentifiers;
+exports.default = _default;
 function getOuterBindingIdentifiers(node, duplicates) {
-  return getBindingIdentifiers(node, duplicates, true);
+  return (0, _getBindingIdentifiers.default)(node, duplicates, true);
 }
 
 //# sourceMappingURL=getOuterBindingIdentifiers.js.map

lib/traverse/traverse.js

@@ -1,3 +0,9 @@
-import { VISITOR_KEYS } from "../definitions/index.js";
-export default function traverse(node, handlers, state) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = traverse;
+var _definitions = require("../definitions");
+function traverse(node, handlers, state) {
   if (typeof handlers === "function") {
@@ -15,3 +21,3 @@ handlers = {
 function traverseSimpleImpl(node, enter, exit, state, ancestors) {
-  const keys = VISITOR_KEYS[node.type];
+  const keys = _definitions.VISITOR_KEYS[node.type];
   if (!keys) return;
@@ -18,0 +24,0 @@ if (enter) enter(node, ancestors, state);

lib/traverse/traverseFast.js

@@ -1,5 +0,11 @@
-import { VISITOR_KEYS } from "../definitions/index.js";
-export default function traverseFast(node, enter, opts) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = traverseFast;
+var _definitions = require("../definitions");
+function traverseFast(node, enter, opts) {
   if (!node) return;
-  const keys = VISITOR_KEYS[node.type];
+  const keys = _definitions.VISITOR_KEYS[node.type];
   if (!keys) return;
@@ -6,0 +12,0 @@ opts = opts || {};

lib/utils/deprecationWarning.js

@@ -0,3 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = deprecationWarning;
 const warnings = new Set();
-export default function deprecationWarning(oldName, newName, prefix = "") {
+function deprecationWarning(oldName, newName, prefix = "") {
   if (warnings.has(oldName)) return;
@@ -4,0 +10,0 @@ warnings.add(oldName);

lib/utils/inherit.js

@@ -1,2 +0,8 @@
-export default function inherit(key, child, parent) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inherit;
+function inherit(key, child, parent) {
   if (child && parent) {
@@ -3,0 +9,0 @@ child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean)));

lib/utils/react/cleanJSXElementLiteralChild.js

@@ -1,4 +0,10 @@
-import { stringLiteral } from "../../builders/generated/index.js";
-import { inherits } from "../../index.js";
-export default function cleanJSXElementLiteralChild(child, args) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cleanJSXElementLiteralChild;
+var _generated = require("../../builders/generated");
+var _ = require("../..");
+function cleanJSXElementLiteralChild(child, args) {
   const lines = child.value.split(/\r\n|\n|\r/);
@@ -31,5 +37,5 @@ let lastNonEmptyLine = 0;
   }
-  if (str) args.push(inherits(stringLiteral(str), child));
+  if (str) args.push((0, _.inherits)((0, _generated.stringLiteral)(str), child));
 }
 
 //# sourceMappingURL=cleanJSXElementLiteralChild.js.map

lib/utils/shallowEqual.js

@@ -1,2 +0,8 @@
-export default function shallowEqual(actual, expected) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = shallowEqual;
+function shallowEqual(actual, expected) {
   const keys = Object.keys(expected);
@@ -3,0 +9,0 @@ for (const key of keys) {

lib/validators/buildMatchMemberExpression.js

@@ -1,7 +0,13 @@
-import matchesPattern from "./matchesPattern.js";
-export default function buildMatchMemberExpression(match, allowPartial) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildMatchMemberExpression;
+var _matchesPattern = require("./matchesPattern");
+function buildMatchMemberExpression(match, allowPartial) {
   const parts = match.split(".");
-  return member => matchesPattern(member, parts, allowPartial);
+  return member => (0, _matchesPattern.default)(member, parts, allowPartial);
 }
 
 //# sourceMappingURL=buildMatchMemberExpression.js.map

lib/validators/is.js

@@ -1,11 +0,17 @@
-import shallowEqual from "../utils/shallowEqual.js";
-import isType from "./isType.js";
-import isPlaceholderType from "./isPlaceholderType.js";
-import { FLIPPED_ALIAS_KEYS } from "../definitions/index.js";
-export default function is(type, node, opts) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = is;
+var _shallowEqual = require("../utils/shallowEqual");
+var _isType = require("./isType");
+var _isPlaceholderType = require("./isPlaceholderType");
+var _definitions = require("../definitions");
+function is(type, node, opts) {
   if (!node) return false;
-  const matches = isType(node.type, type);
+  const matches = (0, _isType.default)(node.type, type);
   if (!matches) {
-    if (!opts && node.type === "Placeholder" && type in FLIPPED_ALIAS_KEYS) {
-      return isPlaceholderType(node.expectedNode, type);
+    if (!opts && node.type === "Placeholder" && type in _definitions.FLIPPED_ALIAS_KEYS) {
+      return (0, _isPlaceholderType.default)(node.expectedNode, type);
     }
@@ -17,3 +23,3 @@ return false;
   } else {
-    return shallowEqual(node, opts);
+    return (0, _shallowEqual.default)(node, opts);
   }
@@ -20,0 +26,0 @@ }

lib/validators/isBinding.js

@@ -1,7 +0,13 @@
-import getBindingIdentifiers from "../retrievers/getBindingIdentifiers.js";
-export default function isBinding(node, parent, grandparent) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isBinding;
+var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers");
+function isBinding(node, parent, grandparent) {
   if (grandparent && node.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") {
     return false;
   }
-  const keys = getBindingIdentifiers.keys[parent.type];
+  const keys = _getBindingIdentifiers.default.keys[parent.type];
   if (keys) {
@@ -8,0 +14,0 @@ for (let i = 0; i < keys.length; i++) {

lib/validators/isBlockScoped.js

@@ -1,7 +0,13 @@
-import { isClassDeclaration, isFunctionDeclaration } from "./generated/index.js";
-import isLet from "./isLet.js";
-export default function isBlockScoped(node) {
-  return isFunctionDeclaration(node) || isClassDeclaration(node) || isLet(node);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isBlockScoped;
+var _generated = require("./generated");
+var _isLet = require("./isLet");
+function isBlockScoped(node) {
+  return (0, _generated.isFunctionDeclaration)(node) || (0, _generated.isClassDeclaration)(node) || (0, _isLet.default)(node);
 }
 
 //# sourceMappingURL=isBlockScoped.js.map

lib/validators/isImmutable.js

@@ -1,6 +0,12 @@
-import isType from "./isType.js";
-import { isIdentifier } from "./generated/index.js";
-export default function isImmutable(node) {
-  if (isType(node.type, "Immutable")) return true;
-  if (isIdentifier(node)) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isImmutable;
+var _isType = require("./isType");
+var _generated = require("./generated");
+function isImmutable(node) {
+  if ((0, _isType.default)(node.type, "Immutable")) return true;
+  if ((0, _generated.isIdentifier)(node)) {
     if (node.name === "undefined") {
@@ -7,0 +13,0 @@ return true;

lib/validators/isLet.js

@@ -1,7 +0,13 @@
-import { isVariableDeclaration } from "./generated/index.js";
-import { BLOCK_SCOPED_SYMBOL } from "../constants/index.js";
-export default function isLet(node) {
-  return isVariableDeclaration(node) && (node.kind !== "var" || node[BLOCK_SCOPED_SYMBOL]);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isLet;
+var _generated = require("./generated");
+var _constants = require("../constants");
+function isLet(node) {
+  return (0, _generated.isVariableDeclaration)(node) && (node.kind !== "var" || node[_constants.BLOCK_SCOPED_SYMBOL]);
 }
 
 //# sourceMappingURL=isLet.js.map

lib/validators/isNode.js

@@ -1,6 +0,12 @@
-import { VISITOR_KEYS } from "../definitions/index.js";
-export default function isNode(node) {
-  return !!(node && VISITOR_KEYS[node.type]);
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isNode;
+var _definitions = require("../definitions");
+function isNode(node) {
+  return !!(node && _definitions.VISITOR_KEYS[node.type]);
 }
 
 //# sourceMappingURL=isNode.js.map

lib/validators/isNodesEquivalent.js

@@ -1,3 +0,9 @@
-import { NODE_FIELDS, VISITOR_KEYS } from "../definitions/index.js";
-export default function isNodesEquivalent(a, b) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isNodesEquivalent;
+var _definitions = require("../definitions");
+function isNodesEquivalent(a, b) {
   if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
@@ -9,4 +15,4 @@ return a === b;
   }
-  const fields = Object.keys(NODE_FIELDS[a.type] || a.type);
-  const visitorKeys = VISITOR_KEYS[a.type];
+  const fields = Object.keys(_definitions.NODE_FIELDS[a.type] || a.type);
+  const visitorKeys = _definitions.VISITOR_KEYS[a.type];
   for (const field of fields) {
@@ -13,0 +19,0 @@ const val_a = a[field];

lib/validators/isPlaceholderType.js

@@ -1,5 +0,11 @@
-import { PLACEHOLDERS_ALIAS } from "../definitions/index.js";
-export default function isPlaceholderType(placeholderType, targetType) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isPlaceholderType;
+var _definitions = require("../definitions");
+function isPlaceholderType(placeholderType, targetType) {
   if (placeholderType === targetType) return true;
-  const aliases = PLACEHOLDERS_ALIAS[placeholderType];
+  const aliases = _definitions.PLACEHOLDERS_ALIAS[placeholderType];
   if (aliases) {
@@ -6,0 +12,0 @@ for (const alias of aliases) {

lib/validators/isReferenced.js

@@ -1,2 +0,8 @@
-export default function isReferenced(node, parent, grandparent) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isReferenced;
+function isReferenced(node, parent, grandparent) {
   switch (parent.type) {
@@ -3,0 +9,0 @@ case "MemberExpression":

lib/validators/isScope.js

@@ -1,12 +0,18 @@
-import { isFunction, isCatchClause, isBlockStatement, isScopable, isPattern } from "./generated/index.js";
-export default function isScope(node, parent) {
-  if (isBlockStatement(node) && (isFunction(parent) || isCatchClause(parent))) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isScope;
+var _generated = require("./generated");
+function isScope(node, parent) {
+  if ((0, _generated.isBlockStatement)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) {
     return false;
   }
-  if (isPattern(node) && (isFunction(parent) || isCatchClause(parent))) {
+  if ((0, _generated.isPattern)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) {
     return true;
   }
-  return isScopable(node);
+  return (0, _generated.isScopable)(node);
 }
 
 //# sourceMappingURL=isScope.js.map

lib/validators/isSpecifierDefault.js

@@ -1,4 +0,10 @@
-import { isIdentifier, isImportDefaultSpecifier } from "./generated/index.js";
-export default function isSpecifierDefault(specifier) {
-  return isImportDefaultSpecifier(specifier) || isIdentifier(specifier.imported || specifier.exported, {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isSpecifierDefault;
+var _generated = require("./generated");
+function isSpecifierDefault(specifier) {
+  return (0, _generated.isImportDefaultSpecifier)(specifier) || (0, _generated.isIdentifier)(specifier.imported || specifier.exported, {
     name: "default"
@@ -5,0 +11,0 @@ });

lib/validators/isType.js

@@ -1,6 +0,12 @@
-import { FLIPPED_ALIAS_KEYS, ALIAS_KEYS } from "../definitions/index.js";
-export default function isType(nodeType, targetType) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isType;
+var _definitions = require("../definitions");
+function isType(nodeType, targetType) {
   if (nodeType === targetType) return true;
-  if (ALIAS_KEYS[targetType]) return false;
-  const aliases = FLIPPED_ALIAS_KEYS[targetType];
+  if (_definitions.ALIAS_KEYS[targetType]) return false;
+  const aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType];
   if (aliases) {
@@ -7,0 +13,0 @@ if (aliases[0] === nodeType) return true;

lib/validators/isValidES3Identifier.js

@@ -1,7 +0,13 @@
-import isValidIdentifier from "./isValidIdentifier.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isValidES3Identifier;
+var _isValidIdentifier = require("./isValidIdentifier");
 const RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]);
-export default function isValidES3Identifier(name) {
-  return isValidIdentifier(name) && !RESERVED_WORDS_ES3_ONLY.has(name);
+function isValidES3Identifier(name) {
+  return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name);
 }
 
 //# sourceMappingURL=isValidES3Identifier.js.map

lib/validators/isValidIdentifier.js

@@ -1,12 +0,18 @@
-import { isIdentifierName, isStrictReservedWord, isKeyword } from "@babel/helper-validator-identifier";
-export default function isValidIdentifier(name, reserved = true) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isValidIdentifier;
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+function isValidIdentifier(name, reserved = true) {
   if (typeof name !== "string") return false;
   if (reserved) {
-    if (isKeyword(name) || isStrictReservedWord(name, true)) {
+    if ((0, _helperValidatorIdentifier.isKeyword)(name) || (0, _helperValidatorIdentifier.isStrictReservedWord)(name, true)) {
       return false;
     }
   }
-  return isIdentifierName(name);
+  return (0, _helperValidatorIdentifier.isIdentifierName)(name);
 }
 
 //# sourceMappingURL=isValidIdentifier.js.map

lib/validators/isVar.js

@@ -1,9 +0,15 @@
-import { isVariableDeclaration } from "./generated/index.js";
-import { BLOCK_SCOPED_SYMBOL } from "../constants/index.js";
-export default function isVar(node) {
-  return isVariableDeclaration(node, {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isVar;
+var _generated = require("./generated");
+var _constants = require("../constants");
+function isVar(node) {
+  return (0, _generated.isVariableDeclaration)(node, {
     kind: "var"
-  }) && !node[BLOCK_SCOPED_SYMBOL];
+  }) && !node[_constants.BLOCK_SCOPED_SYMBOL];
 }
 
 //# sourceMappingURL=isVar.js.map

lib/validators/matchesPattern.js

@@ -1,8 +0,14 @@
-import { isIdentifier, isMemberExpression, isStringLiteral, isThisExpression } from "./generated/index.js";
-export default function matchesPattern(member, match, allowPartial) {
-  if (!isMemberExpression(member)) return false;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = matchesPattern;
+var _generated = require("./generated");
+function matchesPattern(member, match, allowPartial) {
+  if (!(0, _generated.isMemberExpression)(member)) return false;
   const parts = Array.isArray(match) ? match : match.split(".");
   const nodes = [];
   let node;
-  for (node = member; isMemberExpression(node); node = node.object) {
+  for (node = member; (0, _generated.isMemberExpression)(node); node = node.object) {
     nodes.push(node.property);
@@ -16,7 +22,7 @@ }
     let value;
-    if (isIdentifier(node)) {
+    if ((0, _generated.isIdentifier)(node)) {
       value = node.name;
-    } else if (isStringLiteral(node)) {
+    } else if ((0, _generated.isStringLiteral)(node)) {
       value = node.value;
-    } else if (isThisExpression(node)) {
+    } else if ((0, _generated.isThisExpression)(node)) {
       value = "this";
@@ -23,0 +29,0 @@ } else {

lib/validators/react/isCompatTag.js

@@ -1,2 +0,8 @@
-export default function isCompatTag(tagName) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isCompatTag;
+function isCompatTag(tagName) {
   return !!tagName && /^[a-z]/.test(tagName);
@@ -3,0 +9,0 @@ }

lib/validators/react/isReactComponent.js

@@ -1,5 +0,12 @@
-import buildMatchMemberExpression from "../buildMatchMemberExpression.js";
-const isReactComponent = buildMatchMemberExpression("React.Component");
-export default isReactComponent;
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _buildMatchMemberExpression = require("../buildMatchMemberExpression");
+const isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component");
+var _default = isReactComponent;
+exports.default = _default;
+
 //# sourceMappingURL=isReactComponent.js.map

lib/validators/validate.js

@@ -1,5 +0,13 @@
-import { NODE_FIELDS, NODE_PARENT_VALIDATIONS } from "../definitions/index.js";
-export default function validate(node, key, val) {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = validate;
+exports.validateChild = validateChild;
+exports.validateField = validateField;
+var _definitions = require("../definitions");
+function validate(node, key, val) {
   if (!node) return;
-  const fields = NODE_FIELDS[node.type];
+  const fields = _definitions.NODE_FIELDS[node.type];
   if (!fields) return;
@@ -10,3 +18,3 @@ const field = fields[key];
 }
-export function validateField(node, key, val, field) {
+function validateField(node, key, val, field) {
   if (!(field != null && field.validate)) return;
@@ -16,5 +24,5 @@ if (field.optional && val == null) return;
 }
-export function validateChild(node, key, val) {
+function validateChild(node, key, val) {
   if (val == null) return;
-  const validate = NODE_PARENT_VALIDATIONS[val.type];
+  const validate = _definitions.NODE_PARENT_VALIDATIONS[val.type];
   if (!validate) return;
@@ -21,0 +29,0 @@ validate(node, key, val);

package.json

 {
   "name": "@babel/types",
-  "version": "7.21.4-esm.2",
+  "version": "7.21.4-esm.3",
   "description": "Babel Types is a Lodash-esque utility library for AST nodes",
@@ -27,9 +27,9 @@ "author": "The Babel Team (https://babel.dev/team)",
   "dependencies": {
-    "@babel/helper-string-parser": "7.21.4-esm.2",
-    "@babel/helper-validator-identifier": "7.21.4-esm.2",
+    "@babel/helper-string-parser": "7.21.4-esm.3",
+    "@babel/helper-validator-identifier": "7.21.4-esm.3",
     "to-fast-properties": "^2.0.0"
   },
   "devDependencies": {
-    "@babel/generator": "7.21.4-esm.2",
-    "@babel/parser": "7.21.4-esm.2",
+    "@babel/generator": "7.21.4-esm.3",
+    "@babel/parser": "7.21.4-esm.3",
     "chalk": "^4.1.0",
@@ -36,0 +36,0 @@ "glob": "^7.2.0"

No alert changes

Improved metrics

Total package byte prevSize

2481438

increased by4.1%

Lines of code

21477

increased by18.23%

Dependency changes

• + Added@babel/helper-string-parser@7.21.4-esm.3(transitive)

• + Added@babel/helper-validator-identifier@7.21.4-esm.3(transitive)

• - Removed@babel/helper-string-parser@7.21.4-esm.2(transitive)

• - Removed@babel/helper-validator-identifier@7.21.4-esm.2(transitive)

• Updated@babel/helper-string-parser@7.21.4-esm.3

• Updated@babel/helper-validator-identifier@7.21.4-esm.3