node_modules/@babel/types/lib/builders/generated/index.js

+"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.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");
+
+function arrayExpression(elements = []) {
+  return (0, _validateNode.default)({
+    type: "ArrayExpression",
+    elements
+  });
+}
+
+function assignmentExpression(operator, left, right) {
+  return (0, _validateNode.default)({
+    type: "AssignmentExpression",
+    operator,
+    left,
+    right
+  });
+}
+
+function binaryExpression(operator, left, right) {
+  return (0, _validateNode.default)({
+    type: "BinaryExpression",
+    operator,
+    left,
+    right
+  });
+}
+
+function interpreterDirective(value) {
+  return (0, _validateNode.default)({
+    type: "InterpreterDirective",
+    value
+  });
+}
+
+function directive(value) {
+  return (0, _validateNode.default)({
+    type: "Directive",
+    value
+  });
+}
+
+function directiveLiteral(value) {
+  return (0, _validateNode.default)({
+    type: "DirectiveLiteral",
+    value
+  });
+}
+
+function blockStatement(body, directives = []) {
+  return (0, _validateNode.default)({
+    type: "BlockStatement",
+    body,
+    directives
+  });
+}
+
+function breakStatement(label = null) {
+  return (0, _validateNode.default)({
+    type: "BreakStatement",
+    label
+  });
+}
+
+function callExpression(callee, _arguments) {
+  return (0, _validateNode.default)({
+    type: "CallExpression",
+    callee,
+    arguments: _arguments
+  });
+}
+
+function catchClause(param = null, body) {
+  return (0, _validateNode.default)({
+    type: "CatchClause",
+    param,
+    body
+  });
+}
+
+function conditionalExpression(test, consequent, alternate) {
+  return (0, _validateNode.default)({
+    type: "ConditionalExpression",
+    test,
+    consequent,
+    alternate
+  });
+}
+
+function continueStatement(label = null) {
+  return (0, _validateNode.default)({
+    type: "ContinueStatement",
+    label
+  });
+}
+
+function debuggerStatement() {
+  return {
+    type: "DebuggerStatement"
+  };
+}
+
+function doWhileStatement(test, body) {
+  return (0, _validateNode.default)({
+    type: "DoWhileStatement",
+    test,
+    body
+  });
+}
+
+function emptyStatement() {
+  return {
+    type: "EmptyStatement"
+  };
+}
+
+function expressionStatement(expression) {
+  return (0, _validateNode.default)({
+    type: "ExpressionStatement",
+    expression
+  });
+}
+
+function file(program, comments = null, tokens = null) {
+  return (0, _validateNode.default)({
+    type: "File",
+    program,
+    comments,
+    tokens
+  });
+}
+
+function forInStatement(left, right, body) {
+  return (0, _validateNode.default)({
+    type: "ForInStatement",
+    left,
+    right,
+    body
+  });
+}
+
+function forStatement(init = null, test = null, update = null, body) {
+  return (0, _validateNode.default)({
+    type: "ForStatement",
+    init,
+    test,
+    update,
+    body
+  });
+}
+
+function functionDeclaration(id = null, params, body, generator = false, async = false) {
+  return (0, _validateNode.default)({
+    type: "FunctionDeclaration",
+    id,
+    params,
+    body,
+    generator,
+    async
+  });
+}
+
+function functionExpression(id = null, params, body, generator = false, async = false) {
+  return (0, _validateNode.default)({
+    type: "FunctionExpression",
+    id,
+    params,
+    body,
+    generator,
+    async
+  });
+}
+
+function identifier(name) {
+  return (0, _validateNode.default)({
+    type: "Identifier",
+    name
+  });
+}
+
+function ifStatement(test, consequent, alternate = null) {
+  return (0, _validateNode.default)({
+    type: "IfStatement",
+    test,
+    consequent,
+    alternate
+  });
+}
+
+function labeledStatement(label, body) {
+  return (0, _validateNode.default)({
+    type: "LabeledStatement",
+    label,
+    body
+  });
+}
+
+function stringLiteral(value) {
+  return (0, _validateNode.default)({
+    type: "StringLiteral",
+    value
+  });
+}
+
+function numericLiteral(value) {
+  return (0, _validateNode.default)({
+    type: "NumericLiteral",
+    value
+  });
+}
+
+function nullLiteral() {
+  return {
+    type: "NullLiteral"
+  };
+}
+
+function booleanLiteral(value) {
+  return (0, _validateNode.default)({
+    type: "BooleanLiteral",
+    value
+  });
+}
+
+function regExpLiteral(pattern, flags = "") {
+  return (0, _validateNode.default)({
+    type: "RegExpLiteral",
+    pattern,
+    flags
+  });
+}
+
+function logicalExpression(operator, left, right) {
+  return (0, _validateNode.default)({
+    type: "LogicalExpression",
+    operator,
+    left,
+    right
+  });
+}
+
+function memberExpression(object, property, computed = false, optional = null) {
+  return (0, _validateNode.default)({
+    type: "MemberExpression",
+    object,
+    property,
+    computed,
+    optional
+  });
+}
+
+function newExpression(callee, _arguments) {
+  return (0, _validateNode.default)({
+    type: "NewExpression",
+    callee,
+    arguments: _arguments
+  });
+}
+
+function program(body, directives = [], sourceType = "script", interpreter = null) {
+  return (0, _validateNode.default)({
+    type: "Program",
+    body,
+    directives,
+    sourceType,
+    interpreter,
+    sourceFile: null
+  });
+}
+
+function objectExpression(properties) {
+  return (0, _validateNode.default)({
+    type: "ObjectExpression",
+    properties
+  });
+}
+
+function objectMethod(kind = "method", key, params, body, computed = false, generator = false, async = false) {
+  return (0, _validateNode.default)({
+    type: "ObjectMethod",
+    kind,
+    key,
+    params,
+    body,
+    computed,
+    generator,
+    async
+  });
+}
+
+function objectProperty(key, value, computed = false, shorthand = false, decorators = null) {
+  return (0, _validateNode.default)({
+    type: "ObjectProperty",
+    key,
+    value,
+    computed,
+    shorthand,
+    decorators
+  });
+}
+
+function restElement(argument) {
+  return (0, _validateNode.default)({
+    type: "RestElement",
+    argument
+  });
+}
+
+function returnStatement(argument = null) {
+  return (0, _validateNode.default)({
+    type: "ReturnStatement",
+    argument
+  });
+}
+
+function sequenceExpression(expressions) {
+  return (0, _validateNode.default)({
+    type: "SequenceExpression",
+    expressions
+  });
+}
+
+function parenthesizedExpression(expression) {
+  return (0, _validateNode.default)({
+    type: "ParenthesizedExpression",
+    expression
+  });
+}
+
+function switchCase(test = null, consequent) {
+  return (0, _validateNode.default)({
+    type: "SwitchCase",
+    test,
+    consequent
+  });
+}
+
+function switchStatement(discriminant, cases) {
+  return (0, _validateNode.default)({
+    type: "SwitchStatement",
+    discriminant,
+    cases
+  });
+}
+
+function thisExpression() {
+  return {
+    type: "ThisExpression"
+  };
+}
+
+function throwStatement(argument) {
+  return (0, _validateNode.default)({
+    type: "ThrowStatement",
+    argument
+  });
+}
+
+function tryStatement(block, handler = null, finalizer = null) {
+  return (0, _validateNode.default)({
+    type: "TryStatement",
+    block,
+    handler,
+    finalizer
+  });
+}
+
+function unaryExpression(operator, argument, prefix = true) {
+  return (0, _validateNode.default)({
+    type: "UnaryExpression",
+    operator,
+    argument,
+    prefix
+  });
+}
+
+function updateExpression(operator, argument, prefix = false) {
+  return (0, _validateNode.default)({
+    type: "UpdateExpression",
+    operator,
+    argument,
+    prefix
+  });
+}
+
+function variableDeclaration(kind, declarations) {
+  return (0, _validateNode.default)({
+    type: "VariableDeclaration",
+    kind,
+    declarations
+  });
+}
+
+function variableDeclarator(id, init = null) {
+  return (0, _validateNode.default)({
+    type: "VariableDeclarator",
+    id,
+    init
+  });
+}
+
+function whileStatement(test, body) {
+  return (0, _validateNode.default)({
+    type: "WhileStatement",
+    test,
+    body
+  });
+}
+
+function withStatement(object, body) {
+  return (0, _validateNode.default)({
+    type: "WithStatement",
+    object,
+    body
+  });
+}
+
+function assignmentPattern(left, right) {
+  return (0, _validateNode.default)({
+    type: "AssignmentPattern",
+    left,
+    right
+  });
+}
+
+function arrayPattern(elements) {
+  return (0, _validateNode.default)({
+    type: "ArrayPattern",
+    elements
+  });
+}
+
+function arrowFunctionExpression(params, body, async = false) {
+  return (0, _validateNode.default)({
+    type: "ArrowFunctionExpression",
+    params,
+    body,
+    async,
+    expression: null
+  });
+}
+
+function classBody(body) {
+  return (0, _validateNode.default)({
+    type: "ClassBody",
+    body
+  });
+}
+
+function classExpression(id = null, superClass = null, body, decorators = null) {
+  return (0, _validateNode.default)({
+    type: "ClassExpression",
+    id,
+    superClass,
+    body,
+    decorators
+  });
+}
+
+function classDeclaration(id, superClass = null, body, decorators = null) {
+  return (0, _validateNode.default)({
+    type: "ClassDeclaration",
+    id,
+    superClass,
+    body,
+    decorators
+  });
+}
+
+function exportAllDeclaration(source) {
+  return (0, _validateNode.default)({
+    type: "ExportAllDeclaration",
+    source
+  });
+}
+
+function exportDefaultDeclaration(declaration) {
+  return (0, _validateNode.default)({
+    type: "ExportDefaultDeclaration",
+    declaration
+  });
+}
+
+function exportNamedDeclaration(declaration = null, specifiers = [], source = null) {
+  return (0, _validateNode.default)({
+    type: "ExportNamedDeclaration",
+    declaration,
+    specifiers,
+    source
+  });
+}
+
+function exportSpecifier(local, exported) {
+  return (0, _validateNode.default)({
+    type: "ExportSpecifier",
+    local,
+    exported
+  });
+}
+
+function forOfStatement(left, right, body, _await = false) {
+  return (0, _validateNode.default)({
+    type: "ForOfStatement",
+    left,
+    right,
+    body,
+    await: _await
+  });
+}
+
+function importDeclaration(specifiers, source) {
+  return (0, _validateNode.default)({
+    type: "ImportDeclaration",
+    specifiers,
+    source
+  });
+}
+
+function importDefaultSpecifier(local) {
+  return (0, _validateNode.default)({
+    type: "ImportDefaultSpecifier",
+    local
+  });
+}
+
+function importNamespaceSpecifier(local) {
+  return (0, _validateNode.default)({
+    type: "ImportNamespaceSpecifier",
+    local
+  });
+}
+
+function importSpecifier(local, imported) {
+  return (0, _validateNode.default)({
+    type: "ImportSpecifier",
+    local,
+    imported
+  });
+}
+
+function metaProperty(meta, property) {
+  return (0, _validateNode.default)({
+    type: "MetaProperty",
+    meta,
+    property
+  });
+}
+
+function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator = false, async = false) {
+  return (0, _validateNode.default)({
+    type: "ClassMethod",
+    kind,
+    key,
+    params,
+    body,
+    computed,
+    static: _static,
+    generator,
+    async
+  });
+}
+
+function objectPattern(properties) {
+  return (0, _validateNode.default)({
+    type: "ObjectPattern",
+    properties
+  });
+}
+
+function spreadElement(argument) {
+  return (0, _validateNode.default)({
+    type: "SpreadElement",
+    argument
+  });
+}
+
+function _super() {
+  return {
+    type: "Super"
+  };
+}
+
+function taggedTemplateExpression(tag, quasi) {
+  return (0, _validateNode.default)({
+    type: "TaggedTemplateExpression",
+    tag,
+    quasi
+  });
+}
+
+function templateElement(value, tail = false) {
+  return (0, _validateNode.default)({
+    type: "TemplateElement",
+    value,
+    tail
+  });
+}
+
+function templateLiteral(quasis, expressions) {
+  return (0, _validateNode.default)({
+    type: "TemplateLiteral",
+    quasis,
+    expressions
+  });
+}
+
+function yieldExpression(argument = null, delegate = false) {
+  return (0, _validateNode.default)({
+    type: "YieldExpression",
+    argument,
+    delegate
+  });
+}
+
+function awaitExpression(argument) {
+  return (0, _validateNode.default)({
+    type: "AwaitExpression",
+    argument
+  });
+}
+
+function _import() {
+  return {
+    type: "Import"
+  };
+}
+
+function bigIntLiteral(value) {
+  return (0, _validateNode.default)({
+    type: "BigIntLiteral",
+    value
+  });
+}
+
+function exportNamespaceSpecifier(exported) {
+  return (0, _validateNode.default)({
+    type: "ExportNamespaceSpecifier",
+    exported
+  });
+}
+
+function optionalMemberExpression(object, property, computed = false, optional) {
+  return (0, _validateNode.default)({
+    type: "OptionalMemberExpression",
+    object,
+    property,
+    computed,
+    optional
+  });
+}
+
+function optionalCallExpression(callee, _arguments, optional) {
+  return (0, _validateNode.default)({
+    type: "OptionalCallExpression",
+    callee,
+    arguments: _arguments,
+    optional
+  });
+}
+
+function classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
+  return (0, _validateNode.default)({
+    type: "ClassProperty",
+    key,
+    value,
+    typeAnnotation,
+    decorators,
+    computed,
+    static: _static
+  });
+}
+
+function classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
+  return (0, _validateNode.default)({
+    type: "ClassAccessorProperty",
+    key,
+    value,
+    typeAnnotation,
+    decorators,
+    computed,
+    static: _static
+  });
+}
+
+function classPrivateProperty(key, value = null, decorators = null, _static) {
+  return (0, _validateNode.default)({
+    type: "ClassPrivateProperty",
+    key,
+    value,
+    decorators,
+    static: _static
+  });
+}
+
+function classPrivateMethod(kind = "method", key, params, body, _static = false) {
+  return (0, _validateNode.default)({
+    type: "ClassPrivateMethod",
+    kind,
+    key,
+    params,
+    body,
+    static: _static
+  });
+}
+
+function privateName(id) {
+  return (0, _validateNode.default)({
+    type: "PrivateName",
+    id
+  });
+}
+
+function staticBlock(body) {
+  return (0, _validateNode.default)({
+    type: "StaticBlock",
+    body
+  });
+}
+
+function anyTypeAnnotation() {
+  return {
+    type: "AnyTypeAnnotation"
+  };
+}
+
+function arrayTypeAnnotation(elementType) {
+  return (0, _validateNode.default)({
+    type: "ArrayTypeAnnotation",
+    elementType
+  });
+}
+
+function booleanTypeAnnotation() {
+  return {
+    type: "BooleanTypeAnnotation"
+  };
+}
+
+function booleanLiteralTypeAnnotation(value) {
+  return (0, _validateNode.default)({
+    type: "BooleanLiteralTypeAnnotation",
+    value
+  });
+}
+
+function nullLiteralTypeAnnotation() {
+  return {
+    type: "NullLiteralTypeAnnotation"
+  };
+}
+
+function classImplements(id, typeParameters = null) {
+  return (0, _validateNode.default)({
+    type: "ClassImplements",
+    id,
+    typeParameters
+  });
+}
+
+function declareClass(id, typeParameters = null, _extends = null, body) {
+  return (0, _validateNode.default)({
+    type: "DeclareClass",
+    id,
+    typeParameters,
+    extends: _extends,
+    body
+  });
+}
+
+function declareFunction(id) {
+  return (0, _validateNode.default)({
+    type: "DeclareFunction",
+    id
+  });
+}
+
+function declareInterface(id, typeParameters = null, _extends = null, body) {
+  return (0, _validateNode.default)({
+    type: "DeclareInterface",
+    id,
+    typeParameters,
+    extends: _extends,
+    body
+  });
+}
+
+function declareModule(id, body, kind = null) {
+  return (0, _validateNode.default)({
+    type: "DeclareModule",
+    id,
+    body,
+    kind
+  });
+}
+
+function declareModuleExports(typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "DeclareModuleExports",
+    typeAnnotation
+  });
+}
+
+function declareTypeAlias(id, typeParameters = null, right) {
+  return (0, _validateNode.default)({
+    type: "DeclareTypeAlias",
+    id,
+    typeParameters,
+    right
+  });
+}
+
+function declareOpaqueType(id, typeParameters = null, supertype = null) {
+  return (0, _validateNode.default)({
+    type: "DeclareOpaqueType",
+    id,
+    typeParameters,
+    supertype
+  });
+}
+
+function declareVariable(id) {
+  return (0, _validateNode.default)({
+    type: "DeclareVariable",
+    id
+  });
+}
+
+function declareExportDeclaration(declaration = null, specifiers = null, source = null) {
+  return (0, _validateNode.default)({
+    type: "DeclareExportDeclaration",
+    declaration,
+    specifiers,
+    source
+  });
+}
+
+function declareExportAllDeclaration(source) {
+  return (0, _validateNode.default)({
+    type: "DeclareExportAllDeclaration",
+    source
+  });
+}
+
+function declaredPredicate(value) {
+  return (0, _validateNode.default)({
+    type: "DeclaredPredicate",
+    value
+  });
+}
+
+function existsTypeAnnotation() {
+  return {
+    type: "ExistsTypeAnnotation"
+  };
+}
+
+function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) {
+  return (0, _validateNode.default)({
+    type: "FunctionTypeAnnotation",
+    typeParameters,
+    params,
+    rest,
+    returnType
+  });
+}
+
+function functionTypeParam(name = null, typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "FunctionTypeParam",
+    name,
+    typeAnnotation
+  });
+}
+
+function genericTypeAnnotation(id, typeParameters = null) {
+  return (0, _validateNode.default)({
+    type: "GenericTypeAnnotation",
+    id,
+    typeParameters
+  });
+}
+
+function inferredPredicate() {
+  return {
+    type: "InferredPredicate"
+  };
+}
+
+function interfaceExtends(id, typeParameters = null) {
+  return (0, _validateNode.default)({
+    type: "InterfaceExtends",
+    id,
+    typeParameters
+  });
+}
+
+function interfaceDeclaration(id, typeParameters = null, _extends = null, body) {
+  return (0, _validateNode.default)({
+    type: "InterfaceDeclaration",
+    id,
+    typeParameters,
+    extends: _extends,
+    body
+  });
+}
+
+function interfaceTypeAnnotation(_extends = null, body) {
+  return (0, _validateNode.default)({
+    type: "InterfaceTypeAnnotation",
+    extends: _extends,
+    body
+  });
+}
+
+function intersectionTypeAnnotation(types) {
+  return (0, _validateNode.default)({
+    type: "IntersectionTypeAnnotation",
+    types
+  });
+}
+
+function mixedTypeAnnotation() {
+  return {
+    type: "MixedTypeAnnotation"
+  };
+}
+
+function emptyTypeAnnotation() {
+  return {
+    type: "EmptyTypeAnnotation"
+  };
+}
+
+function nullableTypeAnnotation(typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "NullableTypeAnnotation",
+    typeAnnotation
+  });
+}
+
+function numberLiteralTypeAnnotation(value) {
+  return (0, _validateNode.default)({
+    type: "NumberLiteralTypeAnnotation",
+    value
+  });
+}
+
+function numberTypeAnnotation() {
+  return {
+    type: "NumberTypeAnnotation"
+  };
+}
+
+function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) {
+  return (0, _validateNode.default)({
+    type: "ObjectTypeAnnotation",
+    properties,
+    indexers,
+    callProperties,
+    internalSlots,
+    exact
+  });
+}
+
+function objectTypeInternalSlot(id, value, optional, _static, method) {
+  return (0, _validateNode.default)({
+    type: "ObjectTypeInternalSlot",
+    id,
+    value,
+    optional,
+    static: _static,
+    method
+  });
+}
+
+function objectTypeCallProperty(value) {
+  return (0, _validateNode.default)({
+    type: "ObjectTypeCallProperty",
+    value,
+    static: null
+  });
+}
+
+function objectTypeIndexer(id = null, key, value, variance = null) {
+  return (0, _validateNode.default)({
+    type: "ObjectTypeIndexer",
+    id,
+    key,
+    value,
+    variance,
+    static: null
+  });
+}
+
+function objectTypeProperty(key, value, variance = null) {
+  return (0, _validateNode.default)({
+    type: "ObjectTypeProperty",
+    key,
+    value,
+    variance,
+    kind: null,
+    method: null,
+    optional: null,
+    proto: null,
+    static: null
+  });
+}
+
+function objectTypeSpreadProperty(argument) {
+  return (0, _validateNode.default)({
+    type: "ObjectTypeSpreadProperty",
+    argument
+  });
+}
+
+function opaqueType(id, typeParameters = null, supertype = null, impltype) {
+  return (0, _validateNode.default)({
+    type: "OpaqueType",
+    id,
+    typeParameters,
+    supertype,
+    impltype
+  });
+}
+
+function qualifiedTypeIdentifier(id, qualification) {
+  return (0, _validateNode.default)({
+    type: "QualifiedTypeIdentifier",
+    id,
+    qualification
+  });
+}
+
+function stringLiteralTypeAnnotation(value) {
+  return (0, _validateNode.default)({
+    type: "StringLiteralTypeAnnotation",
+    value
+  });
+}
+
+function stringTypeAnnotation() {
+  return {
+    type: "StringTypeAnnotation"
+  };
+}
+
+function symbolTypeAnnotation() {
+  return {
+    type: "SymbolTypeAnnotation"
+  };
+}
+
+function thisTypeAnnotation() {
+  return {
+    type: "ThisTypeAnnotation"
+  };
+}
+
+function tupleTypeAnnotation(types) {
+  return (0, _validateNode.default)({
+    type: "TupleTypeAnnotation",
+    types
+  });
+}
+
+function typeofTypeAnnotation(argument) {
+  return (0, _validateNode.default)({
+    type: "TypeofTypeAnnotation",
+    argument
+  });
+}
+
+function typeAlias(id, typeParameters = null, right) {
+  return (0, _validateNode.default)({
+    type: "TypeAlias",
+    id,
+    typeParameters,
+    right
+  });
+}
+
+function typeAnnotation(typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "TypeAnnotation",
+    typeAnnotation
+  });
+}
+
+function typeCastExpression(expression, typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "TypeCastExpression",
+    expression,
+    typeAnnotation
+  });
+}
+
+function typeParameter(bound = null, _default = null, variance = null) {
+  return (0, _validateNode.default)({
+    type: "TypeParameter",
+    bound,
+    default: _default,
+    variance,
+    name: null
+  });
+}
+
+function typeParameterDeclaration(params) {
+  return (0, _validateNode.default)({
+    type: "TypeParameterDeclaration",
+    params
+  });
+}
+
+function typeParameterInstantiation(params) {
+  return (0, _validateNode.default)({
+    type: "TypeParameterInstantiation",
+    params
+  });
+}
+
+function unionTypeAnnotation(types) {
+  return (0, _validateNode.default)({
+    type: "UnionTypeAnnotation",
+    types
+  });
+}
+
+function variance(kind) {
+  return (0, _validateNode.default)({
+    type: "Variance",
+    kind
+  });
+}
+
+function voidTypeAnnotation() {
+  return {
+    type: "VoidTypeAnnotation"
+  };
+}
+
+function enumDeclaration(id, body) {
+  return (0, _validateNode.default)({
+    type: "EnumDeclaration",
+    id,
+    body
+  });
+}
+
+function enumBooleanBody(members) {
+  return (0, _validateNode.default)({
+    type: "EnumBooleanBody",
+    members,
+    explicitType: null,
+    hasUnknownMembers: null
+  });
+}
+
+function enumNumberBody(members) {
+  return (0, _validateNode.default)({
+    type: "EnumNumberBody",
+    members,
+    explicitType: null,
+    hasUnknownMembers: null
+  });
+}
+
+function enumStringBody(members) {
+  return (0, _validateNode.default)({
+    type: "EnumStringBody",
+    members,
+    explicitType: null,
+    hasUnknownMembers: null
+  });
+}
+
+function enumSymbolBody(members) {
+  return (0, _validateNode.default)({
+    type: "EnumSymbolBody",
+    members,
+    hasUnknownMembers: null
+  });
+}
+
+function enumBooleanMember(id) {
+  return (0, _validateNode.default)({
+    type: "EnumBooleanMember",
+    id,
+    init: null
+  });
+}
+
+function enumNumberMember(id, init) {
+  return (0, _validateNode.default)({
+    type: "EnumNumberMember",
+    id,
+    init
+  });
+}
+
+function enumStringMember(id, init) {
+  return (0, _validateNode.default)({
+    type: "EnumStringMember",
+    id,
+    init
+  });
+}
+
+function enumDefaultedMember(id) {
+  return (0, _validateNode.default)({
+    type: "EnumDefaultedMember",
+    id
+  });
+}
+
+function indexedAccessType(objectType, indexType) {
+  return (0, _validateNode.default)({
+    type: "IndexedAccessType",
+    objectType,
+    indexType
+  });
+}
+
+function optionalIndexedAccessType(objectType, indexType) {
+  return (0, _validateNode.default)({
+    type: "OptionalIndexedAccessType",
+    objectType,
+    indexType,
+    optional: null
+  });
+}
+
+function jsxAttribute(name, value = null) {
+  return (0, _validateNode.default)({
+    type: "JSXAttribute",
+    name,
+    value
+  });
+}
+
+function jsxClosingElement(name) {
+  return (0, _validateNode.default)({
+    type: "JSXClosingElement",
+    name
+  });
+}
+
+function jsxElement(openingElement, closingElement = null, children, selfClosing = null) {
+  return (0, _validateNode.default)({
+    type: "JSXElement",
+    openingElement,
+    closingElement,
+    children,
+    selfClosing
+  });
+}
+
+function jsxEmptyExpression() {
+  return {
+    type: "JSXEmptyExpression"
+  };
+}
+
+function jsxExpressionContainer(expression) {
+  return (0, _validateNode.default)({
+    type: "JSXExpressionContainer",
+    expression
+  });
+}
+
+function jsxSpreadChild(expression) {
+  return (0, _validateNode.default)({
+    type: "JSXSpreadChild",
+    expression
+  });
+}
+
+function jsxIdentifier(name) {
+  return (0, _validateNode.default)({
+    type: "JSXIdentifier",
+    name
+  });
+}
+
+function jsxMemberExpression(object, property) {
+  return (0, _validateNode.default)({
+    type: "JSXMemberExpression",
+    object,
+    property
+  });
+}
+
+function jsxNamespacedName(namespace, name) {
+  return (0, _validateNode.default)({
+    type: "JSXNamespacedName",
+    namespace,
+    name
+  });
+}
+
+function jsxOpeningElement(name, attributes, selfClosing = false) {
+  return (0, _validateNode.default)({
+    type: "JSXOpeningElement",
+    name,
+    attributes,
+    selfClosing
+  });
+}
+
+function jsxSpreadAttribute(argument) {
+  return (0, _validateNode.default)({
+    type: "JSXSpreadAttribute",
+    argument
+  });
+}
+
+function jsxText(value) {
+  return (0, _validateNode.default)({
+    type: "JSXText",
+    value
+  });
+}
+
+function jsxFragment(openingFragment, closingFragment, children) {
+  return (0, _validateNode.default)({
+    type: "JSXFragment",
+    openingFragment,
+    closingFragment,
+    children
+  });
+}
+
+function jsxOpeningFragment() {
+  return {
+    type: "JSXOpeningFragment"
+  };
+}
+
+function jsxClosingFragment() {
+  return {
+    type: "JSXClosingFragment"
+  };
+}
+
+function noop() {
+  return {
+    type: "Noop"
+  };
+}
+
+function placeholder(expectedNode, name) {
+  return (0, _validateNode.default)({
+    type: "Placeholder",
+    expectedNode,
+    name
+  });
+}
+
+function v8IntrinsicIdentifier(name) {
+  return (0, _validateNode.default)({
+    type: "V8IntrinsicIdentifier",
+    name
+  });
+}
+
+function argumentPlaceholder() {
+  return {
+    type: "ArgumentPlaceholder"
+  };
+}
+
+function bindExpression(object, callee) {
+  return (0, _validateNode.default)({
+    type: "BindExpression",
+    object,
+    callee
+  });
+}
+
+function importAttribute(key, value) {
+  return (0, _validateNode.default)({
+    type: "ImportAttribute",
+    key,
+    value
+  });
+}
+
+function decorator(expression) {
+  return (0, _validateNode.default)({
+    type: "Decorator",
+    expression
+  });
+}
+
+function doExpression(body, async = false) {
+  return (0, _validateNode.default)({
+    type: "DoExpression",
+    body,
+    async
+  });
+}
+
+function exportDefaultSpecifier(exported) {
+  return (0, _validateNode.default)({
+    type: "ExportDefaultSpecifier",
+    exported
+  });
+}
+
+function recordExpression(properties) {
+  return (0, _validateNode.default)({
+    type: "RecordExpression",
+    properties
+  });
+}
+
+function tupleExpression(elements = []) {
+  return (0, _validateNode.default)({
+    type: "TupleExpression",
+    elements
+  });
+}
+
+function decimalLiteral(value) {
+  return (0, _validateNode.default)({
+    type: "DecimalLiteral",
+    value
+  });
+}
+
+function moduleExpression(body) {
+  return (0, _validateNode.default)({
+    type: "ModuleExpression",
+    body
+  });
+}
+
+function topicReference() {
+  return {
+    type: "TopicReference"
+  };
+}
+
+function pipelineTopicExpression(expression) {
+  return (0, _validateNode.default)({
+    type: "PipelineTopicExpression",
+    expression
+  });
+}
+
+function pipelineBareFunction(callee) {
+  return (0, _validateNode.default)({
+    type: "PipelineBareFunction",
+    callee
+  });
+}
+
+function pipelinePrimaryTopicReference() {
+  return {
+    type: "PipelinePrimaryTopicReference"
+  };
+}
+
+function tsParameterProperty(parameter) {
+  return (0, _validateNode.default)({
+    type: "TSParameterProperty",
+    parameter
+  });
+}
+
+function tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) {
+  return (0, _validateNode.default)({
+    type: "TSDeclareFunction",
+    id,
+    typeParameters,
+    params,
+    returnType
+  });
+}
+
+function tsDeclareMethod(decorators = null, key, typeParameters = null, params, returnType = null) {
+  return (0, _validateNode.default)({
+    type: "TSDeclareMethod",
+    decorators,
+    key,
+    typeParameters,
+    params,
+    returnType
+  });
+}
+
+function tsQualifiedName(left, right) {
+  return (0, _validateNode.default)({
+    type: "TSQualifiedName",
+    left,
+    right
+  });
+}
+
+function tsCallSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
+    type: "TSCallSignatureDeclaration",
+    typeParameters,
+    parameters,
+    typeAnnotation
+  });
+}
+
+function tsConstructSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
+    type: "TSConstructSignatureDeclaration",
+    typeParameters,
+    parameters,
+    typeAnnotation
+  });
+}
+
+function tsPropertySignature(key, typeAnnotation = null, initializer = null) {
+  return (0, _validateNode.default)({
+    type: "TSPropertySignature",
+    key,
+    typeAnnotation,
+    initializer,
+    kind: null
+  });
+}
+
+function tsMethodSignature(key, typeParameters = null, parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
+    type: "TSMethodSignature",
+    key,
+    typeParameters,
+    parameters,
+    typeAnnotation,
+    kind: null
+  });
+}
+
+function tsIndexSignature(parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
+    type: "TSIndexSignature",
+    parameters,
+    typeAnnotation
+  });
+}
+
+function tsAnyKeyword() {
+  return {
+    type: "TSAnyKeyword"
+  };
+}
+
+function tsBooleanKeyword() {
+  return {
+    type: "TSBooleanKeyword"
+  };
+}
+
+function tsBigIntKeyword() {
+  return {
+    type: "TSBigIntKeyword"
+  };
+}
+
+function tsIntrinsicKeyword() {
+  return {
+    type: "TSIntrinsicKeyword"
+  };
+}
+
+function tsNeverKeyword() {
+  return {
+    type: "TSNeverKeyword"
+  };
+}
+
+function tsNullKeyword() {
+  return {
+    type: "TSNullKeyword"
+  };
+}
+
+function tsNumberKeyword() {
+  return {
+    type: "TSNumberKeyword"
+  };
+}
+
+function tsObjectKeyword() {
+  return {
+    type: "TSObjectKeyword"
+  };
+}
+
+function tsStringKeyword() {
+  return {
+    type: "TSStringKeyword"
+  };
+}
+
+function tsSymbolKeyword() {
+  return {
+    type: "TSSymbolKeyword"
+  };
+}
+
+function tsUndefinedKeyword() {
+  return {
+    type: "TSUndefinedKeyword"
+  };
+}
+
+function tsUnknownKeyword() {
+  return {
+    type: "TSUnknownKeyword"
+  };
+}
+
+function tsVoidKeyword() {
+  return {
+    type: "TSVoidKeyword"
+  };
+}
+
+function tsThisType() {
+  return {
+    type: "TSThisType"
+  };
+}
+
+function tsFunctionType(typeParameters = null, parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
+    type: "TSFunctionType",
+    typeParameters,
+    parameters,
+    typeAnnotation
+  });
+}
+
+function tsConstructorType(typeParameters = null, parameters, typeAnnotation = null) {
+  return (0, _validateNode.default)({
+    type: "TSConstructorType",
+    typeParameters,
+    parameters,
+    typeAnnotation
+  });
+}
+
+function tsTypeReference(typeName, typeParameters = null) {
+  return (0, _validateNode.default)({
+    type: "TSTypeReference",
+    typeName,
+    typeParameters
+  });
+}
+
+function tsTypePredicate(parameterName, typeAnnotation = null, asserts = null) {
+  return (0, _validateNode.default)({
+    type: "TSTypePredicate",
+    parameterName,
+    typeAnnotation,
+    asserts
+  });
+}
+
+function tsTypeQuery(exprName, typeParameters = null) {
+  return (0, _validateNode.default)({
+    type: "TSTypeQuery",
+    exprName,
+    typeParameters
+  });
+}
+
+function tsTypeLiteral(members) {
+  return (0, _validateNode.default)({
+    type: "TSTypeLiteral",
+    members
+  });
+}
+
+function tsArrayType(elementType) {
+  return (0, _validateNode.default)({
+    type: "TSArrayType",
+    elementType
+  });
+}
+
+function tsTupleType(elementTypes) {
+  return (0, _validateNode.default)({
+    type: "TSTupleType",
+    elementTypes
+  });
+}
+
+function tsOptionalType(typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "TSOptionalType",
+    typeAnnotation
+  });
+}
+
+function tsRestType(typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "TSRestType",
+    typeAnnotation
+  });
+}
+
+function tsNamedTupleMember(label, elementType, optional = false) {
+  return (0, _validateNode.default)({
+    type: "TSNamedTupleMember",
+    label,
+    elementType,
+    optional
+  });
+}
+
+function tsUnionType(types) {
+  return (0, _validateNode.default)({
+    type: "TSUnionType",
+    types
+  });
+}
+
+function tsIntersectionType(types) {
+  return (0, _validateNode.default)({
+    type: "TSIntersectionType",
+    types
+  });
+}
+
+function tsConditionalType(checkType, extendsType, trueType, falseType) {
+  return (0, _validateNode.default)({
+    type: "TSConditionalType",
+    checkType,
+    extendsType,
+    trueType,
+    falseType
+  });
+}
+
+function tsInferType(typeParameter) {
+  return (0, _validateNode.default)({
+    type: "TSInferType",
+    typeParameter
+  });
+}
+
+function tsParenthesizedType(typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "TSParenthesizedType",
+    typeAnnotation
+  });
+}
+
+function tsTypeOperator(typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "TSTypeOperator",
+    typeAnnotation,
+    operator: null
+  });
+}
+
+function tsIndexedAccessType(objectType, indexType) {
+  return (0, _validateNode.default)({
+    type: "TSIndexedAccessType",
+    objectType,
+    indexType
+  });
+}
+
+function tsMappedType(typeParameter, typeAnnotation = null, nameType = null) {
+  return (0, _validateNode.default)({
+    type: "TSMappedType",
+    typeParameter,
+    typeAnnotation,
+    nameType
+  });
+}
+
+function tsLiteralType(literal) {
+  return (0, _validateNode.default)({
+    type: "TSLiteralType",
+    literal
+  });
+}
+
+function tsExpressionWithTypeArguments(expression, typeParameters = null) {
+  return (0, _validateNode.default)({
+    type: "TSExpressionWithTypeArguments",
+    expression,
+    typeParameters
+  });
+}
+
+function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) {
+  return (0, _validateNode.default)({
+    type: "TSInterfaceDeclaration",
+    id,
+    typeParameters,
+    extends: _extends,
+    body
+  });
+}
+
+function tsInterfaceBody(body) {
+  return (0, _validateNode.default)({
+    type: "TSInterfaceBody",
+    body
+  });
+}
+
+function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "TSTypeAliasDeclaration",
+    id,
+    typeParameters,
+    typeAnnotation
+  });
+}
+
+function tsInstantiationExpression(expression, typeParameters = null) {
+  return (0, _validateNode.default)({
+    type: "TSInstantiationExpression",
+    expression,
+    typeParameters
+  });
+}
+
+function tsAsExpression(expression, typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "TSAsExpression",
+    expression,
+    typeAnnotation
+  });
+}
+
+function tsTypeAssertion(typeAnnotation, expression) {
+  return (0, _validateNode.default)({
+    type: "TSTypeAssertion",
+    typeAnnotation,
+    expression
+  });
+}
+
+function tsEnumDeclaration(id, members) {
+  return (0, _validateNode.default)({
+    type: "TSEnumDeclaration",
+    id,
+    members
+  });
+}
+
+function tsEnumMember(id, initializer = null) {
+  return (0, _validateNode.default)({
+    type: "TSEnumMember",
+    id,
+    initializer
+  });
+}
+
+function tsModuleDeclaration(id, body) {
+  return (0, _validateNode.default)({
+    type: "TSModuleDeclaration",
+    id,
+    body
+  });
+}
+
+function tsModuleBlock(body) {
+  return (0, _validateNode.default)({
+    type: "TSModuleBlock",
+    body
+  });
+}
+
+function tsImportType(argument, qualifier = null, typeParameters = null) {
+  return (0, _validateNode.default)({
+    type: "TSImportType",
+    argument,
+    qualifier,
+    typeParameters
+  });
+}
+
+function tsImportEqualsDeclaration(id, moduleReference) {
+  return (0, _validateNode.default)({
+    type: "TSImportEqualsDeclaration",
+    id,
+    moduleReference,
+    isExport: null
+  });
+}
+
+function tsExternalModuleReference(expression) {
+  return (0, _validateNode.default)({
+    type: "TSExternalModuleReference",
+    expression
+  });
+}
+
+function tsNonNullExpression(expression) {
+  return (0, _validateNode.default)({
+    type: "TSNonNullExpression",
+    expression
+  });
+}
+
+function tsExportAssignment(expression) {
+  return (0, _validateNode.default)({
+    type: "TSExportAssignment",
+    expression
+  });
+}
+
+function tsNamespaceExportDeclaration(id) {
+  return (0, _validateNode.default)({
+    type: "TSNamespaceExportDeclaration",
+    id
+  });
+}
+
+function tsTypeAnnotation(typeAnnotation) {
+  return (0, _validateNode.default)({
+    type: "TSTypeAnnotation",
+    typeAnnotation
+  });
+}
+
+function tsTypeParameterInstantiation(params) {
+  return (0, _validateNode.default)({
+    type: "TSTypeParameterInstantiation",
+    params
+  });
+}
+
+function tsTypeParameterDeclaration(params) {
+  return (0, _validateNode.default)({
+    type: "TSTypeParameterDeclaration",
+    params
+  });
+}
+
+function tsTypeParameter(constraint = null, _default = null, name) {
+  return (0, _validateNode.default)({
+    type: "TSTypeParameter",
+    constraint,
+    default: _default,
+    name
+  });
+}
+
+function NumberLiteral(value) {
+  console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
+  return numericLiteral(value);
+}
+
+function RegexLiteral(pattern, flags = "") {
+  console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
+  return regExpLiteral(pattern, flags);
+}
+
+function RestProperty(argument) {
+  console.trace("The node type RestProperty has been renamed to RestElement");
+  return restElement(argument);
+}
+
+function SpreadProperty(argument) {
+  console.trace("The node type SpreadProperty has been renamed to SpreadElement");
+  return spreadElement(argument);
+}
\ No newline at end of file

