@putout/babel
Version:
Babel 8 bundled
1,096 lines (1,008 loc) • 1.37 MB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return (mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
exports: {},
}).exports, mod), mod.exports);
};
var __export = (target, all) => {
for (var name in all) __defProp(target, name, {
get: all[name],
enumerable: true,
});
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === 'object' || typeof from === 'function') {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, {
get: () => from[key],
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
});
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, 'default', {
value: mod,
enumerable: true,
}) : target, mod));
// node_modules/jsesc/jsesc.js
var require_jsesc = __commonJS({
'node_modules/jsesc/jsesc.js'(exports, module) {
"use strict";
var object = {};
var hasOwnProperty = object.hasOwnProperty;
var forOwn = (object2, callback) => {
for (const key in object2) {
if (hasOwnProperty.call(object2, key)) {
callback(key, object2[key]);
}
}
};
var extend = (destination, source) => {
if (!source) {
return destination;
}
forOwn(source, (key, value) => {
destination[key] = value;
});
return destination;
};
var forEach = (array, callback) => {
const length = array.length;
let index3 = -1;
while (++index3 < length) {
callback(array[index3]);
}
};
var fourHexEscape = (hex) => {
return '\\u' + ('0000' + hex).slice(-4);
};
var hexadecimal = (code2, lowercase) => {
let hexadecimal2 = code2.toString(16);
if (lowercase)
return hexadecimal2;
return hexadecimal2.toUpperCase();
};
var toString = object.toString;
var isArray = Array.isArray;
var isBuffer = (value) => {
return typeof Buffer === 'function' && Buffer.isBuffer(value);
};
var isObject = (value) => {
return toString.call(value) == '[object Object]';
};
var isString = (value) => {
return typeof value == 'string' || toString.call(value) == '[object String]';
};
var isNumber2 = (value) => {
return typeof value == 'number' || toString.call(value) == '[object Number]';
};
var isBigInt = (value) => {
return typeof value == 'bigint';
};
var isFunction5 = (value) => {
return typeof value == 'function';
};
var isMap = (value) => {
return toString.call(value) == '[object Map]';
};
var isSet = (value) => {
return toString.call(value) == '[object Set]';
};
var singleEscapes = {
'\\': '\\\\',
'\b': '\\b',
'\f': '\\f',
'\n': '\\n',
'\r': '\\r',
' ': '\\t',
// `\v` is omitted intentionally, because in IE < 9, '\v' == 'v'.
// '\v': '\\x0B'
};
var regexSingleEscape = /[\\\b\f\n\r\t]/;
var regexDigit = /[0-9]/;
var regexWhitespace = /[\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;
var escapeEverythingRegex = /([\uD800-\uDBFF][\uDC00-\uDFFF])|([\uD800-\uDFFF])|(['"`])|[^]/g;
var escapeNonAsciiRegex = /([\uD800-\uDBFF][\uDC00-\uDFFF])|([\uD800-\uDFFF])|(['"`])|[^ !#-&\(-\[\]-_a-~]/g;
var jsesc2 = (argument, options) => {
const increaseIndentation = () => {
oldIndent = indent;
++options.indentLevel;
indent = options.indent.repeat(options.indentLevel);
};
const defaults = {
'escapeEverything': false,
'minimal': false,
'isScriptContext': false,
'quotes': 'single',
'wrap': false,
'es6': false,
'json': false,
'compact': true,
'lowercaseHex': false,
'numbers': 'decimal',
'indent': ' ',
'indentLevel': 0,
'__inline1__': false,
'__inline2__': false,
};
const json = options && options.json;
if (json) {
defaults.quotes = 'double';
defaults.wrap = true;
}
options = extend(defaults, options);
if (options.quotes != 'single' && options.quotes != 'double' && options.quotes != 'backtick') {
options.quotes = 'single';
}
const quote = options.quotes == 'double' ? '"' : options.quotes == 'backtick' ? '`' : '\'';
const compact = options.compact;
const lowercaseHex = options.lowercaseHex;
let indent = options.indent.repeat(options.indentLevel);
let oldIndent = '';
const inline1 = options.__inline1__;
const inline2 = options.__inline2__;
const newLine = compact ? '' : '\n';
let result;
let isEmpty = true;
const useBinNumbers = options.numbers == 'binary';
const useOctNumbers = options.numbers == 'octal';
const useDecNumbers = options.numbers == 'decimal';
const useHexNumbers = options.numbers == 'hexadecimal';
if (json && argument && isFunction5(argument.toJSON)) {
argument = argument.toJSON();
}
if (!isString(argument)) {
if (isMap(argument)) {
if (argument.size == 0) {
return 'new Map()';
}
if (!compact) {
options.__inline1__ = true;
options.__inline2__ = false;
}
return 'new Map(' + jsesc2(Array.from(argument), options) + ')';
}
if (isSet(argument)) {
if (argument.size == 0) {
return 'new Set()';
}
return 'new Set(' + jsesc2(Array.from(argument), options) + ')';
}
if (isBuffer(argument)) {
if (argument.length == 0) {
return 'Buffer.from([])';
}
return 'Buffer.from(' + jsesc2(Array.from(argument), options) + ')';
}
if (isArray(argument)) {
result = [];
options.wrap = true;
if (inline1) {
options.__inline1__ = false;
options.__inline2__ = true;
}
if (!inline2) {
increaseIndentation();
}
forEach(argument, (value) => {
isEmpty = false;
if (inline2) {
options.__inline2__ = false;
}
result.push((compact || inline2 ? '' : indent) + jsesc2(value, options));
});
if (isEmpty) {
return '[]';
}
if (inline2) {
return '[' + result.join(', ') + ']';
}
return '[' + newLine + result.join(',' + newLine) + newLine + (compact ? '' : oldIndent) + ']';
} else if (isNumber2(argument) || isBigInt(argument)) {
if (json) {
return JSON.stringify(Number(argument));
}
let result2;
if (useDecNumbers) {
result2 = String(argument);
} else if (useHexNumbers) {
let hexadecimal2 = argument.toString(16);
if (!lowercaseHex) {
hexadecimal2 = hexadecimal2.toUpperCase();
}
result2 = '0x' + hexadecimal2;
} else if (useBinNumbers) {
result2 = '0b' + argument.toString(2);
} else if (useOctNumbers) {
result2 = '0o' + argument.toString(8);
}
if (isBigInt(argument)) {
return result2 + 'n';
}
return result2;
} else if (isBigInt(argument)) {
if (json) {
return JSON.stringify(Number(argument));
}
return argument + 'n';
} else if (!isObject(argument)) {
if (json) {
return JSON.stringify(argument) || 'null';
}
return String(argument);
} else {
result = [];
options.wrap = true;
increaseIndentation();
forOwn(argument, (key, value) => {
isEmpty = false;
result.push((compact ? '' : indent) + jsesc2(key, options) + ':' + (compact ? '' : ' ') + jsesc2(value, options));
});
if (isEmpty) {
return '{}';
}
return '{' + newLine + result.join(',' + newLine) + newLine + (compact ? '' : oldIndent) + '}';
}
}
const regex = options.escapeEverything ? escapeEverythingRegex : escapeNonAsciiRegex;
result = argument.replace(regex, (char, pair, lone, quoteChar, index3, string) => {
if (pair) {
if (options.minimal)
return pair;
const first = pair.charCodeAt(0);
const second = pair.charCodeAt(1);
if (options.es6) {
const codePoint = (first - 55296) * 1024 + second - 56320 + 65536;
const hex2 = hexadecimal(codePoint, lowercaseHex);
return '\\u{' + hex2 + '}';
}
return fourHexEscape(hexadecimal(
first,
lowercaseHex,
)) + fourHexEscape(hexadecimal(
second,
lowercaseHex,
));
}
if (lone) {
return fourHexEscape(hexadecimal(
lone.charCodeAt(0),
lowercaseHex,
));
}
if (char == '\0' && !json && !regexDigit.test(string.charAt(index3 + 1))) {
return '\\0';
}
if (quoteChar) {
if (quoteChar == quote || options.escapeEverything) {
return '\\' + quoteChar;
}
return quoteChar;
}
if (regexSingleEscape.test(char)) {
return singleEscapes[char];
}
if (options.minimal && !regexWhitespace.test(char)) {
return char;
}
const hex = hexadecimal(char.charCodeAt(0), lowercaseHex);
if (json || hex.length > 2) {
return fourHexEscape(hex);
}
return '\\x' + ('00' + hex).slice(-2);
});
if (quote == '`') {
result = result.replace(/\$\{/g, '\\${');
}
if (options.isScriptContext) {
result = result
.replace(/<\/(script|style)/gi, '<\\/$1')
.replace(/<!--/g, json ? '\\u003C!--' : '\\x3C!--');
}
if (options.wrap) {
result = quote + result + quote;
}
return result;
};
jsesc2.version = '3.0.2';
module.exports = jsesc2;
},
});
// node_modules/@babel/types/lib/index.js
var lib_exports = {};
__export(lib_exports, {
ACCESSOR_TYPES: () => ACCESSOR_TYPES,
ALIAS_KEYS: () => ALIAS_KEYS,
ASSIGNMENT_OPERATORS: () => ASSIGNMENT_OPERATORS,
AnyTypeAnnotation: () => AnyTypeAnnotation,
ArgumentPlaceholder: () => ArgumentPlaceholder,
ArrayExpression: () => ArrayExpression,
ArrayPattern: () => ArrayPattern,
ArrayTypeAnnotation: () => ArrayTypeAnnotation,
ArrowFunctionExpression: () => ArrowFunctionExpression,
AssignmentExpression: () => AssignmentExpression,
AssignmentPattern: () => AssignmentPattern,
AwaitExpression: () => AwaitExpression,
BINARY_OPERATORS: () => BINARY_OPERATORS,
BINARY_TYPES: () => BINARY_TYPES,
BLOCKPARENT_TYPES: () => BLOCKPARENT_TYPES,
BLOCK_TYPES: () => BLOCK_TYPES,
BOOLEAN_BINARY_OPERATORS: () => BOOLEAN_BINARY_OPERATORS,
BOOLEAN_NUMBER_BINARY_OPERATORS: () => BOOLEAN_NUMBER_BINARY_OPERATORS,
BOOLEAN_UNARY_OPERATORS: () => BOOLEAN_UNARY_OPERATORS,
BUILDER_KEYS: () => BUILDER_KEYS,
BigIntLiteral: () => BigIntLiteral,
BigIntLiteralTypeAnnotation: () => BigIntLiteralTypeAnnotation,
BinaryExpression: () => BinaryExpression,
BindExpression: () => BindExpression,
BlockStatement: () => BlockStatement,
BooleanLiteral: () => BooleanLiteral,
BooleanLiteralTypeAnnotation: () => BooleanLiteralTypeAnnotation,
BooleanTypeAnnotation: () => BooleanTypeAnnotation,
BreakStatement: () => BreakStatement,
CLASS_TYPES: () => CLASS_TYPES,
COMMENT_KEYS: () => COMMENT_KEYS,
COMPARISON_BINARY_OPERATORS: () => COMPARISON_BINARY_OPERATORS,
COMPLETIONSTATEMENT_TYPES: () => COMPLETIONSTATEMENT_TYPES,
CONDITIONAL_TYPES: () => CONDITIONAL_TYPES,
CallExpression: () => CallExpression,
CatchClause: () => CatchClause,
ClassAccessorProperty: () => ClassAccessorProperty,
ClassBody: () => ClassBody,
ClassDeclaration: () => ClassDeclaration,
ClassExpression: () => ClassExpression,
ClassImplements: () => ClassImplements,
ClassMethod: () => ClassMethod,
ClassPrivateMethod: () => ClassPrivateMethod,
ClassPrivateProperty: () => ClassPrivateProperty,
ClassProperty: () => ClassProperty,
ConditionalExpression: () => ConditionalExpression,
ContinueStatement: () => ContinueStatement,
DECLARATION_TYPES: () => DECLARATION_TYPES,
DEPRECATED_ALIASES: () => DEPRECATED_ALIASES,
DEPRECATED_KEYS: () => DEPRECATED_KEYS,
DebuggerStatement: () => DebuggerStatement,
DeclareClass: () => DeclareClass,
DeclareExportAllDeclaration: () => DeclareExportAllDeclaration,
DeclareExportDeclaration: () => DeclareExportDeclaration,
DeclareFunction: () => DeclareFunction,
DeclareInterface: () => DeclareInterface,
DeclareModule: () => DeclareModule,
DeclareModuleExports: () => DeclareModuleExports,
DeclareOpaqueType: () => DeclareOpaqueType,
DeclareTypeAlias: () => DeclareTypeAlias,
DeclareVariable: () => DeclareVariable,
DeclaredPredicate: () => DeclaredPredicate,
Decorator: () => Decorator,
Directive: () => Directive,
DirectiveLiteral: () => DirectiveLiteral,
DoExpression: () => DoExpression,
DoWhileStatement: () => DoWhileStatement,
ENUMBODY_TYPES: () => ENUMBODY_TYPES,
ENUMMEMBER_TYPES: () => ENUMMEMBER_TYPES,
EQUALITY_BINARY_OPERATORS: () => EQUALITY_BINARY_OPERATORS,
EXPORTDECLARATION_TYPES: () => EXPORTDECLARATION_TYPES,
EXPRESSIONWRAPPER_TYPES: () => EXPRESSIONWRAPPER_TYPES,
EXPRESSION_TYPES: () => EXPRESSION_TYPES,
EmptyStatement: () => EmptyStatement,
EmptyTypeAnnotation: () => EmptyTypeAnnotation,
EnumBooleanBody: () => EnumBooleanBody,
EnumBooleanMember: () => EnumBooleanMember,
EnumDeclaration: () => EnumDeclaration,
EnumDefaultedMember: () => EnumDefaultedMember,
EnumNumberBody: () => EnumNumberBody,
EnumNumberMember: () => EnumNumberMember,
EnumStringBody: () => EnumStringBody,
EnumStringMember: () => EnumStringMember,
EnumSymbolBody: () => EnumSymbolBody,
ExistsTypeAnnotation: () => ExistsTypeAnnotation,
ExportAllDeclaration: () => ExportAllDeclaration,
ExportDefaultDeclaration: () => ExportDefaultDeclaration,
ExportDefaultSpecifier: () => ExportDefaultSpecifier,
ExportNamedDeclaration: () => ExportNamedDeclaration,
ExportNamespaceSpecifier: () => ExportNamespaceSpecifier,
ExportSpecifier: () => ExportSpecifier,
ExpressionStatement: () => ExpressionStatement,
FLATTENABLE_KEYS: () => FLATTENABLE_KEYS,
FLIPPED_ALIAS_KEYS: () => FLIPPED_ALIAS_KEYS,
FLOWBASEANNOTATION_TYPES: () => FLOWBASEANNOTATION_TYPES,
FLOWDECLARATION_TYPES: () => FLOWDECLARATION_TYPES,
FLOWPREDICATE_TYPES: () => FLOWPREDICATE_TYPES,
FLOWTYPE_TYPES: () => FLOWTYPE_TYPES,
FLOW_TYPES: () => FLOW_TYPES,
FORXSTATEMENT_TYPES: () => FORXSTATEMENT_TYPES,
FOR_INIT_KEYS: () => FOR_INIT_KEYS,
FOR_TYPES: () => FOR_TYPES,
FUNCTIONPARAMETER_TYPES: () => FUNCTIONPARAMETER_TYPES,
FUNCTIONPARENT_TYPES: () => FUNCTIONPARENT_TYPES,
FUNCTION_TYPES: () => FUNCTION_TYPES,
File: () => File,
ForInStatement: () => ForInStatement,
ForOfStatement: () => ForOfStatement,
ForStatement: () => ForStatement,
FunctionDeclaration: () => FunctionDeclaration,
FunctionExpression: () => FunctionExpression,
FunctionTypeAnnotation: () => FunctionTypeAnnotation,
FunctionTypeParam: () => FunctionTypeParam,
GenericTypeAnnotation: () => GenericTypeAnnotation,
IMMUTABLE_TYPES: () => IMMUTABLE_TYPES,
IMPORTOREXPORTDECLARATION_TYPES: () => IMPORTOREXPORTDECLARATION_TYPES,
INHERIT_KEYS: () => INHERIT_KEYS,
Identifier: () => Identifier,
IfStatement: () => IfStatement,
Import: () => Import,
ImportAttribute: () => ImportAttribute,
ImportDeclaration: () => ImportDeclaration,
ImportDefaultSpecifier: () => ImportDefaultSpecifier,
ImportExpression: () => ImportExpression,
ImportNamespaceSpecifier: () => ImportNamespaceSpecifier,
ImportSpecifier: () => ImportSpecifier,
IndexedAccessType: () => IndexedAccessType,
InferredPredicate: () => InferredPredicate,
InterfaceDeclaration: () => InterfaceDeclaration,
InterfaceExtends: () => InterfaceExtends,
InterfaceTypeAnnotation: () => InterfaceTypeAnnotation,
InterpreterDirective: () => InterpreterDirective,
IntersectionTypeAnnotation: () => IntersectionTypeAnnotation,
JSXAttribute: () => JSXAttribute,
JSXClosingElement: () => JSXClosingElement,
JSXClosingFragment: () => JSXClosingFragment,
JSXElement: () => JSXElement,
JSXEmptyExpression: () => JSXEmptyExpression,
JSXExpressionContainer: () => JSXExpressionContainer,
JSXFragment: () => JSXFragment,
JSXIdentifier: () => JSXIdentifier,
JSXMemberExpression: () => JSXMemberExpression,
JSXNamespacedName: () => JSXNamespacedName,
JSXOpeningElement: () => JSXOpeningElement,
JSXOpeningFragment: () => JSXOpeningFragment,
JSXSpreadAttribute: () => JSXSpreadAttribute,
JSXSpreadChild: () => JSXSpreadChild,
JSXText: () => JSXText,
JSX_TYPES: () => JSX_TYPES,
LITERAL_TYPES: () => LITERAL_TYPES,
LOGICAL_OPERATORS: () => LOGICAL_OPERATORS,
LOOP_TYPES: () => LOOP_TYPES,
LVAL_TYPES: () => LVAL_TYPES,
LabeledStatement: () => LabeledStatement,
LogicalExpression: () => LogicalExpression,
METHOD_TYPES: () => METHOD_TYPES,
MISCELLANEOUS_TYPES: () => MISCELLANEOUS_TYPES,
MODULEDECLARATION_TYPES: () => MODULEDECLARATION_TYPES,
MODULESPECIFIER_TYPES: () => MODULESPECIFIER_TYPES,
MemberExpression: () => MemberExpression,
MetaProperty: () => MetaProperty,
MixedTypeAnnotation: () => MixedTypeAnnotation,
ModuleExpression: () => ModuleExpression,
NODE_FIELDS: () => NODE_FIELDS$1,
NODE_PARENT_VALIDATIONS: () => NODE_PARENT_VALIDATIONS,
NODE_UNION_SHAPES__PRIVATE: () => NODE_UNION_SHAPES__PRIVATE,
NUMBER_BINARY_OPERATORS: () => NUMBER_BINARY_OPERATORS,
NUMBER_UNARY_OPERATORS: () => NUMBER_UNARY_OPERATORS,
NewExpression: () => NewExpression,
NullLiteral: () => NullLiteral,
NullLiteralTypeAnnotation: () => NullLiteralTypeAnnotation,
NullableTypeAnnotation: () => NullableTypeAnnotation,
NumberLiteralTypeAnnotation: () => NumberLiteralTypeAnnotation,
NumberTypeAnnotation: () => NumberTypeAnnotation,
NumericLiteral: () => NumericLiteral,
OBJECTMEMBER_TYPES: () => OBJECTMEMBER_TYPES,
ObjectExpression: () => ObjectExpression,
ObjectMethod: () => ObjectMethod,
ObjectPattern: () => ObjectPattern,
ObjectProperty: () => ObjectProperty,
ObjectTypeAnnotation: () => ObjectTypeAnnotation,
ObjectTypeCallProperty: () => ObjectTypeCallProperty,
ObjectTypeIndexer: () => ObjectTypeIndexer,
ObjectTypeInternalSlot: () => ObjectTypeInternalSlot,
ObjectTypeProperty: () => ObjectTypeProperty,
ObjectTypeSpreadProperty: () => ObjectTypeSpreadProperty,
OpaqueType: () => OpaqueType,
OptionalCallExpression: () => OptionalCallExpression,
OptionalIndexedAccessType: () => OptionalIndexedAccessType,
OptionalMemberExpression: () => OptionalMemberExpression,
PATTERNLIKE_TYPES: () => PATTERNLIKE_TYPES,
PATTERN_TYPES: () => PATTERN_TYPES,
PLACEHOLDERS: () => PLACEHOLDERS,
PLACEHOLDERS_ALIAS: () => PLACEHOLDERS_ALIAS,
PLACEHOLDERS_FLIPPED_ALIAS: () => PLACEHOLDERS_FLIPPED_ALIAS,
PRIVATE_TYPES: () => PRIVATE_TYPES,
PROPERTY_TYPES: () => PROPERTY_TYPES,
PUREISH_TYPES: () => PUREISH_TYPES,
ParenthesizedExpression: () => ParenthesizedExpression,
Placeholder: () => Placeholder,
PrivateName: () => PrivateName,
Program: () => Program,
QualifiedTypeIdentifier: () => QualifiedTypeIdentifier,
RegExpLiteral: () => RegExpLiteral,
RestElement: () => RestElement,
ReturnStatement: () => ReturnStatement,
SCOPABLE_TYPES: () => SCOPABLE_TYPES,
STANDARDIZED_TYPES: () => STANDARDIZED_TYPES,
STATEMENT_OR_BLOCK_KEYS: () => STATEMENT_OR_BLOCK_KEYS,
STATEMENT_TYPES: () => STATEMENT_TYPES,
STRING_UNARY_OPERATORS: () => STRING_UNARY_OPERATORS,
SequenceExpression: () => SequenceExpression,
SpreadElement: () => SpreadElement,
StaticBlock: () => StaticBlock,
StringLiteral: () => StringLiteral,
StringLiteralTypeAnnotation: () => StringLiteralTypeAnnotation,
StringTypeAnnotation: () => StringTypeAnnotation,
Super: () => Super,
SwitchCase: () => SwitchCase,
SwitchStatement: () => SwitchStatement,
SymbolTypeAnnotation: () => SymbolTypeAnnotation,
TERMINATORLESS_TYPES: () => TERMINATORLESS_TYPES,
TSAnyKeyword: () => TSAnyKeyword,
TSArrayType: () => TSArrayType,
TSAsExpression: () => TSAsExpression,
TSBASETYPE_TYPES: () => TSBASETYPE_TYPES,
TSBigIntKeyword: () => TSBigIntKeyword,
TSBooleanKeyword: () => TSBooleanKeyword,
TSCallSignatureDeclaration: () => TSCallSignatureDeclaration,
TSClassImplements: () => TSClassImplements,
TSConditionalType: () => TSConditionalType,
TSConstructSignatureDeclaration: () => TSConstructSignatureDeclaration,
TSConstructorType: () => TSConstructorType,
TSDeclareFunction: () => TSDeclareFunction,
TSDeclareMethod: () => TSDeclareMethod,
TSENTITYNAME_TYPES: () => TSENTITYNAME_TYPES,
TSEnumBody: () => TSEnumBody,
TSEnumDeclaration: () => TSEnumDeclaration,
TSEnumMember: () => TSEnumMember,
TSExportAssignment: () => TSExportAssignment,
TSExternalModuleReference: () => TSExternalModuleReference,
TSFunctionType: () => TSFunctionType,
TSImportEqualsDeclaration: () => TSImportEqualsDeclaration,
TSImportType: () => TSImportType,
TSIndexSignature: () => TSIndexSignature,
TSIndexedAccessType: () => TSIndexedAccessType,
TSInferType: () => TSInferType,
TSInstantiationExpression: () => TSInstantiationExpression,
TSInterfaceBody: () => TSInterfaceBody,
TSInterfaceDeclaration: () => TSInterfaceDeclaration,
TSInterfaceHeritage: () => TSInterfaceHeritage,
TSIntersectionType: () => TSIntersectionType,
TSIntrinsicKeyword: () => TSIntrinsicKeyword,
TSLiteralType: () => TSLiteralType,
TSMappedType: () => TSMappedType,
TSMethodSignature: () => TSMethodSignature,
TSModuleBlock: () => TSModuleBlock,
TSModuleDeclaration: () => TSModuleDeclaration,
TSNamedTupleMember: () => TSNamedTupleMember,
TSNamespaceExportDeclaration: () => TSNamespaceExportDeclaration,
TSNeverKeyword: () => TSNeverKeyword,
TSNonNullExpression: () => TSNonNullExpression,
TSNullKeyword: () => TSNullKeyword,
TSNumberKeyword: () => TSNumberKeyword,
TSObjectKeyword: () => TSObjectKeyword,
TSOptionalType: () => TSOptionalType,
TSParameterProperty: () => TSParameterProperty,
TSParenthesizedType: () => TSParenthesizedType,
TSPropertySignature: () => TSPropertySignature,
TSQualifiedName: () => TSQualifiedName,
TSRestType: () => TSRestType,
TSSatisfiesExpression: () => TSSatisfiesExpression,
TSStringKeyword: () => TSStringKeyword,
TSSymbolKeyword: () => TSSymbolKeyword,
TSTYPEELEMENT_TYPES: () => TSTYPEELEMENT_TYPES,
TSTYPE_TYPES: () => TSTYPE_TYPES,
TSTemplateLiteralType: () => TSTemplateLiteralType,
TSThisType: () => TSThisType,
TSTupleType: () => TSTupleType,
TSTypeAliasDeclaration: () => TSTypeAliasDeclaration,
TSTypeAnnotation: () => TSTypeAnnotation,
TSTypeAssertion: () => TSTypeAssertion,
TSTypeLiteral: () => TSTypeLiteral,
TSTypeOperator: () => TSTypeOperator,
TSTypeParameter: () => TSTypeParameter,
TSTypeParameterDeclaration: () => TSTypeParameterDeclaration,
TSTypeParameterInstantiation: () => TSTypeParameterInstantiation,
TSTypePredicate: () => TSTypePredicate,
TSTypeQuery: () => TSTypeQuery,
TSTypeReference: () => TSTypeReference,
TSUndefinedKeyword: () => TSUndefinedKeyword,
TSUnionType: () => TSUnionType,
TSUnknownKeyword: () => TSUnknownKeyword,
TSVoidKeyword: () => TSVoidKeyword,
TYPES: () => TYPES,
TYPESCRIPT_TYPES: () => TYPESCRIPT_TYPES,
TaggedTemplateExpression: () => TaggedTemplateExpression,
TemplateElement: () => TemplateElement,
TemplateLiteral: () => TemplateLiteral,
ThisExpression: () => ThisExpression,
ThisTypeAnnotation: () => ThisTypeAnnotation,
ThrowStatement: () => ThrowStatement,
TopicReference: () => TopicReference,
TryStatement: () => TryStatement,
TupleTypeAnnotation: () => TupleTypeAnnotation,
TypeAlias: () => TypeAlias,
TypeAnnotation: () => TypeAnnotation,
TypeCastExpression: () => TypeCastExpression,
TypeParameter: () => TypeParameter,
TypeParameterDeclaration: () => TypeParameterDeclaration,
TypeParameterInstantiation: () => TypeParameterInstantiation,
TypeofTypeAnnotation: () => TypeofTypeAnnotation,
UNARYLIKE_TYPES: () => UNARYLIKE_TYPES,
UNARY_OPERATORS: () => UNARY_OPERATORS,
UPDATE_OPERATORS: () => UPDATE_OPERATORS,
USERWHITESPACABLE_TYPES: () => USERWHITESPACABLE_TYPES,
UnaryExpression: () => UnaryExpression,
UnionTypeAnnotation: () => UnionTypeAnnotation,
UpdateExpression: () => UpdateExpression,
V8IntrinsicIdentifier: () => V8IntrinsicIdentifier,
VISITOR_KEYS: () => VISITOR_KEYS,
VariableDeclaration: () => VariableDeclaration,
VariableDeclarator: () => VariableDeclarator,
Variance: () => Variance,
VoidPattern: () => VoidPattern,
VoidTypeAnnotation: () => VoidTypeAnnotation,
WHILE_TYPES: () => WHILE_TYPES,
WhileStatement: () => WhileStatement,
WithStatement: () => WithStatement,
YieldExpression: () => YieldExpression,
__internal__deprecationWarning: () => deprecationWarning,
addComment: () => addComment,
addComments: () => addComments,
anyTypeAnnotation: () => anyTypeAnnotation,
appendToMemberExpression: () => appendToMemberExpression,
argumentPlaceholder: () => argumentPlaceholder,
arrayExpression: () => arrayExpression,
arrayPattern: () => arrayPattern,
arrayTypeAnnotation: () => arrayTypeAnnotation,
arrowFunctionExpression: () => arrowFunctionExpression,
assertAccessor: () => assertAccessor,
assertAnyTypeAnnotation: () => assertAnyTypeAnnotation,
assertArgumentPlaceholder: () => assertArgumentPlaceholder,
assertArrayExpression: () => assertArrayExpression,
assertArrayPattern: () => assertArrayPattern,
assertArrayTypeAnnotation: () => assertArrayTypeAnnotation,
assertArrowFunctionExpression: () => assertArrowFunctionExpression,
assertAssignmentExpression: () => assertAssignmentExpression,
assertAssignmentPattern: () => assertAssignmentPattern,
assertAwaitExpression: () => assertAwaitExpression,
assertBigIntLiteral: () => assertBigIntLiteral,
assertBigIntLiteralTypeAnnotation: () => assertBigIntLiteralTypeAnnotation,
assertBinary: () => assertBinary,
assertBinaryExpression: () => assertBinaryExpression,
assertBindExpression: () => assertBindExpression,
assertBlock: () => assertBlock,
assertBlockParent: () => assertBlockParent,
assertBlockStatement: () => assertBlockStatement,
assertBooleanLiteral: () => assertBooleanLiteral,
assertBooleanLiteralTypeAnnotation: () => assertBooleanLiteralTypeAnnotation,
assertBooleanTypeAnnotation: () => assertBooleanTypeAnnotation,
assertBreakStatement: () => assertBreakStatement,
assertCallExpression: () => assertCallExpression,
assertCatchClause: () => assertCatchClause,
assertClass: () => assertClass,
assertClassAccessorProperty: () => assertClassAccessorProperty,
assertClassBody: () => assertClassBody,
assertClassDeclaration: () => assertClassDeclaration,
assertClassExpression: () => assertClassExpression,
assertClassImplements: () => assertClassImplements,
assertClassMethod: () => assertClassMethod,
assertClassPrivateMethod: () => assertClassPrivateMethod,
assertClassPrivateProperty: () => assertClassPrivateProperty,
assertClassProperty: () => assertClassProperty,
assertCompletionStatement: () => assertCompletionStatement,
assertConditional: () => assertConditional,
assertConditionalExpression: () => assertConditionalExpression,
assertContinueStatement: () => assertContinueStatement,
assertDebuggerStatement: () => assertDebuggerStatement,
assertDeclaration: () => assertDeclaration,
assertDeclareClass: () => assertDeclareClass,
assertDeclareExportAllDeclaration: () => assertDeclareExportAllDeclaration,
assertDeclareExportDeclaration: () => assertDeclareExportDeclaration,
assertDeclareFunction: () => assertDeclareFunction,
assertDeclareInterface: () => assertDeclareInterface,
assertDeclareModule: () => assertDeclareModule,
assertDeclareModuleExports: () => assertDeclareModuleExports,
assertDeclareOpaqueType: () => assertDeclareOpaqueType,
assertDeclareTypeAlias: () => assertDeclareTypeAlias,
assertDeclareVariable: () => assertDeclareVariable,
assertDeclaredPredicate: () => assertDeclaredPredicate,
assertDecorator: () => assertDecorator,
assertDirective: () => assertDirective,
assertDirectiveLiteral: () => assertDirectiveLiteral,
assertDoExpression: () => assertDoExpression,
assertDoWhileStatement: () => assertDoWhileStatement,
assertEmptyStatement: () => assertEmptyStatement,
assertEmptyTypeAnnotation: () => assertEmptyTypeAnnotation,
assertEnumBody: () => assertEnumBody,
assertEnumBooleanBody: () => assertEnumBooleanBody,
assertEnumBooleanMember: () => assertEnumBooleanMember,
assertEnumDeclaration: () => assertEnumDeclaration,
assertEnumDefaultedMember: () => assertEnumDefaultedMember,
assertEnumMember: () => assertEnumMember,
assertEnumNumberBody: () => assertEnumNumberBody,
assertEnumNumberMember: () => assertEnumNumberMember,
assertEnumStringBody: () => assertEnumStringBody,
assertEnumStringMember: () => assertEnumStringMember,
assertEnumSymbolBody: () => assertEnumSymbolBody,
assertExistsTypeAnnotation: () => assertExistsTypeAnnotation,
assertExportAllDeclaration: () => assertExportAllDeclaration,
assertExportDeclaration: () => assertExportDeclaration,
assertExportDefaultDeclaration: () => assertExportDefaultDeclaration,
assertExportDefaultSpecifier: () => assertExportDefaultSpecifier,
assertExportNamedDeclaration: () => assertExportNamedDeclaration,
assertExportNamespaceSpecifier: () => assertExportNamespaceSpecifier,
assertExportSpecifier: () => assertExportSpecifier,
assertExpression: () => assertExpression,
assertExpressionStatement: () => assertExpressionStatement,
assertExpressionWrapper: () => assertExpressionWrapper,
assertFile: () => assertFile,
assertFlow: () => assertFlow,
assertFlowBaseAnnotation: () => assertFlowBaseAnnotation,
assertFlowDeclaration: () => assertFlowDeclaration,
assertFlowPredicate: () => assertFlowPredicate,
assertFlowType: () => assertFlowType,
assertFor: () => assertFor,
assertForInStatement: () => assertForInStatement,
assertForOfStatement: () => assertForOfStatement,
assertForStatement: () => assertForStatement,
assertForXStatement: () => assertForXStatement,
assertFunction: () => assertFunction,
assertFunctionDeclaration: () => assertFunctionDeclaration,
assertFunctionExpression: () => assertFunctionExpression,
assertFunctionParameter: () => assertFunctionParameter,
assertFunctionParent: () => assertFunctionParent,
assertFunctionTypeAnnotation: () => assertFunctionTypeAnnotation,
assertFunctionTypeParam: () => assertFunctionTypeParam,
assertGenericTypeAnnotation: () => assertGenericTypeAnnotation,
assertIdentifier: () => assertIdentifier,
assertIfStatement: () => assertIfStatement,
assertImmutable: () => assertImmutable,
assertImport: () => assertImport,
assertImportAttribute: () => assertImportAttribute,
assertImportDeclaration: () => assertImportDeclaration,
assertImportDefaultSpecifier: () => assertImportDefaultSpecifier,
assertImportExpression: () => assertImportExpression,
assertImportNamespaceSpecifier: () => assertImportNamespaceSpecifier,
assertImportOrExportDeclaration: () => assertImportOrExportDeclaration,
assertImportSpecifier: () => assertImportSpecifier,
assertIndexedAccessType: () => assertIndexedAccessType,
assertInferredPredicate: () => assertInferredPredicate,
assertInterfaceDeclaration: () => assertInterfaceDeclaration,
assertInterfaceExtends: () => assertInterfaceExtends,
assertInterfaceTypeAnnotation: () => assertInterfaceTypeAnnotation,
assertInterpreterDirective: () => assertInterpreterDirective,
assertIntersectionTypeAnnotation: () => assertIntersectionTypeAnnotation,
assertJSX: () => assertJSX,
assertJSXAttribute: () => assertJSXAttribute,
assertJSXClosingElement: () => assertJSXClosingElement,
assertJSXClosingFragment: () => assertJSXClosingFragment,
assertJSXElement: () => assertJSXElement,
assertJSXEmptyExpression: () => assertJSXEmptyExpression,
assertJSXExpressionContainer: () => assertJSXExpressionContainer,
assertJSXFragment: () => assertJSXFragment,
assertJSXIdentifier: () => assertJSXIdentifier,
assertJSXMemberExpression: () => assertJSXMemberExpression,
assertJSXNamespacedName: () => assertJSXNamespacedName,
assertJSXOpeningElement: () => assertJSXOpeningElement,
assertJSXOpeningFragment: () => assertJSXOpeningFragment,
assertJSXSpreadAttribute: () => assertJSXSpreadAttribute,
assertJSXSpreadChild: () => assertJSXSpreadChild,
assertJSXText: () => assertJSXText,
assertLVal: () => assertLVal,
assertLabeledStatement: () => assertLabeledStatement,
assertLiteral: () => assertLiteral,
assertLogicalExpression: () => assertLogicalExpression,
assertLoop: () => assertLoop,
assertMemberExpression: () => assertMemberExpression,
assertMetaProperty: () => assertMetaProperty,
assertMethod: () => assertMethod,
assertMiscellaneous: () => assertMiscellaneous,
assertMixedTypeAnnotation: () => assertMixedTypeAnnotation,
assertModuleDeclaration: () => assertModuleDeclaration,
assertModuleExpression: () => assertModuleExpression,
assertModuleSpecifier: () => assertModuleSpecifier,
assertNewExpression: () => assertNewExpression,
assertNode: () => assertNode,
assertNullLiteral: () => assertNullLiteral,
assertNullLiteralTypeAnnotation: () => assertNullLiteralTypeAnnotation,
assertNullableTypeAnnotation: () => assertNullableTypeAnnotation,
assertNumberLiteral: () => assertNumberLiteral,
assertNumberLiteralTypeAnnotation: () => assertNumberLiteralTypeAnnotation,
assertNumberTypeAnnotation: () => assertNumberTypeAnnotation,
assertNumericLiteral: () => assertNumericLiteral,
assertObjectExpression: () => assertObjectExpression,
assertObjectMember: () => assertObjectMember,
assertObjectMethod: () => assertObjectMethod,
assertObjectPattern: () => assertObjectPattern,
assertObjectProperty: () => assertObjectProperty,
assertObjectTypeAnnotation: () => assertObjectTypeAnnotation,
assertObjectTypeCallProperty: () => assertObjectTypeCallProperty,
assertObjectTypeIndexer: () => assertObjectTypeIndexer,
assertObjectTypeInternalSlot: () => assertObjectTypeInternalSlot,
assertObjectTypeProperty: () => assertObjectTypeProperty,
assertObjectTypeSpreadProperty: () => assertObjectTypeSpreadProperty,
assertOpaqueType: () => assertOpaqueType,
assertOptionalCallExpression: () => assertOptionalCallExpression,
assertOptionalIndexedAccessType: () => assertOptionalIndexedAccessType,
assertOptionalMemberExpression: () => assertOptionalMemberExpression,
assertParenthesizedExpression: () => assertParenthesizedExpression,
assertPattern: () => assertPattern,
assertPatternLike: () => assertPatternLike,
assertPlaceholder: () => assertPlaceholder,
assertPrivate: () => assertPrivate,
assertPrivateName: () => assertPrivateName,
assertProgram: () => assertProgram,
assertProperty: () => assertProperty,
assertPureish: () => assertPureish,
assertQualifiedTypeIdentifier: () => assertQualifiedTypeIdentifier,
assertRegExpLiteral: () => assertRegExpLiteral,
assertRegexLiteral: () => assertRegexLiteral,
assertRestElement: () => assertRestElement,
assertRestProperty: () => assertRestProperty,
assertReturnStatement: () => assertReturnStatement,
assertScopable: () => assertScopable,
assertSequenceExpression: () => assertSequenceExpression,
assertSpreadElement: () => assertSpreadElement,
assertSpreadProperty: () => assertSpreadProperty,
assertStandardized: () => assertStandardized,
assertStatement: () => assertStatement,
assertStaticBlock: () => assertStaticBlock,
assertStringLiteral: () => assertStringLiteral,
assertStringLiteralTypeAnnotation: () => assertStringLiteralTypeAnnotation,
assertStringTypeAnnotation: () => assertStringTypeAnnotation,
assertSuper: () => assertSuper,
assertSwitchCase: () => assertSwitchCase,
assertSwitchStatement: () => assertSwitchStatement,
assertSymbolTypeAnnotation: () => assertSymbolTypeAnnotation,
assertTSAnyKeyword: () => assertTSAnyKeyword,
assertTSArrayType: () => assertTSArrayType,
assertTSAsExpression: () => assertTSAsExpression,
assertTSBaseType: () => assertTSBaseType,
assertTSBigIntKeyword: () => assertTSBigIntKeyword,
assertTSBooleanKeyword: () => assertTSBooleanKeyword,
assertTSCallSignatureDeclaration: () => assertTSCallSignatureDeclaration,
assertTSClassImplements: () => assertTSClassImplements,
assertTSConditionalType: () => assertTSConditionalType,
assertTSConstructSignatureDeclaration: () => assertTSConstructSignatureDeclaration,
assertTSConstructorType: () => assertTSConstructorType,
assertTSDeclareFunction: () => assertTSDeclareFunction,
assertTSDeclareMethod: () => assertTSDeclareMethod,
assertTSEntityName: () => assertTSEntityName,
assertTSEnumBody: () => assertTSEnumBody,
assertTSEnumDeclaration: () => assertTSEnumDeclaration,
assertTSEnumMember: () => assertTSEnumMember,
assertTSExportAssignment: () => assertTSExportAssignment,
assertTSExternalModuleReference: () => assertTSExternalModuleReference,
assertTSFunctionType: () => assertTSFunctionType,
assertTSImportEqualsDeclaration: () => assertTSImportEqualsDeclaration,
assertTSImportType: () => assertTSImportType,
assertTSIndexSignature: () => assertTSIndexSignature,
assertTSIndexedAccessType: () => assertTSIndexedAccessType,
assertTSInferType: () => assertTSInferType,
assertTSInstantiationExpression: () => assertTSInstantiationExpression,
assertTSInterfaceBody: () => assertTSInterfaceBody,
assertTSInterfaceDeclaration: () => assertTSInterfaceDeclaration,
assertTSInterfaceHeritage: () => assertTSInterfaceHeritage,
assertTSIntersectionType: () => assertTSIntersectionType,
assertTSIntrinsicKeyword: () => assertTSIntrinsicKeyword,
assertTSLiteralType: () => assertTSLiteralType,
assertTSMappedType: () => assertTSMappedType,
assertTSMethodSignature: () => assertTSMethodSignature,
assertTSModuleBlock: () => assertTSModuleBlock,
assertTSModuleDeclaration: () => assertTSModuleDeclaration,
assertTSNamedTupleMember: () => assertTSNamedTupleMember,
assertTSNamespaceExportDeclaration: () => assertTSNamespaceExportDeclaration,
assertTSNeverKeyword: () => assertTSNeverKeyword,
assertTSNonNullExpression: () => assertTSNonNullExpression,
assertTSNullKeyword: () => assertTSNullKeyword,
assertTSNumberKeyword: () => assertTSNumberKeyword,
assertTSObjectKeyword: () => assertTSObjectKeyword,
assertTSOptionalType: () => assertTSOptionalType,
assertTSParameterProperty: () => assertTSParameterProperty,
assertTSParenthesizedType: () => assertTSParenthesizedType,
assertTSPropertySignature: () => assertTSPropertySignature,
assertTSQualifiedName: () => assertTSQualifiedName,
assertTSRestType: () => assertTSRestType,
assertTSSatisfiesExpression: () => assertTSSatisfiesExpression,
assertTSStringKeyword: () => assertTSStringKeyword,
assertTSSymbolKeyword: () => assertTSSymbolKeyword,
assertTSTemplateLiteralType: () => assertTSTemplateLiteralType,
assertTSThisType: () => assertTSThisType,
assertTSTupleType: () => assertTSTupleType,
assertTSType: () => assertTSType,
assertTSTypeAliasDeclaration: () => assertTSTypeAliasDeclaration,
assertTSTypeAnnotation: () => assertTSTypeAnnotation,
assertTSTypeAssertion: () => assertTSTypeAssertion,
assertTSTypeElement: () => assertTSTypeElement,
assertTSTypeLiteral: () => assertTSTypeLiteral,
assertTSTypeOperator: () => assertTSTypeOperator,
assertTSTypeParameter: () => assertTSTypeParameter,
assertTSTypeParameterDeclaration: () => assertTSTypeParameterDeclaration,
assertTSTypeParameterInstantiation: () => assertTSTypeParameterInstantiation,
assertTSTypePredicate: () => assertTSTypePredicate,
assertTSTypeQuery: () => assertTSTypeQuery,
assertTSTypeReference: () => assertTSTypeReference,
assertTSUndefinedKeyword: () => assertTSUndefinedKeyword,
assertTSUnionType: () => assertTSUnionType,
assertTSUnknownKeyword: () => assertTSUnknownKeyword,
assertTSVoidKeyword: () => assertTSVoidKeyword,
assertTaggedTemplateExpression: () => assertTaggedTemplateExpression,
assertTemplateElement: () => assertTemplateElement,
assertTemplateLiteral: () => assertTemplateLiteral,
assertTerminatorless: () => assertTerminatorless,
assertThisExpression: () => assertThisExpression,
assertThisTypeAnnotation: () => assertThisTypeAnnotation,
assertThrowStatement: () => assertThrowStatement,
assertTopicReference: () => assertTopicReference,
assertTryStatement: () => assertTryStatement,
assertTupleTypeAnnotation: () => assertTupleTypeAnnotation,
assertTypeAlias: () => assertTypeAlias,
assertTypeAnnotation: () => assertTypeAnnotation,
assertTypeCastExpression: () => assertTypeCastExpression,
assertTypeParameter: () => assertTypeParameter,
assertTypeParameterDeclaration: () => assertTypeParameterDeclaration,
assertTypeParameterInstantiation: () => assertTypeParameterInstantiation,
assertTypeScript: () => assertTypeScript,
assertTypeofTypeAnnotation: () => assertTypeofTypeAnnotation,
assertUnaryExpression: () => assertUnaryExpression,
assertUnaryLike: () => assertUnaryLike,
assertUnionTypeAnnotation: () => assertUnionTypeAnnotation,
assertUpdateExpression: () => assertUpdateExpression,
assertUserWhitespacable: () => assertUserWhitespacable,
assertV8IntrinsicIdentifier: () => assertV8IntrinsicIdentifier,
assertVariableDeclaration: () => assertVariableDeclaration,
assertVariableDeclarator: () => assertVariableDeclarator,
assertVariance: () => assertVariance,
assertVoidPattern: () => assertVoidPattern,
assertVoidTypeAnnotation: () => assertVoidTypeAnnotation,
assertWhile: () => assertWhile,
assertWhileStatement: () => assertWhileStatement,
assertWithStatement: () => assertWithStatement,
assertYieldExpression: () => assertYieldExpression,
assignmentExpression: () => assignmentExpression,
assignmentPattern: () => assignmentPattern,
awaitExpression: () => awaitExpression,
bigIntLiteral: () => bigIntLiteral,
bigIntLiteralTypeAnnotation: () => bigIntLiteralTypeAnnotation,
binaryExpression: () => binaryExpression,
bindExpression: () => bindExpression,
blockStatement: () => blockStatement,
booleanLiteral: () => booleanLiteral,
booleanLiteralTypeAnnotation: () => booleanLiteralTypeAnnotation,
booleanTypeAnnotation: () => booleanTypeAnnotation,
breakStatement: () => breakStatement,
buildMatchMemberExpression: () => buildMatchMemberExpression,
buildUndefinedNode: () => buildUndefinedNode,
callExpression: () => callExpression,
catchClause: () => catchClause,
classAccessorProperty: () => classAccessorProperty,
classBody: () => classBody,
classDeclaration: () => classDeclaration,
classExpression: () => classExpression,
classImplements: () => classImplements,
classMethod: () => classMethod,
classPrivateMethod: () => classPrivateMethod,
classPrivateProperty: () => classPrivateProperty,
classProperty: () => classProperty,
clone: () => clone,
cloneDeep: () => cloneDeep,
cloneDeepWithoutLoc: () => cloneDeepWithoutLoc,
cloneNode: () => cloneNode,
cloneWithoutLoc: () => cloneWithoutLoc,
conditionalExpression: () => conditionalExpression,
continueStatement: () => continueStatement,
createFlowUnionType: () => createFlowUnionType,
createTSUnionType: () => createTSUnionType,
createTypeAnnotationBasedOnTypeof: () => createTypeAnnotationBasedOnTypeof,
createUnionTypeAnnotation: () => createFlowUnionType,
debuggerStatement: () => debuggerStatement,
declareClass: () => declareClass,
declareExportAllDeclaration: () => declareExportAllDeclaration,
declareExportDeclaration: () => declareExportDeclaration,
decla