@babel/types - npm Package Compare versions

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

lib/asserts/assertNode.js

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

lib/asserts/generated/index.js

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

lib/builders/flow/createFlowUnionType.js

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

lib/builders/flow/createTypeAnnotationBasedOnTypeof.js

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

lib/builders/generated/index.js

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

lib/builders/generated/uppercase.js

@@ -1,1526 +0,3 @@
-"use strict";
+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";
 
-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,19 +0,13 @@
-"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) {
+import { isJSXText, isJSXExpressionContainer, isJSXEmptyExpression } from "../../validators/generated/index.js";
+import cleanJSXElementLiteralChild from "../../utils/react/cleanJSXElementLiteralChild.js";
+export default function buildChildren(node) {
   const elements = [];
   for (let i = 0; i < node.children.length; i++) {
     let child = node.children[i];
-    if ((0, _generated.isJSXText)(child)) {
-      (0, _cleanJSXElementLiteralChild.default)(child, elements);
+    if (isJSXText(child)) {
+      cleanJSXElementLiteralChild(child, elements);
       continue;
     }
-    if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression;
-    if ((0, _generated.isJSXEmptyExpression)(child)) continue;
+    if (isJSXExpressionContainer(child)) child = child.expression;
+    if (isJSXEmptyExpression(child)) continue;
     elements.push(child);
@@ -20,0 +14,0 @@ }

lib/builders/typescript/createTSUnionType.js

@@ -1,19 +0,13 @@
-"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) {
+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) {
   const types = typeAnnotations.map(type => {
-    return (0, _index.isTSTypeAnnotation)(type) ? type.typeAnnotation : type;
+    return isTSTypeAnnotation(type) ? type.typeAnnotation : type;
   });
-  const flattened = (0, _removeTypeDuplicates.default)(types);
+  const flattened = removeTypeDuplicates(types);
   if (flattened.length === 1) {
     return flattened[0];
   } else {
-    return (0, _generated.tsUnionType)(flattened);
+    return tsUnionType(flattened);
   }
@@ -20,0 +14,0 @@ }

lib/builders/validateNode.js

@@ -1,13 +0,7 @@
-"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];
+import validate from "../validators/validate.js";
+import { BUILDER_KEYS } from "../index.js";
+export default function validateNode(node) {
+  const keys = BUILDER_KEYS[node.type];
   for (const key of keys) {
-    (0, _validate.default)(node, key, node[key]);
+    validate(node, key, node[key]);
   }
@@ -14,0 +8,0 @@ return node;

lib/clone/clone.js

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

lib/clone/cloneDeep.js

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

lib/clone/cloneDeepWithoutLoc.js

@@ -1,12 +0,6 @@
-"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);
+import cloneNode from "./cloneNode.js";
+export default function cloneDeepWithoutLoc(node) {
+  return cloneNode(node, true, true);
 }
 
 //# sourceMappingURL=cloneDeepWithoutLoc.js.map

lib/clone/cloneNode.js

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

lib/clone/cloneWithoutLoc.js

@@ -1,12 +0,6 @@
-"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);
+import cloneNode from "./cloneNode.js";
+export default function cloneWithoutLoc(node) {
+  return cloneNode(node, false, true);
 }
 
 //# sourceMappingURL=cloneWithoutLoc.js.map

lib/comments/addComment.js

@@ -1,10 +0,4 @@
-"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, [{
+import addComments from "./addComments.js";
+export default function addComment(node, type, content, line) {
+  return addComments(node, type, [{
     type: line ? "CommentLine" : "CommentBlock",
@@ -11,0 +5,0 @@ value: content

lib/comments/addComments.js

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

lib/comments/inheritInnerComments.js

@@ -1,12 +0,6 @@
-"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);
+import inherit from "../utils/inherit.js";
+export default function inheritInnerComments(child, parent) {
+  inherit("innerComments", child, parent);
 }
 
 //# sourceMappingURL=inheritInnerComments.js.map

lib/comments/inheritLeadingComments.js

@@ -1,12 +0,6 @@
-"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);
+import inherit from "../utils/inherit.js";
+export default function inheritLeadingComments(child, parent) {
+  inherit("leadingComments", child, parent);
 }
 
 //# sourceMappingURL=inheritLeadingComments.js.map

lib/comments/inheritsComments.js

@@ -1,14 +0,8 @@
-"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);
+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);
   return child;
@@ -15,0 +9,0 @@ }

lib/comments/inheritTrailingComments.js

@@ -1,12 +0,6 @@
-"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);
+import inherit from "../utils/inherit.js";
+export default function inheritTrailingComments(child, parent) {
+  inherit("trailingComments", child, parent);
 }
 
 //# sourceMappingURL=inheritTrailingComments.js.map

lib/comments/removeComments.js

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

lib/constants/generated/index.js

@@ -1,109 +0,53 @@
-"use strict";
+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;
 
-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,51 +0,25 @@
-"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 = {
+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 = {
   optional: ["typeAnnotation", "typeParameters", "returnType"],
   force: ["start", "loc", "end"]
 };
-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;
+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");
 
 //# sourceMappingURL=index.js.map

lib/converters/ensureBlock.js

@@ -1,10 +0,4 @@
-"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);
+import toBlock from "./toBlock.js";
+export default function ensureBlock(node, key = "body") {
+  const result = toBlock(node[key], node);
   node[key] = result;
@@ -11,0 +5,0 @@ return result;

lib/converters/gatherSequenceExpressions.js

@@ -1,47 +0,41 @@
-"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) {
+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) {
   const exprs = [];
   let ensureLastUndefined = true;
   for (const node of nodes) {
-    if (!(0, _generated.isEmptyStatement)(node)) {
+    if (!isEmptyStatement(node)) {
       ensureLastUndefined = false;
     }
-    if ((0, _generated.isExpression)(node)) {
+    if (isExpression(node)) {
       exprs.push(node);
-    } else if ((0, _generated.isExpressionStatement)(node)) {
+    } else if (isExpressionStatement(node)) {
       exprs.push(node.expression);
-    } else if ((0, _generated.isVariableDeclaration)(node)) {
+    } else if (isVariableDeclaration(node)) {
       if (node.kind !== "var") return;
       for (const declar of node.declarations) {
-        const bindings = (0, _getBindingIdentifiers.default)(declar);
+        const bindings = getBindingIdentifiers(declar);
         for (const key of Object.keys(bindings)) {
           declars.push({
             kind: node.kind,
-            id: (0, _cloneNode.default)(bindings[key])
+            id: cloneNode(bindings[key])
           });
         }
         if (declar.init) {
-          exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init));
+          exprs.push(assignmentExpression("=", declar.id, declar.init));
         }
       }
       ensureLastUndefined = true;
-    } else if ((0, _generated.isIfStatement)(node)) {
+    } else if (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((0, _generated2.conditionalExpression)(node.test, consequent, alternate));
-    } else if ((0, _generated.isBlockStatement)(node)) {
+      exprs.push(conditionalExpression(node.test, consequent, alternate));
+    } else if (isBlockStatement(node)) {
       const body = gatherSequenceExpressions(node.body, scope, declars);
       if (!body) return;
       exprs.push(body);
-    } else if ((0, _generated.isEmptyStatement)(node)) {
+    } else if (isEmptyStatement(node)) {
       if (nodes.indexOf(node) === 0) {
@@ -60,3 +54,3 @@ ensureLastUndefined = true;
   } else {
-    return (0, _generated2.sequenceExpression)(exprs);
+    return sequenceExpression(exprs);
   }
@@ -63,0 +57,0 @@ }

lib/converters/toBindingIdentifierName.js

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

lib/converters/toBlock.js

@@ -1,22 +0,16 @@
-"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)) {
+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)) {
     return node;
   }
   let blockNodes = [];
-  if ((0, _generated.isEmptyStatement)(node)) {
+  if (isEmptyStatement(node)) {
     blockNodes = [];
   } else {
-    if (!(0, _generated.isStatement)(node)) {
-      if ((0, _generated.isFunction)(parent)) {
-        node = (0, _generated2.returnStatement)(node);
+    if (!isStatement(node)) {
+      if (isFunction(parent)) {
+        node = returnStatement(node);
       } else {
-        node = (0, _generated2.expressionStatement)(node);
+        node = expressionStatement(node);
       }
@@ -26,5 +20,5 @@ }
   }
-  return (0, _generated2.blockStatement)(blockNodes);
+  return blockStatement(blockNodes);
 }
 
 //# sourceMappingURL=toBlock.js.map

lib/converters/toComputedKey.js

@@ -1,11 +0,5 @@
-"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);
+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);
   return key;
@@ -12,0 +6,0 @@ }

lib/converters/toExpression.js

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

lib/converters/toIdentifier.js

@@ -1,14 +0,8 @@
-"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) {
+import isValidIdentifier from "../validators/isValidIdentifier.js";
+import { isIdentifierChar } from "@babel/helper-validator-identifier";
+export default function toIdentifier(input) {
   input = input + "";
   let name = "";
   for (const c of input) {
-    name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-";
+    name += isIdentifierChar(c.codePointAt(0)) ? c : "-";
   }
@@ -19,3 +13,3 @@ name = name.replace(/^[-0-9]+/, "");
   });
-  if (!(0, _isValidIdentifier.default)(name)) {
+  if (!isValidIdentifier(name)) {
     name = `_${name}`;
@@ -22,0 +16,0 @@ }

lib/converters/toKeyAlias.js

@@ -1,20 +0,14 @@
-"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) {
+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) {
   let alias;
   if (node.kind === "method") {
     return toKeyAlias.increment() + "";
-  } else if ((0, _generated.isIdentifier)(key)) {
+  } else if (isIdentifier(key)) {
     alias = key.name;
-  } else if ((0, _generated.isStringLiteral)(key)) {
+  } else if (isStringLiteral(key)) {
     alias = JSON.stringify(key.value);
   } else {
-    alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key)));
+    alias = JSON.stringify(removePropertiesDeep(cloneNode(key)));
   }
@@ -21,0 +15,0 @@ if (node.computed) {

lib/converters/toSequenceExpression.js

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

lib/converters/toStatement.js

@@ -1,13 +0,6 @@
-"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;
+import { isStatement, isFunction, isClass, isAssignmentExpression } from "../validators/generated/index.js";
+import { expressionStatement } from "../builders/generated/index.js";
+export default toStatement;
 function toStatement(node, ignore) {
-  if ((0, _generated.isStatement)(node)) {
+  if (isStatement(node)) {
     return node;
@@ -17,10 +10,10 @@ }
   let newType;
-  if ((0, _generated.isClass)(node)) {
+  if (isClass(node)) {
     mustHaveId = true;
     newType = "ClassDeclaration";
-  } else if ((0, _generated.isFunction)(node)) {
+  } else if (isFunction(node)) {
     mustHaveId = true;
     newType = "FunctionDeclaration";
-  } else if ((0, _generated.isAssignmentExpression)(node)) {
-    return (0, _generated2.expressionStatement)(node);
+  } else if (isAssignmentExpression(node)) {
+    return expressionStatement(node);
   }
@@ -27,0 +20,0 @@ if (mustHaveId && !node.id) {

lib/converters/valueToNode.js

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

lib/definitions/core.js

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

lib/definitions/deprecated-aliases.js

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

lib/definitions/experimental.js

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

lib/definitions/flow.js

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

lib/definitions/index.js

@@ -1,97 +0,25 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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]];
 });
-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;
+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 };
 
 //# sourceMappingURL=index.js.map

lib/definitions/jsx.js

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

lib/definitions/misc.js

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

lib/definitions/placeholders.js

@@ -1,21 +0,12 @@
-"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 = {
+import { ALIAS_KEYS } from "./utils.js";
+export const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
+export const PLACEHOLDERS_ALIAS = {
   Declaration: ["Statement"],
   Pattern: ["PatternLike", "LVal"]
 };
-exports.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS;
 for (const type of PLACEHOLDERS) {
-  const alias = _utils.ALIAS_KEYS[type];
+  const alias = ALIAS_KEYS[type];
   if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias;
 }
-const PLACEHOLDERS_FLIPPED_ALIAS = {};
-exports.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS;
+export const PLACEHOLDERS_FLIPPED_ALIAS = {};
 Object.keys(PLACEHOLDERS_ALIAS).forEach(type => {
@@ -22,0 +13,0 @@ PLACEHOLDERS_ALIAS[type].forEach(alias => {

lib/definitions/typescript.js

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

lib/definitions/utils.js

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

lib/index.js

@@ -1,570 +0,75 @@
-"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
+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
 };
-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;
+export { default as __internal__deprecationWarning } from "./utils/deprecationWarning.js";
 
 //# sourceMappingURL=index.js.map

lib/modifications/appendToMemberExpression.js

@@ -1,10 +0,4 @@
-"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);
+import { memberExpression } from "../builders/generated/index.js";
+export default function appendToMemberExpression(member, append, computed = false) {
+  member.object = memberExpression(member.object, member.property, member.computed);
   member.property = append;
@@ -11,0 +5,0 @@ member.computed = !!computed;

lib/modifications/flow/removeTypeDuplicates.js

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

lib/modifications/inherits.js

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

lib/modifications/prependToMemberExpression.js

@@ -1,14 +0,8 @@
-"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)) {
+import { memberExpression } from "../builders/generated/index.js";
+import { isSuper } from "../index.js";
+export default function prependToMemberExpression(member, prepend) {
+  if (isSuper(member.object)) {
     throw new Error("Cannot prepend node to super property access (`super.foo`).");
   }
-  member.object = (0, _generated.memberExpression)(prepend, member.object);
+  member.object = memberExpression(prepend, member.object);
   return member;
@@ -15,0 +9,0 @@ }

lib/modifications/removeProperties.js

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

lib/modifications/removePropertiesDeep.js

@@ -1,11 +0,5 @@
-"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);
+import traverseFast from "../traverse/traverseFast.js";
+import removeProperties from "./removeProperties.js";
+export default function removePropertiesDeep(tree, opts) {
+  traverseFast(tree, removeProperties, opts);
   return tree;
@@ -12,0 +6,0 @@ }

lib/modifications/typescript/removeTypeDuplicates.js

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

lib/retrievers/getBindingIdentifiers.js

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

lib/retrievers/getOuterBindingIdentifiers.js

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

lib/traverse/traverse.js

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

lib/traverse/traverseFast.js

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

lib/utils/deprecationWarning.js

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

lib/utils/inherit.js

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

lib/utils/react/cleanJSXElementLiteralChild.js

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

lib/utils/shallowEqual.js

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

lib/validators/buildMatchMemberExpression.js

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

lib/validators/is.js

@@ -1,17 +0,11 @@
-"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) {
+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) {
   if (!node) return false;
-  const matches = (0, _isType.default)(node.type, type);
+  const matches = isType(node.type, type);
   if (!matches) {
-    if (!opts && node.type === "Placeholder" && type in _definitions.FLIPPED_ALIAS_KEYS) {
-      return (0, _isPlaceholderType.default)(node.expectedNode, type);
+    if (!opts && node.type === "Placeholder" && type in FLIPPED_ALIAS_KEYS) {
+      return isPlaceholderType(node.expectedNode, type);
     }
@@ -23,3 +17,3 @@ return false;
   } else {
-    return (0, _shallowEqual.default)(node, opts);
+    return shallowEqual(node, opts);
   }
@@ -26,0 +20,0 @@ }

lib/validators/isBinding.js

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

lib/validators/isBlockScoped.js

@@ -1,13 +0,7 @@
-"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);
+import { isClassDeclaration, isFunctionDeclaration } from "./generated/index.js";
+import isLet from "./isLet.js";
+export default function isBlockScoped(node) {
+  return isFunctionDeclaration(node) || isClassDeclaration(node) || isLet(node);
 }
 
 //# sourceMappingURL=isBlockScoped.js.map

lib/validators/isImmutable.js

@@ -1,12 +0,6 @@
-"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)) {
+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)) {
     if (node.name === "undefined") {
@@ -13,0 +7,0 @@ return true;

lib/validators/isLet.js

@@ -1,13 +0,7 @@
-"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]);
+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]);
 }
 
 //# sourceMappingURL=isLet.js.map

lib/validators/isNode.js

@@ -1,12 +0,6 @@
-"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]);
+import { VISITOR_KEYS } from "../definitions/index.js";
+export default function isNode(node) {
+  return !!(node && VISITOR_KEYS[node.type]);
 }
 
 //# sourceMappingURL=isNode.js.map

lib/validators/isNodesEquivalent.js

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

lib/validators/isPlaceholderType.js

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

lib/validators/isReferenced.js

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

lib/validators/isScope.js

@@ -1,18 +0,12 @@
-"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))) {
+import { isFunction, isCatchClause, isBlockStatement, isScopable, isPattern } from "./generated/index.js";
+export default function isScope(node, parent) {
+  if (isBlockStatement(node) && (isFunction(parent) || isCatchClause(parent))) {
     return false;
   }
-  if ((0, _generated.isPattern)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) {
+  if (isPattern(node) && (isFunction(parent) || isCatchClause(parent))) {
     return true;
   }
-  return (0, _generated.isScopable)(node);
+  return isScopable(node);
 }
 
 //# sourceMappingURL=isScope.js.map

lib/validators/isSpecifierDefault.js

@@ -1,10 +0,4 @@
-"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, {
+import { isIdentifier, isImportDefaultSpecifier } from "./generated/index.js";
+export default function isSpecifierDefault(specifier) {
+  return isImportDefaultSpecifier(specifier) || isIdentifier(specifier.imported || specifier.exported, {
     name: "default"
@@ -11,0 +5,0 @@ });

lib/validators/isType.js

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

lib/validators/isValidES3Identifier.js

@@ -1,13 +0,7 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = isValidES3Identifier;
-var _isValidIdentifier = require("./isValidIdentifier");
+import isValidIdentifier from "./isValidIdentifier.js";
 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"]);
-function isValidES3Identifier(name) {
-  return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name);
+export default function isValidES3Identifier(name) {
+  return isValidIdentifier(name) && !RESERVED_WORDS_ES3_ONLY.has(name);
 }
 
 //# sourceMappingURL=isValidES3Identifier.js.map

lib/validators/isValidIdentifier.js

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

lib/validators/isVar.js

@@ -1,15 +0,9 @@
-"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, {
+import { isVariableDeclaration } from "./generated/index.js";
+import { BLOCK_SCOPED_SYMBOL } from "../constants/index.js";
+export default function isVar(node) {
+  return isVariableDeclaration(node, {
     kind: "var"
-  }) && !node[_constants.BLOCK_SCOPED_SYMBOL];
+  }) && !node[BLOCK_SCOPED_SYMBOL];
 }
 
 //# sourceMappingURL=isVar.js.map

lib/validators/matchesPattern.js

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

lib/validators/react/isCompatTag.js

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

lib/validators/react/isReactComponent.js

@@ -1,12 +0,5 @@
-"use strict";
+import buildMatchMemberExpression from "../buildMatchMemberExpression.js";
+const isReactComponent = buildMatchMemberExpression("React.Component");
+export default isReactComponent;
 
-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,13 +0,5 @@
-"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) {
+import { NODE_FIELDS, NODE_PARENT_VALIDATIONS } from "../definitions/index.js";
+export default function validate(node, key, val) {
   if (!node) return;
-  const fields = _definitions.NODE_FIELDS[node.type];
+  const fields = NODE_FIELDS[node.type];
   if (!fields) return;
@@ -18,3 +10,3 @@ const field = fields[key];
 }
-function validateField(node, key, val, field) {
+export function validateField(node, key, val, field) {
   if (!(field != null && field.validate)) return;
@@ -24,5 +16,5 @@ if (field.optional && val == null) return;
 }
-function validateChild(node, key, val) {
+export function validateChild(node, key, val) {
   if (val == null) return;
-  const validate = _definitions.NODE_PARENT_VALIDATIONS[val.type];
+  const validate = NODE_PARENT_VALIDATIONS[val.type];
   if (!validate) return;
@@ -29,0 +21,0 @@ validate(node, key, val);

package.json

 {
   "name": "@babel/types",
-  "version": "7.21.4-esm.3",
+  "version": "7.21.4-esm.4",
   "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.3",
-    "@babel/helper-validator-identifier": "7.21.4-esm.3",
+    "@babel/helper-string-parser": "7.21.4-esm.4",
+    "@babel/helper-validator-identifier": "7.21.4-esm.4",
     "to-fast-properties": "^2.0.0"
   },
   "devDependencies": {
-    "@babel/generator": "7.21.4-esm.3",
-    "@babel/parser": "7.21.4-esm.3",
+    "@babel/generator": "7.21.4-esm.4",
+    "@babel/parser": "7.21.4-esm.4",
     "chalk": "^4.1.0",
@@ -36,0 +36,0 @@ "glob": "^7.2.0"

No alert changes

Improved metrics

Number of package files

171

increased by0.59%

Worsened metrics

Total package byte prevSize

2383755

decreased by-3.94%

Lines of code

18166

decreased by-15.42%

Dependency changes

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

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

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

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

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

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