node_modules/@babel/types/lib/builders/generated/uppercase.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AnyTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.anyTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ArgumentPlaceholder", {
+  enumerable: true,
+  get: function () {
+    return _index.argumentPlaceholder;
+  }
+});
+Object.defineProperty(exports, "ArrayExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.arrayExpression;
+  }
+});
+Object.defineProperty(exports, "ArrayPattern", {
+  enumerable: true,
+  get: function () {
+    return _index.arrayPattern;
+  }
+});
+Object.defineProperty(exports, "ArrayTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.arrayTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ArrowFunctionExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.arrowFunctionExpression;
+  }
+});
+Object.defineProperty(exports, "AssignmentExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.assignmentExpression;
+  }
+});
+Object.defineProperty(exports, "AssignmentPattern", {
+  enumerable: true,
+  get: function () {
+    return _index.assignmentPattern;
+  }
+});
+Object.defineProperty(exports, "AwaitExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.awaitExpression;
+  }
+});
+Object.defineProperty(exports, "BigIntLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.bigIntLiteral;
+  }
+});
+Object.defineProperty(exports, "BinaryExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.binaryExpression;
+  }
+});
+Object.defineProperty(exports, "BindExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.bindExpression;
+  }
+});
+Object.defineProperty(exports, "BlockStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.blockStatement;
+  }
+});
+Object.defineProperty(exports, "BooleanLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.booleanLiteral;
+  }
+});
+Object.defineProperty(exports, "BooleanLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.booleanLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "BooleanTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.booleanTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "BreakStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.breakStatement;
+  }
+});
+Object.defineProperty(exports, "CallExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.callExpression;
+  }
+});
+Object.defineProperty(exports, "CatchClause", {
+  enumerable: true,
+  get: function () {
+    return _index.catchClause;
+  }
+});
+Object.defineProperty(exports, "ClassAccessorProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.classAccessorProperty;
+  }
+});
+Object.defineProperty(exports, "ClassBody", {
+  enumerable: true,
+  get: function () {
+    return _index.classBody;
+  }
+});
+Object.defineProperty(exports, "ClassDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.classDeclaration;
+  }
+});
+Object.defineProperty(exports, "ClassExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.classExpression;
+  }
+});
+Object.defineProperty(exports, "ClassImplements", {
+  enumerable: true,
+  get: function () {
+    return _index.classImplements;
+  }
+});
+Object.defineProperty(exports, "ClassMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.classMethod;
+  }
+});
+Object.defineProperty(exports, "ClassPrivateMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.classPrivateMethod;
+  }
+});
+Object.defineProperty(exports, "ClassPrivateProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.classPrivateProperty;
+  }
+});
+Object.defineProperty(exports, "ClassProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.classProperty;
+  }
+});
+Object.defineProperty(exports, "ConditionalExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.conditionalExpression;
+  }
+});
+Object.defineProperty(exports, "ContinueStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.continueStatement;
+  }
+});
+Object.defineProperty(exports, "DebuggerStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.debuggerStatement;
+  }
+});
+Object.defineProperty(exports, "DecimalLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.decimalLiteral;
+  }
+});
+Object.defineProperty(exports, "DeclareClass", {
+  enumerable: true,
+  get: function () {
+    return _index.declareClass;
+  }
+});
+Object.defineProperty(exports, "DeclareExportAllDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.declareExportAllDeclaration;
+  }
+});
+Object.defineProperty(exports, "DeclareExportDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.declareExportDeclaration;
+  }
+});
+Object.defineProperty(exports, "DeclareFunction", {
+  enumerable: true,
+  get: function () {
+    return _index.declareFunction;
+  }
+});
+Object.defineProperty(exports, "DeclareInterface", {
+  enumerable: true,
+  get: function () {
+    return _index.declareInterface;
+  }
+});
+Object.defineProperty(exports, "DeclareModule", {
+  enumerable: true,
+  get: function () {
+    return _index.declareModule;
+  }
+});
+Object.defineProperty(exports, "DeclareModuleExports", {
+  enumerable: true,
+  get: function () {
+    return _index.declareModuleExports;
+  }
+});
+Object.defineProperty(exports, "DeclareOpaqueType", {
+  enumerable: true,
+  get: function () {
+    return _index.declareOpaqueType;
+  }
+});
+Object.defineProperty(exports, "DeclareTypeAlias", {
+  enumerable: true,
+  get: function () {
+    return _index.declareTypeAlias;
+  }
+});
+Object.defineProperty(exports, "DeclareVariable", {
+  enumerable: true,
+  get: function () {
+    return _index.declareVariable;
+  }
+});
+Object.defineProperty(exports, "DeclaredPredicate", {
+  enumerable: true,
+  get: function () {
+    return _index.declaredPredicate;
+  }
+});
+Object.defineProperty(exports, "Decorator", {
+  enumerable: true,
+  get: function () {
+    return _index.decorator;
+  }
+});
+Object.defineProperty(exports, "Directive", {
+  enumerable: true,
+  get: function () {
+    return _index.directive;
+  }
+});
+Object.defineProperty(exports, "DirectiveLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.directiveLiteral;
+  }
+});
+Object.defineProperty(exports, "DoExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.doExpression;
+  }
+});
+Object.defineProperty(exports, "DoWhileStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.doWhileStatement;
+  }
+});
+Object.defineProperty(exports, "EmptyStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.emptyStatement;
+  }
+});
+Object.defineProperty(exports, "EmptyTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.emptyTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "EnumBooleanBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumBooleanBody;
+  }
+});
+Object.defineProperty(exports, "EnumBooleanMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumBooleanMember;
+  }
+});
+Object.defineProperty(exports, "EnumDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.enumDeclaration;
+  }
+});
+Object.defineProperty(exports, "EnumDefaultedMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumDefaultedMember;
+  }
+});
+Object.defineProperty(exports, "EnumNumberBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumNumberBody;
+  }
+});
+Object.defineProperty(exports, "EnumNumberMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumNumberMember;
+  }
+});
+Object.defineProperty(exports, "EnumStringBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumStringBody;
+  }
+});
+Object.defineProperty(exports, "EnumStringMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumStringMember;
+  }
+});
+Object.defineProperty(exports, "EnumSymbolBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumSymbolBody;
+  }
+});
+Object.defineProperty(exports, "ExistsTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.existsTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ExportAllDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.exportAllDeclaration;
+  }
+});
+Object.defineProperty(exports, "ExportDefaultDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.exportDefaultDeclaration;
+  }
+});
+Object.defineProperty(exports, "ExportDefaultSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.exportDefaultSpecifier;
+  }
+});
+Object.defineProperty(exports, "ExportNamedDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.exportNamedDeclaration;
+  }
+});
+Object.defineProperty(exports, "ExportNamespaceSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.exportNamespaceSpecifier;
+  }
+});
+Object.defineProperty(exports, "ExportSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.exportSpecifier;
+  }
+});
+Object.defineProperty(exports, "ExpressionStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.expressionStatement;
+  }
+});
+Object.defineProperty(exports, "File", {
+  enumerable: true,
+  get: function () {
+    return _index.file;
+  }
+});
+Object.defineProperty(exports, "ForInStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.forInStatement;
+  }
+});
+Object.defineProperty(exports, "ForOfStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.forOfStatement;
+  }
+});
+Object.defineProperty(exports, "ForStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.forStatement;
+  }
+});
+Object.defineProperty(exports, "FunctionDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.functionDeclaration;
+  }
+});
+Object.defineProperty(exports, "FunctionExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.functionExpression;
+  }
+});
+Object.defineProperty(exports, "FunctionTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.functionTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "FunctionTypeParam", {
+  enumerable: true,
+  get: function () {
+    return _index.functionTypeParam;
+  }
+});
+Object.defineProperty(exports, "GenericTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.genericTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "Identifier", {
+  enumerable: true,
+  get: function () {
+    return _index.identifier;
+  }
+});
+Object.defineProperty(exports, "IfStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.ifStatement;
+  }
+});
+Object.defineProperty(exports, "Import", {
+  enumerable: true,
+  get: function () {
+    return _index.import;
+  }
+});
+Object.defineProperty(exports, "ImportAttribute", {
+  enumerable: true,
+  get: function () {
+    return _index.importAttribute;
+  }
+});
+Object.defineProperty(exports, "ImportDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.importDeclaration;
+  }
+});
+Object.defineProperty(exports, "ImportDefaultSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.importDefaultSpecifier;
+  }
+});
+Object.defineProperty(exports, "ImportNamespaceSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.importNamespaceSpecifier;
+  }
+});
+Object.defineProperty(exports, "ImportSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.importSpecifier;
+  }
+});
+Object.defineProperty(exports, "IndexedAccessType", {
+  enumerable: true,
+  get: function () {
+    return _index.indexedAccessType;
+  }
+});
+Object.defineProperty(exports, "InferredPredicate", {
+  enumerable: true,
+  get: function () {
+    return _index.inferredPredicate;
+  }
+});
+Object.defineProperty(exports, "InterfaceDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.interfaceDeclaration;
+  }
+});
+Object.defineProperty(exports, "InterfaceExtends", {
+  enumerable: true,
+  get: function () {
+    return _index.interfaceExtends;
+  }
+});
+Object.defineProperty(exports, "InterfaceTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.interfaceTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "InterpreterDirective", {
+  enumerable: true,
+  get: function () {
+    return _index.interpreterDirective;
+  }
+});
+Object.defineProperty(exports, "IntersectionTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.intersectionTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "JSXAttribute", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxAttribute;
+  }
+});
+Object.defineProperty(exports, "JSXClosingElement", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxClosingElement;
+  }
+});
+Object.defineProperty(exports, "JSXClosingFragment", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxClosingFragment;
+  }
+});
+Object.defineProperty(exports, "JSXElement", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxElement;
+  }
+});
+Object.defineProperty(exports, "JSXEmptyExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxEmptyExpression;
+  }
+});
+Object.defineProperty(exports, "JSXExpressionContainer", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxExpressionContainer;
+  }
+});
+Object.defineProperty(exports, "JSXFragment", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxFragment;
+  }
+});
+Object.defineProperty(exports, "JSXIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxIdentifier;
+  }
+});
+Object.defineProperty(exports, "JSXMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxMemberExpression;
+  }
+});
+Object.defineProperty(exports, "JSXNamespacedName", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxNamespacedName;
+  }
+});
+Object.defineProperty(exports, "JSXOpeningElement", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxOpeningElement;
+  }
+});
+Object.defineProperty(exports, "JSXOpeningFragment", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxOpeningFragment;
+  }
+});
+Object.defineProperty(exports, "JSXSpreadAttribute", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxSpreadAttribute;
+  }
+});
+Object.defineProperty(exports, "JSXSpreadChild", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxSpreadChild;
+  }
+});
+Object.defineProperty(exports, "JSXText", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxText;
+  }
+});
+Object.defineProperty(exports, "LabeledStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.labeledStatement;
+  }
+});
+Object.defineProperty(exports, "LogicalExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.logicalExpression;
+  }
+});
+Object.defineProperty(exports, "MemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.memberExpression;
+  }
+});
+Object.defineProperty(exports, "MetaProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.metaProperty;
+  }
+});
+Object.defineProperty(exports, "MixedTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.mixedTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ModuleExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.moduleExpression;
+  }
+});
+Object.defineProperty(exports, "NewExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.newExpression;
+  }
+});
+Object.defineProperty(exports, "Noop", {
+  enumerable: true,
+  get: function () {
+    return _index.noop;
+  }
+});
+Object.defineProperty(exports, "NullLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.nullLiteral;
+  }
+});
+Object.defineProperty(exports, "NullLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.nullLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NullableTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.nullableTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NumberLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.numberLiteral;
+  }
+});
+Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.numberLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NumberTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.numberTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NumericLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.numericLiteral;
+  }
+});
+Object.defineProperty(exports, "ObjectExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.objectExpression;
+  }
+});
+Object.defineProperty(exports, "ObjectMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.objectMethod;
+  }
+});
+Object.defineProperty(exports, "ObjectPattern", {
+  enumerable: true,
+  get: function () {
+    return _index.objectPattern;
+  }
+});
+Object.defineProperty(exports, "ObjectProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectProperty;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeCallProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeCallProperty;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeIndexer", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeIndexer;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeInternalSlot", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeInternalSlot;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeProperty;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeSpreadProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeSpreadProperty;
+  }
+});
+Object.defineProperty(exports, "OpaqueType", {
+  enumerable: true,
+  get: function () {
+    return _index.opaqueType;
+  }
+});
+Object.defineProperty(exports, "OptionalCallExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.optionalCallExpression;
+  }
+});
+Object.defineProperty(exports, "OptionalIndexedAccessType", {
+  enumerable: true,
+  get: function () {
+    return _index.optionalIndexedAccessType;
+  }
+});
+Object.defineProperty(exports, "OptionalMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.optionalMemberExpression;
+  }
+});
+Object.defineProperty(exports, "ParenthesizedExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.parenthesizedExpression;
+  }
+});
+Object.defineProperty(exports, "PipelineBareFunction", {
+  enumerable: true,
+  get: function () {
+    return _index.pipelineBareFunction;
+  }
+});
+Object.defineProperty(exports, "PipelinePrimaryTopicReference", {
+  enumerable: true,
+  get: function () {
+    return _index.pipelinePrimaryTopicReference;
+  }
+});
+Object.defineProperty(exports, "PipelineTopicExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.pipelineTopicExpression;
+  }
+});
+Object.defineProperty(exports, "Placeholder", {
+  enumerable: true,
+  get: function () {
+    return _index.placeholder;
+  }
+});
+Object.defineProperty(exports, "PrivateName", {
+  enumerable: true,
+  get: function () {
+    return _index.privateName;
+  }
+});
+Object.defineProperty(exports, "Program", {
+  enumerable: true,
+  get: function () {
+    return _index.program;
+  }
+});
+Object.defineProperty(exports, "QualifiedTypeIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _index.qualifiedTypeIdentifier;
+  }
+});
+Object.defineProperty(exports, "RecordExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.recordExpression;
+  }
+});
+Object.defineProperty(exports, "RegExpLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.regExpLiteral;
+  }
+});
+Object.defineProperty(exports, "RegexLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.regexLiteral;
+  }
+});
+Object.defineProperty(exports, "RestElement", {
+  enumerable: true,
+  get: function () {
+    return _index.restElement;
+  }
+});
+Object.defineProperty(exports, "RestProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.restProperty;
+  }
+});
+Object.defineProperty(exports, "ReturnStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.returnStatement;
+  }
+});
+Object.defineProperty(exports, "SequenceExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.sequenceExpression;
+  }
+});
+Object.defineProperty(exports, "SpreadElement", {
+  enumerable: true,
+  get: function () {
+    return _index.spreadElement;
+  }
+});
+Object.defineProperty(exports, "SpreadProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.spreadProperty;
+  }
+});
+Object.defineProperty(exports, "StaticBlock", {
+  enumerable: true,
+  get: function () {
+    return _index.staticBlock;
+  }
+});
+Object.defineProperty(exports, "StringLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.stringLiteral;
+  }
+});
+Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.stringLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "StringTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.stringTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "Super", {
+  enumerable: true,
+  get: function () {
+    return _index.super;
+  }
+});
+Object.defineProperty(exports, "SwitchCase", {
+  enumerable: true,
+  get: function () {
+    return _index.switchCase;
+  }
+});
+Object.defineProperty(exports, "SwitchStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.switchStatement;
+  }
+});
+Object.defineProperty(exports, "SymbolTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.symbolTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "TSAnyKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsAnyKeyword;
+  }
+});
+Object.defineProperty(exports, "TSArrayType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsArrayType;
+  }
+});
+Object.defineProperty(exports, "TSAsExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tsAsExpression;
+  }
+});
+Object.defineProperty(exports, "TSBigIntKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsBigIntKeyword;
+  }
+});
+Object.defineProperty(exports, "TSBooleanKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsBooleanKeyword;
+  }
+});
+Object.defineProperty(exports, "TSCallSignatureDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsCallSignatureDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSConditionalType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsConditionalType;
+  }
+});
+Object.defineProperty(exports, "TSConstructSignatureDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsConstructSignatureDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSConstructorType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsConstructorType;
+  }
+});
+Object.defineProperty(exports, "TSDeclareFunction", {
+  enumerable: true,
+  get: function () {
+    return _index.tsDeclareFunction;
+  }
+});
+Object.defineProperty(exports, "TSDeclareMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.tsDeclareMethod;
+  }
+});
+Object.defineProperty(exports, "TSEnumDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsEnumDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSEnumMember", {
+  enumerable: true,
+  get: function () {
+    return _index.tsEnumMember;
+  }
+});
+Object.defineProperty(exports, "TSExportAssignment", {
+  enumerable: true,
+  get: function () {
+    return _index.tsExportAssignment;
+  }
+});
+Object.defineProperty(exports, "TSExpressionWithTypeArguments", {
+  enumerable: true,
+  get: function () {
+    return _index.tsExpressionWithTypeArguments;
+  }
+});
+Object.defineProperty(exports, "TSExternalModuleReference", {
+  enumerable: true,
+  get: function () {
+    return _index.tsExternalModuleReference;
+  }
+});
+Object.defineProperty(exports, "TSFunctionType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsFunctionType;
+  }
+});
+Object.defineProperty(exports, "TSImportEqualsDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsImportEqualsDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSImportType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsImportType;
+  }
+});
+Object.defineProperty(exports, "TSIndexSignature", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIndexSignature;
+  }
+});
+Object.defineProperty(exports, "TSIndexedAccessType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIndexedAccessType;
+  }
+});
+Object.defineProperty(exports, "TSInferType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInferType;
+  }
+});
+Object.defineProperty(exports, "TSInstantiationExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInstantiationExpression;
+  }
+});
+Object.defineProperty(exports, "TSInterfaceBody", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInterfaceBody;
+  }
+});
+Object.defineProperty(exports, "TSInterfaceDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInterfaceDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSIntersectionType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIntersectionType;
+  }
+});
+Object.defineProperty(exports, "TSIntrinsicKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIntrinsicKeyword;
+  }
+});
+Object.defineProperty(exports, "TSLiteralType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsLiteralType;
+  }
+});
+Object.defineProperty(exports, "TSMappedType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsMappedType;
+  }
+});
+Object.defineProperty(exports, "TSMethodSignature", {
+  enumerable: true,
+  get: function () {
+    return _index.tsMethodSignature;
+  }
+});
+Object.defineProperty(exports, "TSModuleBlock", {
+  enumerable: true,
+  get: function () {
+    return _index.tsModuleBlock;
+  }
+});
+Object.defineProperty(exports, "TSModuleDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsModuleDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSNamedTupleMember", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNamedTupleMember;
+  }
+});
+Object.defineProperty(exports, "TSNamespaceExportDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNamespaceExportDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSNeverKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNeverKeyword;
+  }
+});
+Object.defineProperty(exports, "TSNonNullExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNonNullExpression;
+  }
+});
+Object.defineProperty(exports, "TSNullKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNullKeyword;
+  }
+});
+Object.defineProperty(exports, "TSNumberKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNumberKeyword;
+  }
+});
+Object.defineProperty(exports, "TSObjectKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsObjectKeyword;
+  }
+});
+Object.defineProperty(exports, "TSOptionalType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsOptionalType;
+  }
+});
+Object.defineProperty(exports, "TSParameterProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.tsParameterProperty;
+  }
+});
+Object.defineProperty(exports, "TSParenthesizedType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsParenthesizedType;
+  }
+});
+Object.defineProperty(exports, "TSPropertySignature", {
+  enumerable: true,
+  get: function () {
+    return _index.tsPropertySignature;
+  }
+});
+Object.defineProperty(exports, "TSQualifiedName", {
+  enumerable: true,
+  get: function () {
+    return _index.tsQualifiedName;
+  }
+});
+Object.defineProperty(exports, "TSRestType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsRestType;
+  }
+});
+Object.defineProperty(exports, "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");
\ No newline at end of file

node_modules/@babel/types/lib/builders/react/buildChildren.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildChildren;
+
+var _generated = require("../../validators/generated");
+
+var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild");
+
+function buildChildren(node) {
+  const elements = [];
+
+  for (let i = 0; i < node.children.length; i++) {
+    let child = node.children[i];
+
+    if ((0, _generated.isJSXText)(child)) {
+      (0, _cleanJSXElementLiteralChild.default)(child, elements);
+      continue;
+    }
+
+    if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression;
+    if ((0, _generated.isJSXEmptyExpression)(child)) continue;
+    elements.push(child);
+  }
+
+  return elements;
+}
\ No newline at end of file

node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createTSUnionType;
+
+var _generated = require("../generated");
+
+var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates");
+
+function createTSUnionType(typeAnnotations) {
+  const types = typeAnnotations.map(type => type.typeAnnotation);
+  const flattened = (0, _removeTypeDuplicates.default)(types);
+
+  if (flattened.length === 1) {
+    return flattened[0];
+  } else {
+    return (0, _generated.tsUnionType)(flattened);
+  }
+}
\ No newline at end of file

node_modules/@babel/types/lib/builders/validateNode.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = validateNode;
+
+var _validate = require("../validators/validate");
+
+var _ = require("..");
+
+function validateNode(node) {
+  const keys = _.BUILDER_KEYS[node.type];
+
+  for (const key of keys) {
+    (0, _validate.default)(node, key, node[key]);
+  }
+
+  return node;
+}
\ No newline at end of file

node_modules/@babel/types/lib/clone/clone.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = clone;
+
+var _cloneNode = require("./cloneNode");
+
+function clone(node) {
+  return (0, _cloneNode.default)(node, false);
+}
\ No newline at end of file

node_modules/@babel/types/lib/clone/cloneDeep.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneDeep;
+
+var _cloneNode = require("./cloneNode");
+
+function cloneDeep(node) {
+  return (0, _cloneNode.default)(node);
+}
\ No newline at end of file

node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js

+"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);
+}
\ No newline at end of file

node_modules/@babel/types/lib/clone/cloneNode.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneNode;
+
+var _definitions = require("../definitions");
+
+var _generated = require("../validators/generated");
+
+const has = Function.call.bind(Object.prototype.hasOwnProperty);
+
+function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
+  if (obj && typeof obj.type === "string") {
+    return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);
+  }
+
+  return obj;
+}
+
+function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) {
+  if (Array.isArray(obj)) {
+    return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache));
+  }
+
+  return cloneIfNode(obj, deep, withoutLoc, commentsCache);
+}
+
+function cloneNode(node, deep = true, withoutLoc = false) {
+  return cloneNodeInternal(node, deep, withoutLoc, new Map());
+}
+
+function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) {
+  if (!node) return node;
+  const {
+    type
+  } = node;
+  const newNode = {
+    type: node.type
+  };
+
+  if ((0, _generated.isIdentifier)(node)) {
+    newNode.name = node.name;
+
+    if (has(node, "optional") && typeof node.optional === "boolean") {
+      newNode.optional = node.optional;
+    }
+
+    if (has(node, "typeAnnotation")) {
+      newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation;
+    }
+  } else if (!has(_definitions.NODE_FIELDS, type)) {
+    throw new Error(`Unknown node type: "${type}"`);
+  } else {
+    for (const field of Object.keys(_definitions.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);
+        } else {
+          newNode[field] = node[field];
+        }
+      }
+    }
+  }
+
+  if (has(node, "loc")) {
+    if (withoutLoc) {
+      newNode.loc = null;
+    } else {
+      newNode.loc = node.loc;
+    }
+  }
+
+  if (has(node, "leadingComments")) {
+    newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache);
+  }
+
+  if (has(node, "innerComments")) {
+    newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache);
+  }
+
+  if (has(node, "trailingComments")) {
+    newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache);
+  }
+
+  if (has(node, "extra")) {
+    newNode.extra = Object.assign({}, node.extra);
+  }
+
+  return newNode;
+}
+
+function maybeCloneComments(comments, deep, withoutLoc, commentsCache) {
+  if (!comments || !deep) {
+    return comments;
+  }
+
+  return comments.map(comment => {
+    const cache = commentsCache.get(comment);
+    if (cache) return cache;
+    const {
+      type,
+      value,
+      loc
+    } = comment;
+    const ret = {
+      type,
+      value,
+      loc
+    };
+
+    if (withoutLoc) {
+      ret.loc = null;
+    }
+
+    commentsCache.set(comment, ret);
+    return ret;
+  });
+}
\ No newline at end of file

node_modules/@babel/types/lib/clone/cloneWithoutLoc.js

+"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);
+}
\ No newline at end of file

node_modules/@babel/types/lib/comments/addComment.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addComment;
+
+var _addComments = require("./addComments");
+
+function addComment(node, type, content, line) {
+  return (0, _addComments.default)(node, type, [{
+    type: line ? "CommentLine" : "CommentBlock",
+    value: content
+  }]);
+}
\ No newline at end of file

node_modules/@babel/types/lib/comments/addComments.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addComments;
+
+function addComments(node, type, comments) {
+  if (!comments || !node) return node;
+  const key = `${type}Comments`;
+
+  if (node[key]) {
+    if (type === "leading") {
+      node[key] = comments.concat(node[key]);
+    } else {
+      node[key].push(...comments);
+    }
+  } else {
+    node[key] = comments;
+  }
+
+  return node;
+}
\ No newline at end of file

node_modules/@babel/types/lib/comments/inheritInnerComments.js

+"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);
+}
\ No newline at end of file

node_modules/@babel/types/lib/comments/inheritLeadingComments.js

+"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);
+}
\ No newline at end of file

node_modules/@babel/types/lib/comments/inheritTrailingComments.js

+"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);
+}
\ No newline at end of file

node_modules/@babel/types/lib/comments/inheritsComments.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritsComments;
+
+var _inheritTrailingComments = require("./inheritTrailingComments");
+
+var _inheritLeadingComments = require("./inheritLeadingComments");
+
+var _inheritInnerComments = require("./inheritInnerComments");
+
+function inheritsComments(child, parent) {
+  (0, _inheritTrailingComments.default)(child, parent);
+  (0, _inheritLeadingComments.default)(child, parent);
+  (0, _inheritInnerComments.default)(child, parent);
+  return child;
+}
\ No newline at end of file

node_modules/@babel/types/lib/comments/removeComments.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeComments;
+
+var _constants = require("../constants");
+
+function removeComments(node) {
+  _constants.COMMENT_KEYS.forEach(key => {
+    node[key] = null;
+  });
+
+  return node;
+}
\ No newline at end of file

node_modules/@babel/types/lib/constants/generated/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.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 MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"];
+exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_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;
\ No newline at end of file

node_modules/@babel/types/lib/constants/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UPDATE_OPERATORS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.STATEMENT_OR_BLOCK_KEYS = exports.NUMBER_UNARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.NOT_LOCAL_BINDING = exports.LOGICAL_OPERATORS = exports.INHERIT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.EQUALITY_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.COMMENT_KEYS = exports.BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.BLOCK_SCOPED_SYMBOL = exports.BINARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = void 0;
+const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
+exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS;
+const FLATTENABLE_KEYS = ["body", "expressions"];
+exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS;
+const FOR_INIT_KEYS = ["left", "init"];
+exports.FOR_INIT_KEYS = FOR_INIT_KEYS;
+const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
+exports.COMMENT_KEYS = COMMENT_KEYS;
+const LOGICAL_OPERATORS = ["||", "&&", "??"];
+exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS;
+const UPDATE_OPERATORS = ["++", "--"];
+exports.UPDATE_OPERATORS = UPDATE_OPERATORS;
+const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
+exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS;
+const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
+exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS;
+const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
+exports.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS;
+const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
+exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS;
+const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS;
+const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"];
+exports.BINARY_OPERATORS = BINARY_OPERATORS;
+const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")];
+exports.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS;
+const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
+exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS;
+const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
+exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS;
+const STRING_UNARY_OPERATORS = ["typeof"];
+exports.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS;
+const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
+exports.UNARY_OPERATORS = UNARY_OPERATORS;
+const INHERIT_KEYS = {
+  optional: ["typeAnnotation", "typeParameters", "returnType"],
+  force: ["start", "loc", "end"]
+};
+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;
\ No newline at end of file

node_modules/@babel/types/lib/converters/ensureBlock.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = ensureBlock;
+
+var _toBlock = require("./toBlock");
+
+function ensureBlock(node, key = "body") {
+  const result = (0, _toBlock.default)(node[key], node);
+  node[key] = result;
+  return result;
+}
\ No newline at end of file