@babel/types

Package Overview

Dependencies

Maintainers

Versions

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

@babel/types - npm Package Compare versions

Comparing version 7.0.0-beta.42 to 7.0.0-beta.43

lib/asserts/assertNode.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = assertNode;
		@@ -12,5 +14,5 @@
		if (!(0, _isNode.default)(node)) {
		var type = node && node.type \|\| JSON.stringify(node);
		throw new TypeError("Not a valid node of type \"" + type + "\"");
		const type = node && node.type \|\| JSON.stringify(node);
		throw new TypeError(`Not a valid node of type "${type}"`);
		}
		}

1494

lib/asserts/generated/index.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.assertArrayExpression = assertArrayExpression;
		@@ -263,1987 +265,995 @@ exports.assertAssignmentExpression = assertAssignmentExpression;
		if (!(0, _is.default)(type, node, opts)) {
		throw new Error("Expected type \"" + type + "\" with option " + JSON.stringify(opts) + ", but instead got \"" + node.type + "\".");
		throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, but instead got "${node.type}".`);
		}
		}

		function assertArrayExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertArrayExpression(node, opts = {}) {
		assert("ArrayExpression", node, opts);
		}

		function assertAssignmentExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertAssignmentExpression(node, opts = {}) {
		assert("AssignmentExpression", node, opts);
		}

		function assertBinaryExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertBinaryExpression(node, opts = {}) {
		assert("BinaryExpression", node, opts);
		}

		function assertDirective(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDirective(node, opts = {}) {
		assert("Directive", node, opts);
		}

		function assertDirectiveLiteral(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDirectiveLiteral(node, opts = {}) {
		assert("DirectiveLiteral", node, opts);
		}

		function assertBlockStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertBlockStatement(node, opts = {}) {
		assert("BlockStatement", node, opts);
		}

		function assertBreakStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertBreakStatement(node, opts = {}) {
		assert("BreakStatement", node, opts);
		}

		function assertCallExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertCallExpression(node, opts = {}) {
		assert("CallExpression", node, opts);
		}

		function assertCatchClause(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertCatchClause(node, opts = {}) {
		assert("CatchClause", node, opts);
		}

		function assertConditionalExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertConditionalExpression(node, opts = {}) {
		assert("ConditionalExpression", node, opts);
		}

		function assertContinueStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertContinueStatement(node, opts = {}) {
		assert("ContinueStatement", node, opts);
		}

		function assertDebuggerStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDebuggerStatement(node, opts = {}) {
		assert("DebuggerStatement", node, opts);
		}

		function assertDoWhileStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDoWhileStatement(node, opts = {}) {
		assert("DoWhileStatement", node, opts);
		}

		function assertEmptyStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertEmptyStatement(node, opts = {}) {
		assert("EmptyStatement", node, opts);
		}

		function assertExpressionStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExpressionStatement(node, opts = {}) {
		assert("ExpressionStatement", node, opts);
		}

		function assertFile(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFile(node, opts = {}) {
		assert("File", node, opts);
		}

		function assertForInStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertForInStatement(node, opts = {}) {
		assert("ForInStatement", node, opts);
		}

		function assertForStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertForStatement(node, opts = {}) {
		assert("ForStatement", node, opts);
		}

		function assertFunctionDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFunctionDeclaration(node, opts = {}) {
		assert("FunctionDeclaration", node, opts);
		}

		function assertFunctionExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFunctionExpression(node, opts = {}) {
		assert("FunctionExpression", node, opts);
		}

		function assertIdentifier(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertIdentifier(node, opts = {}) {
		assert("Identifier", node, opts);
		}

		function assertIfStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertIfStatement(node, opts = {}) {
		assert("IfStatement", node, opts);
		}

		function assertLabeledStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertLabeledStatement(node, opts = {}) {
		assert("LabeledStatement", node, opts);
		}

		function assertStringLiteral(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertStringLiteral(node, opts = {}) {
		assert("StringLiteral", node, opts);
		}

		function assertNumericLiteral(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertNumericLiteral(node, opts = {}) {
		assert("NumericLiteral", node, opts);
		}

		function assertNullLiteral(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertNullLiteral(node, opts = {}) {
		assert("NullLiteral", node, opts);
		}

		function assertBooleanLiteral(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertBooleanLiteral(node, opts = {}) {
		assert("BooleanLiteral", node, opts);
		}

		function assertRegExpLiteral(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertRegExpLiteral(node, opts = {}) {
		assert("RegExpLiteral", node, opts);
		}

		function assertLogicalExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertLogicalExpression(node, opts = {}) {
		assert("LogicalExpression", node, opts);
		}

		function assertMemberExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertMemberExpression(node, opts = {}) {
		assert("MemberExpression", node, opts);
		}

		function assertNewExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertNewExpression(node, opts = {}) {
		assert("NewExpression", node, opts);
		}

		function assertProgram(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertProgram(node, opts = {}) {
		assert("Program", node, opts);
		}

		function assertObjectExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertObjectExpression(node, opts = {}) {
		assert("ObjectExpression", node, opts);
		}

		function assertObjectMethod(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertObjectMethod(node, opts = {}) {
		assert("ObjectMethod", node, opts);
		}

		function assertObjectProperty(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertObjectProperty(node, opts = {}) {
		assert("ObjectProperty", node, opts);
		}

		function assertRestElement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertRestElement(node, opts = {}) {
		assert("RestElement", node, opts);
		}

		function assertReturnStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertReturnStatement(node, opts = {}) {
		assert("ReturnStatement", node, opts);
		}

		function assertSequenceExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertSequenceExpression(node, opts = {}) {
		assert("SequenceExpression", node, opts);
		}

		function assertSwitchCase(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertSwitchCase(node, opts = {}) {
		assert("SwitchCase", node, opts);
		}

		function assertSwitchStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertSwitchStatement(node, opts = {}) {
		assert("SwitchStatement", node, opts);
		}

		function assertThisExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertThisExpression(node, opts = {}) {
		assert("ThisExpression", node, opts);
		}

		function assertThrowStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertThrowStatement(node, opts = {}) {
		assert("ThrowStatement", node, opts);
		}

		function assertTryStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTryStatement(node, opts = {}) {
		assert("TryStatement", node, opts);
		}

		function assertUnaryExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertUnaryExpression(node, opts = {}) {
		assert("UnaryExpression", node, opts);
		}

		function assertUpdateExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertUpdateExpression(node, opts = {}) {
		assert("UpdateExpression", node, opts);
		}

		function assertVariableDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertVariableDeclaration(node, opts = {}) {
		assert("VariableDeclaration", node, opts);
		}

		function assertVariableDeclarator(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertVariableDeclarator(node, opts = {}) {
		assert("VariableDeclarator", node, opts);
		}

		function assertWhileStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertWhileStatement(node, opts = {}) {
		assert("WhileStatement", node, opts);
		}

		function assertWithStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertWithStatement(node, opts = {}) {
		assert("WithStatement", node, opts);
		}

		function assertAssignmentPattern(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertAssignmentPattern(node, opts = {}) {
		assert("AssignmentPattern", node, opts);
		}

		function assertArrayPattern(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertArrayPattern(node, opts = {}) {
		assert("ArrayPattern", node, opts);
		}

		function assertArrowFunctionExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertArrowFunctionExpression(node, opts = {}) {
		assert("ArrowFunctionExpression", node, opts);
		}

		function assertClassBody(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertClassBody(node, opts = {}) {
		assert("ClassBody", node, opts);
		}

		function assertClassDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertClassDeclaration(node, opts = {}) {
		assert("ClassDeclaration", node, opts);
		}

		function assertClassExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertClassExpression(node, opts = {}) {
		assert("ClassExpression", node, opts);
		}

		function assertExportAllDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExportAllDeclaration(node, opts = {}) {
		assert("ExportAllDeclaration", node, opts);
		}

		function assertExportDefaultDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExportDefaultDeclaration(node, opts = {}) {
		assert("ExportDefaultDeclaration", node, opts);
		}

		function assertExportNamedDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExportNamedDeclaration(node, opts = {}) {
		assert("ExportNamedDeclaration", node, opts);
		}

		function assertExportSpecifier(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExportSpecifier(node, opts = {}) {
		assert("ExportSpecifier", node, opts);
		}

		function assertForOfStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertForOfStatement(node, opts = {}) {
		assert("ForOfStatement", node, opts);
		}

		function assertImportDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertImportDeclaration(node, opts = {}) {
		assert("ImportDeclaration", node, opts);
		}

		function assertImportDefaultSpecifier(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertImportDefaultSpecifier(node, opts = {}) {
		assert("ImportDefaultSpecifier", node, opts);
		}

		function assertImportNamespaceSpecifier(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertImportNamespaceSpecifier(node, opts = {}) {
		assert("ImportNamespaceSpecifier", node, opts);
		}

		function assertImportSpecifier(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertImportSpecifier(node, opts = {}) {
		assert("ImportSpecifier", node, opts);
		}

		function assertMetaProperty(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertMetaProperty(node, opts = {}) {
		assert("MetaProperty", node, opts);
		}

		function assertClassMethod(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertClassMethod(node, opts = {}) {
		assert("ClassMethod", node, opts);
		}

		function assertObjectPattern(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertObjectPattern(node, opts = {}) {
		assert("ObjectPattern", node, opts);
		}

		function assertSpreadElement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertSpreadElement(node, opts = {}) {
		assert("SpreadElement", node, opts);
		}

		function assertSuper(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertSuper(node, opts = {}) {
		assert("Super", node, opts);
		}

		function assertTaggedTemplateExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTaggedTemplateExpression(node, opts = {}) {
		assert("TaggedTemplateExpression", node, opts);
		}

		function assertTemplateElement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTemplateElement(node, opts = {}) {
		assert("TemplateElement", node, opts);
		}

		function assertTemplateLiteral(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTemplateLiteral(node, opts = {}) {
		assert("TemplateLiteral", node, opts);
		}

		function assertYieldExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertYieldExpression(node, opts = {}) {
		assert("YieldExpression", node, opts);
		}

		function assertAnyTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertAnyTypeAnnotation(node, opts = {}) {
		assert("AnyTypeAnnotation", node, opts);
		}

		function assertArrayTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertArrayTypeAnnotation(node, opts = {}) {
		assert("ArrayTypeAnnotation", node, opts);
		}

		function assertBooleanTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertBooleanTypeAnnotation(node, opts = {}) {
		assert("BooleanTypeAnnotation", node, opts);
		}

		function assertBooleanLiteralTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertBooleanLiteralTypeAnnotation(node, opts = {}) {
		assert("BooleanLiteralTypeAnnotation", node, opts);
		}

		function assertNullLiteralTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertNullLiteralTypeAnnotation(node, opts = {}) {
		assert("NullLiteralTypeAnnotation", node, opts);
		}

		function assertClassImplements(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertClassImplements(node, opts = {}) {
		assert("ClassImplements", node, opts);
		}

		function assertDeclareClass(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclareClass(node, opts = {}) {
		assert("DeclareClass", node, opts);
		}

		function assertDeclareFunction(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclareFunction(node, opts = {}) {
		assert("DeclareFunction", node, opts);
		}

		function assertDeclareInterface(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclareInterface(node, opts = {}) {
		assert("DeclareInterface", node, opts);
		}

		function assertDeclareModule(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclareModule(node, opts = {}) {
		assert("DeclareModule", node, opts);
		}

		function assertDeclareModuleExports(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclareModuleExports(node, opts = {}) {
		assert("DeclareModuleExports", node, opts);
		}

		function assertDeclareTypeAlias(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclareTypeAlias(node, opts = {}) {
		assert("DeclareTypeAlias", node, opts);
		}

		function assertDeclareOpaqueType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclareOpaqueType(node, opts = {}) {
		assert("DeclareOpaqueType", node, opts);
		}

		function assertDeclareVariable(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclareVariable(node, opts = {}) {
		assert("DeclareVariable", node, opts);
		}

		function assertDeclareExportDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclareExportDeclaration(node, opts = {}) {
		assert("DeclareExportDeclaration", node, opts);
		}

		function assertDeclareExportAllDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclareExportAllDeclaration(node, opts = {}) {
		assert("DeclareExportAllDeclaration", node, opts);
		}

		function assertDeclaredPredicate(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclaredPredicate(node, opts = {}) {
		assert("DeclaredPredicate", node, opts);
		}

		function assertExistsTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExistsTypeAnnotation(node, opts = {}) {
		assert("ExistsTypeAnnotation", node, opts);
		}

		function assertFunctionTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFunctionTypeAnnotation(node, opts = {}) {
		assert("FunctionTypeAnnotation", node, opts);
		}

		function assertFunctionTypeParam(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFunctionTypeParam(node, opts = {}) {
		assert("FunctionTypeParam", node, opts);
		}

		function assertGenericTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertGenericTypeAnnotation(node, opts = {}) {
		assert("GenericTypeAnnotation", node, opts);
		}

		function assertInferredPredicate(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertInferredPredicate(node, opts = {}) {
		assert("InferredPredicate", node, opts);
		}

		function assertInterfaceExtends(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertInterfaceExtends(node, opts = {}) {
		assert("InterfaceExtends", node, opts);
		}

		function assertInterfaceDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertInterfaceDeclaration(node, opts = {}) {
		assert("InterfaceDeclaration", node, opts);
		}

		function assertIntersectionTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertIntersectionTypeAnnotation(node, opts = {}) {
		assert("IntersectionTypeAnnotation", node, opts);
		}

		function assertMixedTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertMixedTypeAnnotation(node, opts = {}) {
		assert("MixedTypeAnnotation", node, opts);
		}

		function assertEmptyTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertEmptyTypeAnnotation(node, opts = {}) {
		assert("EmptyTypeAnnotation", node, opts);
		}

		function assertNullableTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertNullableTypeAnnotation(node, opts = {}) {
		assert("NullableTypeAnnotation", node, opts);
		}

		function assertNumberLiteralTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertNumberLiteralTypeAnnotation(node, opts = {}) {
		assert("NumberLiteralTypeAnnotation", node, opts);
		}

		function assertNumberTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertNumberTypeAnnotation(node, opts = {}) {
		assert("NumberTypeAnnotation", node, opts);
		}

		function assertObjectTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertObjectTypeAnnotation(node, opts = {}) {
		assert("ObjectTypeAnnotation", node, opts);
		}

		function assertObjectTypeCallProperty(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertObjectTypeCallProperty(node, opts = {}) {
		assert("ObjectTypeCallProperty", node, opts);
		}

		function assertObjectTypeIndexer(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertObjectTypeIndexer(node, opts = {}) {
		assert("ObjectTypeIndexer", node, opts);
		}

		function assertObjectTypeProperty(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertObjectTypeProperty(node, opts = {}) {
		assert("ObjectTypeProperty", node, opts);
		}

		function assertObjectTypeSpreadProperty(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertObjectTypeSpreadProperty(node, opts = {}) {
		assert("ObjectTypeSpreadProperty", node, opts);
		}

		function assertOpaqueType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertOpaqueType(node, opts = {}) {
		assert("OpaqueType", node, opts);
		}

		function assertQualifiedTypeIdentifier(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertQualifiedTypeIdentifier(node, opts = {}) {
		assert("QualifiedTypeIdentifier", node, opts);
		}

		function assertStringLiteralTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertStringLiteralTypeAnnotation(node, opts = {}) {
		assert("StringLiteralTypeAnnotation", node, opts);
		}

		function assertStringTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertStringTypeAnnotation(node, opts = {}) {
		assert("StringTypeAnnotation", node, opts);
		}

		function assertThisTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertThisTypeAnnotation(node, opts = {}) {
		assert("ThisTypeAnnotation", node, opts);
		}

		function assertTupleTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTupleTypeAnnotation(node, opts = {}) {
		assert("TupleTypeAnnotation", node, opts);
		}

		function assertTypeofTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTypeofTypeAnnotation(node, opts = {}) {
		assert("TypeofTypeAnnotation", node, opts);
		}

		function assertTypeAlias(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTypeAlias(node, opts = {}) {
		assert("TypeAlias", node, opts);
		}

		function assertTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTypeAnnotation(node, opts = {}) {
		assert("TypeAnnotation", node, opts);
		}

		function assertTypeCastExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTypeCastExpression(node, opts = {}) {
		assert("TypeCastExpression", node, opts);
		}

		function assertTypeParameter(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTypeParameter(node, opts = {}) {
		assert("TypeParameter", node, opts);
		}

		function assertTypeParameterDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTypeParameterDeclaration(node, opts = {}) {
		assert("TypeParameterDeclaration", node, opts);
		}

		function assertTypeParameterInstantiation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTypeParameterInstantiation(node, opts = {}) {
		assert("TypeParameterInstantiation", node, opts);
		}

		function assertUnionTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertUnionTypeAnnotation(node, opts = {}) {
		assert("UnionTypeAnnotation", node, opts);
		}

		function assertVariance(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertVariance(node, opts = {}) {
		assert("Variance", node, opts);
		}

		function assertVoidTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertVoidTypeAnnotation(node, opts = {}) {
		assert("VoidTypeAnnotation", node, opts);
		}

		function assertJSXAttribute(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXAttribute(node, opts = {}) {
		assert("JSXAttribute", node, opts);
		}

		function assertJSXClosingElement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXClosingElement(node, opts = {}) {
		assert("JSXClosingElement", node, opts);
		}

		function assertJSXElement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXElement(node, opts = {}) {
		assert("JSXElement", node, opts);
		}

		function assertJSXEmptyExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXEmptyExpression(node, opts = {}) {
		assert("JSXEmptyExpression", node, opts);
		}

		function assertJSXExpressionContainer(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXExpressionContainer(node, opts = {}) {
		assert("JSXExpressionContainer", node, opts);
		}

		function assertJSXSpreadChild(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXSpreadChild(node, opts = {}) {
		assert("JSXSpreadChild", node, opts);
		}

		function assertJSXIdentifier(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXIdentifier(node, opts = {}) {
		assert("JSXIdentifier", node, opts);
		}

		function assertJSXMemberExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXMemberExpression(node, opts = {}) {
		assert("JSXMemberExpression", node, opts);
		}

		function assertJSXNamespacedName(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXNamespacedName(node, opts = {}) {
		assert("JSXNamespacedName", node, opts);
		}

		function assertJSXOpeningElement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXOpeningElement(node, opts = {}) {
		assert("JSXOpeningElement", node, opts);
		}

		function assertJSXSpreadAttribute(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXSpreadAttribute(node, opts = {}) {
		assert("JSXSpreadAttribute", node, opts);
		}

		function assertJSXText(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXText(node, opts = {}) {
		assert("JSXText", node, opts);
		}

		function assertJSXFragment(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXFragment(node, opts = {}) {
		assert("JSXFragment", node, opts);
		}

		function assertJSXOpeningFragment(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXOpeningFragment(node, opts = {}) {
		assert("JSXOpeningFragment", node, opts);
		}

		function assertJSXClosingFragment(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSXClosingFragment(node, opts = {}) {
		assert("JSXClosingFragment", node, opts);
		}

		function assertNoop(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertNoop(node, opts = {}) {
		assert("Noop", node, opts);
		}

		function assertParenthesizedExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertParenthesizedExpression(node, opts = {}) {
		assert("ParenthesizedExpression", node, opts);
		}

		function assertAwaitExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertAwaitExpression(node, opts = {}) {
		assert("AwaitExpression", node, opts);
		}

		function assertBindExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertBindExpression(node, opts = {}) {
		assert("BindExpression", node, opts);
		}

		function assertClassProperty(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertClassProperty(node, opts = {}) {
		assert("ClassProperty", node, opts);
		}

		function assertOptionalMemberExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertOptionalMemberExpression(node, opts = {}) {
		assert("OptionalMemberExpression", node, opts);
		}

		function assertOptionalCallExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertOptionalCallExpression(node, opts = {}) {
		assert("OptionalCallExpression", node, opts);
		}

		function assertImport(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertImport(node, opts = {}) {
		assert("Import", node, opts);
		}

		function assertDecorator(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDecorator(node, opts = {}) {
		assert("Decorator", node, opts);
		}

		function assertDoExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDoExpression(node, opts = {}) {
		assert("DoExpression", node, opts);
		}

		function assertExportDefaultSpecifier(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExportDefaultSpecifier(node, opts = {}) {
		assert("ExportDefaultSpecifier", node, opts);
		}

		function assertExportNamespaceSpecifier(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExportNamespaceSpecifier(node, opts = {}) {
		assert("ExportNamespaceSpecifier", node, opts);
		}

		function assertTSParameterProperty(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSParameterProperty(node, opts = {}) {
		assert("TSParameterProperty", node, opts);
		}

		function assertTSDeclareFunction(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSDeclareFunction(node, opts = {}) {
		assert("TSDeclareFunction", node, opts);
		}

		function assertTSDeclareMethod(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSDeclareMethod(node, opts = {}) {
		assert("TSDeclareMethod", node, opts);
		}

		function assertTSQualifiedName(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSQualifiedName(node, opts = {}) {
		assert("TSQualifiedName", node, opts);
		}

		function assertTSCallSignatureDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSCallSignatureDeclaration(node, opts = {}) {
		assert("TSCallSignatureDeclaration", node, opts);
		}

		function assertTSConstructSignatureDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSConstructSignatureDeclaration(node, opts = {}) {
		assert("TSConstructSignatureDeclaration", node, opts);
		}

		function assertTSPropertySignature(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSPropertySignature(node, opts = {}) {
		assert("TSPropertySignature", node, opts);
		}

		function assertTSMethodSignature(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSMethodSignature(node, opts = {}) {
		assert("TSMethodSignature", node, opts);
		}

		function assertTSIndexSignature(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSIndexSignature(node, opts = {}) {
		assert("TSIndexSignature", node, opts);
		}

		function assertTSAnyKeyword(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSAnyKeyword(node, opts = {}) {
		assert("TSAnyKeyword", node, opts);
		}

		function assertTSNumberKeyword(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSNumberKeyword(node, opts = {}) {
		assert("TSNumberKeyword", node, opts);
		}

		function assertTSObjectKeyword(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSObjectKeyword(node, opts = {}) {
		assert("TSObjectKeyword", node, opts);
		}

		function assertTSBooleanKeyword(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSBooleanKeyword(node, opts = {}) {
		assert("TSBooleanKeyword", node, opts);
		}

		function assertTSStringKeyword(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSStringKeyword(node, opts = {}) {
		assert("TSStringKeyword", node, opts);
		}

		function assertTSSymbolKeyword(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSSymbolKeyword(node, opts = {}) {
		assert("TSSymbolKeyword", node, opts);
		}

		function assertTSVoidKeyword(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSVoidKeyword(node, opts = {}) {
		assert("TSVoidKeyword", node, opts);
		}

		function assertTSUndefinedKeyword(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSUndefinedKeyword(node, opts = {}) {
		assert("TSUndefinedKeyword", node, opts);
		}

		function assertTSNullKeyword(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSNullKeyword(node, opts = {}) {
		assert("TSNullKeyword", node, opts);
		}

		function assertTSNeverKeyword(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSNeverKeyword(node, opts = {}) {
		assert("TSNeverKeyword", node, opts);
		}

		function assertTSThisType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSThisType(node, opts = {}) {
		assert("TSThisType", node, opts);
		}

		function assertTSFunctionType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSFunctionType(node, opts = {}) {
		assert("TSFunctionType", node, opts);
		}

		function assertTSConstructorType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSConstructorType(node, opts = {}) {
		assert("TSConstructorType", node, opts);
		}

		function assertTSTypeReference(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeReference(node, opts = {}) {
		assert("TSTypeReference", node, opts);
		}

		function assertTSTypePredicate(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypePredicate(node, opts = {}) {
		assert("TSTypePredicate", node, opts);
		}

		function assertTSTypeQuery(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeQuery(node, opts = {}) {
		assert("TSTypeQuery", node, opts);
		}

		function assertTSTypeLiteral(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeLiteral(node, opts = {}) {
		assert("TSTypeLiteral", node, opts);
		}

		function assertTSArrayType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSArrayType(node, opts = {}) {
		assert("TSArrayType", node, opts);
		}

		function assertTSTupleType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTupleType(node, opts = {}) {
		assert("TSTupleType", node, opts);
		}

		function assertTSUnionType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSUnionType(node, opts = {}) {
		assert("TSUnionType", node, opts);
		}

		function assertTSIntersectionType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSIntersectionType(node, opts = {}) {
		assert("TSIntersectionType", node, opts);
		}

		function assertTSConditionalType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSConditionalType(node, opts = {}) {
		assert("TSConditionalType", node, opts);
		}

		function assertTSInferType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSInferType(node, opts = {}) {
		assert("TSInferType", node, opts);
		}

		function assertTSParenthesizedType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSParenthesizedType(node, opts = {}) {
		assert("TSParenthesizedType", node, opts);
		}

		function assertTSTypeOperator(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeOperator(node, opts = {}) {
		assert("TSTypeOperator", node, opts);
		}

		function assertTSIndexedAccessType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSIndexedAccessType(node, opts = {}) {
		assert("TSIndexedAccessType", node, opts);
		}

		function assertTSMappedType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSMappedType(node, opts = {}) {
		assert("TSMappedType", node, opts);
		}

		function assertTSLiteralType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSLiteralType(node, opts = {}) {
		assert("TSLiteralType", node, opts);
		}

		function assertTSExpressionWithTypeArguments(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSExpressionWithTypeArguments(node, opts = {}) {
		assert("TSExpressionWithTypeArguments", node, opts);
		}

		function assertTSInterfaceDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSInterfaceDeclaration(node, opts = {}) {
		assert("TSInterfaceDeclaration", node, opts);
		}

		function assertTSInterfaceBody(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSInterfaceBody(node, opts = {}) {
		assert("TSInterfaceBody", node, opts);
		}

		function assertTSTypeAliasDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeAliasDeclaration(node, opts = {}) {
		assert("TSTypeAliasDeclaration", node, opts);
		}

		function assertTSAsExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSAsExpression(node, opts = {}) {
		assert("TSAsExpression", node, opts);
		}

		function assertTSTypeAssertion(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeAssertion(node, opts = {}) {
		assert("TSTypeAssertion", node, opts);
		}

		function assertTSEnumDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSEnumDeclaration(node, opts = {}) {
		assert("TSEnumDeclaration", node, opts);
		}

		function assertTSEnumMember(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSEnumMember(node, opts = {}) {
		assert("TSEnumMember", node, opts);
		}

		function assertTSModuleDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSModuleDeclaration(node, opts = {}) {
		assert("TSModuleDeclaration", node, opts);
		}

		function assertTSModuleBlock(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSModuleBlock(node, opts = {}) {
		assert("TSModuleBlock", node, opts);
		}

		function assertTSImportEqualsDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSImportEqualsDeclaration(node, opts = {}) {
		assert("TSImportEqualsDeclaration", node, opts);
		}

		function assertTSExternalModuleReference(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSExternalModuleReference(node, opts = {}) {
		assert("TSExternalModuleReference", node, opts);
		}

		function assertTSNonNullExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSNonNullExpression(node, opts = {}) {
		assert("TSNonNullExpression", node, opts);
		}

		function assertTSExportAssignment(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSExportAssignment(node, opts = {}) {
		assert("TSExportAssignment", node, opts);
		}

		function assertTSNamespaceExportDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSNamespaceExportDeclaration(node, opts = {}) {
		assert("TSNamespaceExportDeclaration", node, opts);
		}

		function assertTSTypeAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeAnnotation(node, opts = {}) {
		assert("TSTypeAnnotation", node, opts);
		}

		function assertTSTypeParameterInstantiation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeParameterInstantiation(node, opts = {}) {
		assert("TSTypeParameterInstantiation", node, opts);
		}

		function assertTSTypeParameterDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeParameterDeclaration(node, opts = {}) {
		assert("TSTypeParameterDeclaration", node, opts);
		}

		function assertTSTypeParameter(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeParameter(node, opts = {}) {
		assert("TSTypeParameter", node, opts);
		}

		function assertExpression(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExpression(node, opts = {}) {
		assert("Expression", node, opts);
		}

		function assertBinary(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertBinary(node, opts = {}) {
		assert("Binary", node, opts);
		}

		function assertScopable(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertScopable(node, opts = {}) {
		assert("Scopable", node, opts);
		}

		function assertBlockParent(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertBlockParent(node, opts = {}) {
		assert("BlockParent", node, opts);
		}

		function assertBlock(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertBlock(node, opts = {}) {
		assert("Block", node, opts);
		}

		function assertStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertStatement(node, opts = {}) {
		assert("Statement", node, opts);
		}

		function assertTerminatorless(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTerminatorless(node, opts = {}) {
		assert("Terminatorless", node, opts);
		}

		function assertCompletionStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertCompletionStatement(node, opts = {}) {
		assert("CompletionStatement", node, opts);
		}

		function assertConditional(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertConditional(node, opts = {}) {
		assert("Conditional", node, opts);
		}

		function assertLoop(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertLoop(node, opts = {}) {
		assert("Loop", node, opts);
		}

		function assertWhile(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertWhile(node, opts = {}) {
		assert("While", node, opts);
		}

		function assertExpressionWrapper(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExpressionWrapper(node, opts = {}) {
		assert("ExpressionWrapper", node, opts);
		}

		function assertFor(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFor(node, opts = {}) {
		assert("For", node, opts);
		}

		function assertForXStatement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertForXStatement(node, opts = {}) {
		assert("ForXStatement", node, opts);
		}

		function assertFunction(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFunction(node, opts = {}) {
		assert("Function", node, opts);
		}

		function assertFunctionParent(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFunctionParent(node, opts = {}) {
		assert("FunctionParent", node, opts);
		}

		function assertPureish(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertPureish(node, opts = {}) {
		assert("Pureish", node, opts);
		}

		function assertDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertDeclaration(node, opts = {}) {
		assert("Declaration", node, opts);
		}

		function assertPatternLike(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertPatternLike(node, opts = {}) {
		assert("PatternLike", node, opts);
		}

		function assertLVal(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertLVal(node, opts = {}) {
		assert("LVal", node, opts);
		}

		function assertTSEntityName(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSEntityName(node, opts = {}) {
		assert("TSEntityName", node, opts);
		}

		function assertLiteral(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertLiteral(node, opts = {}) {
		assert("Literal", node, opts);
		}

		function assertImmutable(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertImmutable(node, opts = {}) {
		assert("Immutable", node, opts);
		}

		function assertUserWhitespacable(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertUserWhitespacable(node, opts = {}) {
		assert("UserWhitespacable", node, opts);
		}

		function assertMethod(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertMethod(node, opts = {}) {
		assert("Method", node, opts);
		}

		function assertObjectMember(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertObjectMember(node, opts = {}) {
		assert("ObjectMember", node, opts);
		}

		function assertProperty(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertProperty(node, opts = {}) {
		assert("Property", node, opts);
		}

		function assertUnaryLike(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertUnaryLike(node, opts = {}) {
		assert("UnaryLike", node, opts);
		}

		function assertPattern(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertPattern(node, opts = {}) {
		assert("Pattern", node, opts);
		}

		function assertClass(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertClass(node, opts = {}) {
		assert("Class", node, opts);
		}

		function assertModuleDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertModuleDeclaration(node, opts = {}) {
		assert("ModuleDeclaration", node, opts);
		}

		function assertExportDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertExportDeclaration(node, opts = {}) {
		assert("ExportDeclaration", node, opts);
		}

		function assertModuleSpecifier(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertModuleSpecifier(node, opts = {}) {
		assert("ModuleSpecifier", node, opts);
		}

		function assertFlow(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFlow(node, opts = {}) {
		assert("Flow", node, opts);
		}

		function assertFlowType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFlowType(node, opts = {}) {
		assert("FlowType", node, opts);
		}

		function assertFlowBaseAnnotation(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFlowBaseAnnotation(node, opts = {}) {
		assert("FlowBaseAnnotation", node, opts);
		}

		function assertFlowDeclaration(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFlowDeclaration(node, opts = {}) {
		assert("FlowDeclaration", node, opts);
		}

		function assertFlowPredicate(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertFlowPredicate(node, opts = {}) {
		assert("FlowPredicate", node, opts);
		}

		function assertJSX(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertJSX(node, opts = {}) {
		assert("JSX", node, opts);
		}

		function assertTSTypeElement(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSTypeElement(node, opts = {}) {
		assert("TSTypeElement", node, opts);
		}

		function assertTSType(node, opts) {
		if (opts === void 0) {
		opts = {};
		}

		function assertTSType(node, opts = {}) {
		assert("TSType", node, opts);
		@@ -2250,0 +1260,0 @@ }

lib/builders/builder.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = builder;

		var _clone = _interopRequireDefault(require("lodash/clone"));
		function _clone() {
		const data = _interopRequireDefault(require("lodash/clone"));

		_clone = function () {
		return data;
		};

		return data;
		}

		var _definitions = require("../definitions");
		@@ -14,23 +24,19 @@

		function builder(type) {
		for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
		args[_key - 1] = arguments[_key];
		}
		function builder(type, ...args) {
		const keys = _definitions.BUILDER_KEYS[type];
		const countArgs = args.length;

		var keys = _definitions.BUILDER_KEYS[type];
		var countArgs = args.length;

		if (countArgs > keys.length) {
		throw new Error(type + ": Too many arguments passed. Received " + countArgs + " but can receive no more than " + keys.length);
		throw new Error(`${type}: Too many arguments passed. Received ${countArgs} but can receive no more than ${keys.length}`);
		}

		var node = {
		type: type
		const node = {
		type
		};
		var i = 0;
		keys.forEach(function (key) {
		var field = _definitions.NODE_FIELDS[type][key];
		var arg;
		let i = 0;
		keys.forEach(key => {
		const field = _definitions.NODE_FIELDS[type][key];
		let arg;
		if (i < countArgs) arg = args[i];
		if (arg === undefined) arg = (0, _clone.default)(field.default);
		if (arg === undefined) arg = (0, _clone().default)(field.default);
		node[key] = arg;
		@@ -40,3 +46,3 @@ i++;

		for (var key in node) {
		for (const key in node) {
		(0, _validate.default)(node, key, node[key]);
		@@ -43,0 +49,0 @@ }

lib/builders/flow/createTypeAnnotationBasedOnTypeof.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = createTypeAnnotationBasedOnTypeof;
		@@ -5,0 +7,0 @@

lib/builders/flow/createUnionTypeAnnotation.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = createUnionTypeAnnotation;
		@@ -13,3 +15,3 @@
		function createUnionTypeAnnotation(types) {
		var flattened = (0, _removeTypeDuplicates.default)(types);
		const flattened = (0, _removeTypeDuplicates.default)(types);

		@@ -16,0 +18,0 @@ if (flattened.length === 1) {

lib/builders/react/buildChildren.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = buildChildren;
		@@ -13,6 +15,6 @@
		function buildChildren(node) {
		var elements = [];
		const elements = [];

		for (var i = 0; i < node.children.length; i++) {
		var child = node.children[i];
		for (let i = 0; i < node.children.length; i++) {
		let child = node.children[i];

		@@ -19,0 +21,0 @@ if ((0, _generated.isJSXText)(child)) {

lib/clone/clone.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = clone;
		@@ -5,0 +7,0 @@

lib/clone/cloneDeep.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = cloneDeep;
		@@ -5,0 +7,0 @@

lib/clone/cloneNode.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = cloneNode;
		@@ -8,3 +10,3 @@

		var has = Function.call.bind(Object.prototype.hasOwnProperty);
		const has = Function.call.bind(Object.prototype.hasOwnProperty);

		@@ -21,5 +23,3 @@ function cloneIfNode(obj, deep) {
		if (Array.isArray(obj)) {
		return obj.map(function (node) {
		return cloneIfNode(node, deep);
		});
		return obj.map(node => cloneIfNode(node, deep));
		}
		@@ -30,11 +30,9 @@

		function cloneNode(node, deep) {
		if (deep === void 0) {
		deep = true;
		}

		function cloneNode(node, deep = true) {
		if (!node) return node;
		var type = node.type;
		var newNode = {
		type: type
		const {
		type
		} = node;
		const newNode = {
		type
		};
		@@ -45,9 +43,5 @@
		} else if (!has(_definitions.NODE_FIELDS, type)) {
		throw new Error("Unknown node type: \"" + type + "\"");
		throw new Error(`Unknown node type: "${type}"`);
		} else {
		var _arr = Object.keys(_definitions.NODE_FIELDS[type]);

		for (var _i = 0; _i < _arr.length; _i++) {
		var field = _arr[_i];

		for (const field of Object.keys(_definitions.NODE_FIELDS[type])) {
		if (has(node, field)) {
		@@ -54,0 +48,0 @@ newNode[field] = deep ? cloneIfNodeOrArray(node[field], true) : node[field];

lib/clone/cloneWithoutLoc.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = cloneWithoutLoc;
		@@ -11,5 +13,5 @@
		function cloneWithoutLoc(node) {
		var newNode = (0, _clone.default)(node);
		const newNode = (0, _clone.default)(node);
		newNode.loc = null;
		return newNode;
		}

lib/comments/addComment.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = addComment;
		@@ -5,0 +7,0 @@

lib/comments/addComments.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = addComments;
		@@ -8,3 +10,3 @@
		if (!comments \|\| !node) return node;
		var key = type + "Comments";
		const key = `${type}Comments`;

		@@ -11,0 +13,0 @@ if (node[key]) {

lib/comments/inheritInnerComments.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = inheritInnerComments;
		@@ -5,0 +7,0 @@

lib/comments/inheritLeadingComments.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = inheritLeadingComments;
		@@ -5,0 +7,0 @@

lib/comments/inheritsComments.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = inheritsComments;
		@@ -5,0 +7,0 @@

lib/comments/inheritTrailingComments.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = inheritTrailingComments;
		@@ -5,0 +7,0 @@

lib/comments/removeComments.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = removeComments;
		@@ -9,3 +11,3 @@
		function removeComments(node) {
		_constants.COMMENT_KEYS.forEach(function (key) {
		_constants.COMMENT_KEYS.forEach(key => {
		node[key] = null;
		@@ -12,0 +14,0 @@ });

lib/constants/generated/index.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.JSX_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.FLOWTYPE_TYPES = exports.FLOW_TYPES = exports.MODULESPECIFIER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.MODULEDECLARATION_TYPES = exports.CLASS_TYPES = exports.PATTERN_TYPES = exports.UNARYLIKE_TYPES = exports.PROPERTY_TYPES = exports.OBJECTMEMBER_TYPES = exports.METHOD_TYPES = exports.USERWHITESPACABLE_TYPES = exports.IMMUTABLE_TYPES = exports.LITERAL_TYPES = exports.TSENTITYNAME_TYPES = exports.LVAL_TYPES = exports.PATTERNLIKE_TYPES = exports.DECLARATION_TYPES = exports.PUREISH_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FUNCTION_TYPES = exports.FORXSTATEMENT_TYPES = exports.FOR_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.WHILE_TYPES = exports.LOOP_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.SCOPABLE_TYPES = exports.BINARY_TYPES = exports.EXPRESSION_TYPES = void 0;
		@@ -8,83 +10,83 @@

		var EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"];
		const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"];
		exports.EXPRESSION_TYPES = EXPRESSION_TYPES;
		var BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"];
		const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"];
		exports.BINARY_TYPES = BINARY_TYPES;
		var SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"];
		const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"];
		exports.SCOPABLE_TYPES = SCOPABLE_TYPES;
		var BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"];
		const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"];
		exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES;
		var BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"];
		const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"];
		exports.BLOCK_TYPES = BLOCK_TYPES;
		var STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"];
		const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"];
		exports.STATEMENT_TYPES = STATEMENT_TYPES;
		var TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"];
		const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"];
		exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES;
		var COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"];
		const COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"];
		exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES;
		var CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"];
		const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"];
		exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES;
		var LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"];
		const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"];
		exports.LOOP_TYPES = LOOP_TYPES;
		var WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"];
		const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"];
		exports.WHILE_TYPES = WHILE_TYPES;
		var EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
		const EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
		exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES;
		var FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"];
		const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"];
		exports.FOR_TYPES = FOR_TYPES;
		var FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"];
		const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"];
		exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES;
		var FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"];
		const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"];
		exports.FUNCTION_TYPES = FUNCTION_TYPES;
		var FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"];
		const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"];
		exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES;
		var PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"];
		const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"];
		exports.PUREISH_TYPES = PUREISH_TYPES;
		var DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"];
		const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"];
		exports.DECLARATION_TYPES = DECLARATION_TYPES;
		var PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"];
		const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"];
		exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES;
		var LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"];
		const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"];
		exports.LVAL_TYPES = LVAL_TYPES;
		var TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"];
		const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"];
		exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES;
		var LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"];
		const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"];
		exports.LITERAL_TYPES = LITERAL_TYPES;
		var IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"];
		const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"];
		exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES;
		var USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
		const USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
		exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES;
		var METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"];
		const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"];
		exports.METHOD_TYPES = METHOD_TYPES;
		var OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"];
		const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"];
		exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES;
		var PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"];
		const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"];
		exports.PROPERTY_TYPES = PROPERTY_TYPES;
		var UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"];
		const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"];
		exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES;
		var PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"];
		const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"];
		exports.PATTERN_TYPES = PATTERN_TYPES;
		var CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"];
		const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"];
		exports.CLASS_TYPES = CLASS_TYPES;
		var MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"];
		const MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"];
		exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES;
		var EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
		const EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
		exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES;
		var MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
		const MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
		exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES;
		var FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"];
		const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"];
		exports.FLOW_TYPES = FLOW_TYPES;
		var FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"];
		const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"];
		exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES;
		var FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
		const FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
		exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES;
		var FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
		const FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
		exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES;
		var FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"];
		const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"];
		exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES;
		var JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"];
		const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"];
		exports.JSX_TYPES = JSX_TYPES;
		var TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"];
		const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"];
		exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES;
		var TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"];
		const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"];
		exports.TSTYPE_TYPES = TSTYPE_TYPES;

lib/constants/index.js

		"use strict";

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

lib/converters/ensureBlock.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = ensureBlock;
		@@ -10,8 +12,4 @@

		function ensureBlock(node, key) {
		if (key === void 0) {
		key = "body";
		}

		function ensureBlock(node, key = "body") {
		return node[key] = (0, _toBlock.default)(node[key], node);
		}

lib/converters/gatherSequenceExpressions.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = gatherSequenceExpressions;
		@@ -17,35 +19,21 @@
		function gatherSequenceExpressions(nodes, scope, declars) {
		var exprs = [];
		var ensureLastUndefined = true;
		const exprs = [];
		let ensureLastUndefined = true;

		for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
		var _ref;

		if (_isArray) {
		if (_i >= _iterator.length) break;
		_ref = _iterator[_i++];
		} else {
		_i = _iterator.next();
		if (_i.done) break;
		_ref = _i.value;
		}

		var _node = _ref;
		for (const node of nodes) {
		ensureLastUndefined = false;

		if ((0, _generated.isExpression)(_node)) {
		exprs.push(_node);
		} else if ((0, _generated.isExpressionStatement)(_node)) {
		exprs.push(_node.expression);
		} else if ((0, _generated.isVariableDeclaration)(_node)) {
		if (_node.kind !== "var") return;
		var _arr = _node.declarations;
		if ((0, _generated.isExpression)(node)) {
		exprs.push(node);
		} else if ((0, _generated.isExpressionStatement)(node)) {
		exprs.push(node.expression);
		} else if ((0, _generated.isVariableDeclaration)(node)) {
		if (node.kind !== "var") return;

		for (var _i2 = 0; _i2 < _arr.length; _i2++) {
		var declar = _arr[_i2];
		var bindings = (0, _getBindingIdentifiers.default)(declar);
		for (const declar of node.declarations) {
		const bindings = (0, _getBindingIdentifiers.default)(declar);

		for (var key in bindings) {
		for (const key in bindings) {
		declars.push({
		kind: _node.kind,
		kind: node.kind,
		id: (0, _cloneNode.default)(bindings[key])
		@@ -61,12 +49,12 @@ });
		ensureLastUndefined = true;
		} else if ((0, _generated.isIfStatement)(_node)) {
		var consequent = _node.consequent ? gatherSequenceExpressions([_node.consequent], scope, declars) : scope.buildUndefinedNode();
		var alternate = _node.alternate ? gatherSequenceExpressions([_node.alternate], scope, declars) : scope.buildUndefinedNode();
		} else if ((0, _generated.isIfStatement)(node)) {
		const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode();
		const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
		if (!consequent \|\| !alternate) return;
		exprs.push((0, _generated2.conditionalExpression)(_node.test, consequent, alternate));
		} else if ((0, _generated.isBlockStatement)(_node)) {
		var body = gatherSequenceExpressions(_node.body, scope, declars);
		exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate));
		} else if ((0, _generated.isBlockStatement)(node)) {
		const body = gatherSequenceExpressions(node.body, scope, declars);
		if (!body) return;
		exprs.push(body);
		} else if ((0, _generated.isEmptyStatement)(_node)) {
		} else if ((0, _generated.isEmptyStatement)(node)) {
		ensureLastUndefined = true;
		@@ -73,0 +61,0 @@ } else {

lib/converters/toBindingIdentifierName.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = toBindingIdentifierName;
		@@ -5,0 +7,0 @@

lib/converters/toBlock.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = toBlock;
		@@ -15,3 +17,3 @@

		var blockNodes = [];
		let blockNodes = [];

		@@ -18,0 +20,0 @@ if ((0, _generated.isEmptyStatement)(node)) {

lib/converters/toComputedKey.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = toComputedKey;
		@@ -10,9 +12,5 @@

		function toComputedKey(node, key) {
		if (key === void 0) {
		key = node.key \|\| node.property;
		}

		function toComputedKey(node, key = node.key \|\| node.property) {
		if (!node.computed && (0, _generated.isIdentifier)(key)) key = (0, _generated2.stringLiteral)(key.name);
		return key;
		}

lib/converters/toExpression.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = toExpression;
		@@ -24,3 +26,3 @@
		if (!(0, _generated.isExpression)(node)) {
		throw new Error("cannot turn " + node.type + " to an expression");
		throw new Error(`cannot turn ${node.type} to an expression`);
		}
		@@ -27,0 +29,0 @@

lib/converters/toIdentifier.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = toIdentifier;
		@@ -19,3 +21,3 @@
		if (!(0, _isValidIdentifier.default)(name)) {
		name = "_" + name;
		name = `_${name}`;
		}
		@@ -22,0 +24,0 @@

lib/converters/toKeyAlias.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = toKeyAlias;
		@@ -14,9 +16,5 @@

		function toKeyAlias(node, key) {
		if (key === void 0) {
		key = node.key;
		}
		function toKeyAlias(node, key = node.key) {
		let alias;

		var alias;

		if (node.kind === "method") {
		@@ -33,7 +31,7 @@ return toKeyAlias.increment() + "";
		if (node.computed) {
		alias = "[" + alias + "]";
		alias = `[${alias}]`;
		}

		if (node.static) {
		alias = "static:" + alias;
		alias = `static:${alias}`;
		}
		@@ -40,0 +38,0 @@

lib/converters/toSequenceExpression.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = toSequenceExpression;
		@@ -12,8 +14,7 @@
		if (!nodes \|\| !nodes.length) return;
		var declars = [];
		var result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars);
		const declars = [];
		const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars);
		if (!result) return;

		for (var _i = 0; _i < declars.length; _i++) {
		var declar = declars[_i];
		for (const declar of declars) {
		scope.push(declar);
		@@ -20,0 +21,0 @@ }

lib/converters/toStatement.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = toStatement;
		@@ -15,4 +17,4 @@

		var mustHaveId = false;
		var newType;
		let mustHaveId = false;
		let newType;

		@@ -37,3 +39,3 @@ if ((0, _generated.isClass)(node)) {
		} else {
		throw new Error("cannot turn " + node.type + " to a statement");
		throw new Error(`cannot turn ${node.type} to a statement`);
		}
		@@ -40,0 +42,0 @@ }

lib/converters/valueToNode.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = valueToNode;

		var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));
		function _isPlainObject() {
		const data = _interopRequireDefault(require("lodash/isPlainObject"));

		var _isRegExp = _interopRequireDefault(require("lodash/isRegExp"));
		_isPlainObject = function () {
		return data;
		};

		return data;
		}

		function _isRegExp() {
		const data = _interopRequireDefault(require("lodash/isRegExp"));

		_isRegExp = function () {
		return data;
		};

		return data;
		}

		var _isValidIdentifier = _interopRequireDefault(require("../validators/isValidIdentifier"));
		@@ -37,5 +55,5 @@

		if ((0, _isRegExp.default)(value)) {
		var pattern = value.source;
		var flags = value.toString().match(/\/([a-z]+\|)$/)[1];
		if ((0, _isRegExp().default)(value)) {
		const pattern = value.source;
		const flags = value.toString().match(/\/([a-z]+\|)$/)[1];
		return (0, _generated.regExpLiteral)(pattern, flags);
		@@ -48,7 +66,7 @@ }

		if ((0, _isPlainObject.default)(value)) {
		var props = [];
		if ((0, _isPlainObject().default)(value)) {
		const props = [];

		for (var key in value) {
		var nodeKey = void 0;
		for (const key in value) {
		let nodeKey;

		@@ -55,0 +73,0 @@ if ((0, _isValidIdentifier.default)(key)) {

lib/definitions/core.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.patternLikeCommon = exports.functionDeclarationCommon = exports.functionTypeAnnotationCommon = exports.functionCommon = void 0;
		@@ -50,3 +52,3 @@
		operator: {
		validate: _utils.assertOneOf.apply(void 0, _constants.BINARY_OPERATORS)
		validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS)
		},
		@@ -234,3 +236,3 @@ left: {
		});
		var functionCommon = {
		const functionCommon = {
		params: {
		@@ -249,3 +251,3 @@ validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("LVal")))
		exports.functionCommon = functionCommon;
		var functionTypeAnnotationCommon = {
		const functionTypeAnnotationCommon = {
		returnType: {
		@@ -262,3 +264,3 @@ validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),

		var functionDeclarationCommon = _objectSpread({}, functionCommon, {
		const functionDeclarationCommon = _objectSpread({}, functionCommon, {
		declare: {
		@@ -298,3 +300,3 @@ validate: (0, _utils.assertValueType)("boolean"),
		});
		var patternLikeCommon = {
		const patternLikeCommon = {
		typeAnnotation: {
		@@ -404,3 +406,3 @@ validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
		operator: {
		validate: _utils.assertOneOf.apply(void 0, _constants.LOGICAL_OPERATORS)
		validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS)
		},
		@@ -425,6 +427,6 @@ left: {
		validate: function () {
		var normal = (0, _utils.assertNodeType)("Identifier");
		var computed = (0, _utils.assertNodeType)("Expression");
		const normal = (0, _utils.assertNodeType)("Identifier");
		const computed = (0, _utils.assertNodeType)("Expression");
		return function (node, key, val) {
		var validator = node.computed ? computed : normal;
		const validator = node.computed ? computed : normal;
		validator(node, key, val);
		@@ -489,6 +491,6 @@ };
		validate: function () {
		var normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
		var computed = (0, _utils.assertNodeType)("Expression");
		const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
		const computed = (0, _utils.assertNodeType)("Expression");
		return function (node, key, val) {
		var validator = node.computed ? computed : normal;
		const validator = node.computed ? computed : normal;
		validator(node, key, val);
		@@ -517,6 +519,6 @@ };
		validate: function () {
		var normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
		var computed = (0, _utils.assertNodeType)("Expression");
		const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
		const computed = (0, _utils.assertNodeType)("Expression");
		return function (node, key, val) {
		var validator = node.computed ? computed : normal;
		const validator = node.computed ? computed : normal;
		validator(node, key, val);
		@@ -634,3 +636,3 @@ };
		operator: {
		validate: _utils.assertOneOf.apply(void 0, _constants.UNARY_OPERATORS)
		validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS)
		}
		@@ -651,3 +653,3 @@ },
		operator: {
		validate: _utils.assertOneOf.apply(void 0, _constants.UPDATE_OPERATORS)
		validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
		}
		@@ -654,0 +656,0 @@ },

lib/definitions/es2015.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = void 0;
		@@ -66,3 +68,3 @@
		});
		var classCommon = {
		const classCommon = {
		typeParameters: {
		@@ -255,3 +257,3 @@ validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
		});
		var classMethodOrPropertyCommon = {
		const classMethodOrPropertyCommon = {
		abstract: {
		@@ -279,6 +281,6 @@ validate: (0, _utils.assertValueType)("boolean"),
		validate: (0, _utils.chain)(function () {
		var normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
		var computed = (0, _utils.assertNodeType)("Expression");
		const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
		const computed = (0, _utils.assertNodeType)("Expression");
		return function (node, key, val) {
		var validator = node.computed ? computed : normal;
		const validator = node.computed ? computed : normal;
		validator(node, key, val);
		@@ -291,3 +293,3 @@ };

		var classMethodOrDeclareMethodCommon = _objectSpread({}, _core.functionCommon, classMethodOrPropertyCommon, {
		const classMethodOrDeclareMethodCommon = _objectSpread({}, _core.functionCommon, classMethodOrPropertyCommon, {
		kind: {
		@@ -294,0 +296,0 @@ validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("get", "set", "method", "constructor")),

lib/definitions/experimental.js

		@@ -65,6 +65,6 @@ "use strict";
		validate: function () {
		var normal = (0, _utils.assertNodeType)("Identifier");
		var computed = (0, _utils.assertNodeType)("Expression");
		const normal = (0, _utils.assertNodeType)("Identifier");
		const computed = (0, _utils.assertNodeType)("Expression");
		return function (node, key, val) {
		var validator = node.computed ? computed : normal;
		const validator = node.computed ? computed : normal;
		validator(node, key, val);
		@@ -71,0 +71,0 @@ };

lib/definitions/flow.js

		@@ -252,3 +252,3 @@ "use strict";
		fields: {
		key: (0, _utils.validateType)("Identifier"),
		key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
		value: (0, _utils.validateType)("FlowType"),
		@@ -255,0 +255,0 @@ kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),

lib/definitions/index.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		Object.defineProperty(exports, "VISITOR_KEYS", {
		enumerable: true,
		get: function () {
		return _utils.VISITOR_KEYS;
		}
		});
		Object.defineProperty(exports, "ALIAS_KEYS", {
		enumerable: true,
		get: function () {
		return _utils.ALIAS_KEYS;
		}
		});
		Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
		enumerable: true,
		get: function () {
		return _utils.FLIPPED_ALIAS_KEYS;
		}
		});
		Object.defineProperty(exports, "NODE_FIELDS", {
		enumerable: true,
		get: function () {
		return _utils.NODE_FIELDS;
		}
		});
		Object.defineProperty(exports, "BUILDER_KEYS", {
		enumerable: true,
		get: function () {
		return _utils.BUILDER_KEYS;
		}
		});
		Object.defineProperty(exports, "DEPRECATED_KEYS", {
		enumerable: true,
		get: function () {
		return _utils.DEPRECATED_KEYS;
		}
		});
		exports.TYPES = void 0;

		var _toFastProperties = _interopRequireDefault(require("to-fast-properties"));
		function _toFastProperties() {
		const data = _interopRequireDefault(require("to-fast-properties"));

		_toFastProperties = function () {
		return data;
		};

		return data;
		}

		require("./core");
		@@ -24,18 +70,11 @@

		exports.VISITOR_KEYS = _utils.VISITOR_KEYS;
		exports.ALIAS_KEYS = _utils.ALIAS_KEYS;
		exports.FLIPPED_ALIAS_KEYS = _utils.FLIPPED_ALIAS_KEYS;
		exports.NODE_FIELDS = _utils.NODE_FIELDS;
		exports.BUILDER_KEYS = _utils.BUILDER_KEYS;
		exports.DEPRECATED_KEYS = _utils.DEPRECATED_KEYS;

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		(0, _toFastProperties.default)(_utils.VISITOR_KEYS);
		(0, _toFastProperties.default)(_utils.ALIAS_KEYS);
		(0, _toFastProperties.default)(_utils.FLIPPED_ALIAS_KEYS);
		(0, _toFastProperties.default)(_utils.NODE_FIELDS);
		(0, _toFastProperties.default)(_utils.BUILDER_KEYS);
		(0, _toFastProperties.default)(_utils.DEPRECATED_KEYS);
		var TYPES = Object.keys(_utils.VISITOR_KEYS).concat(Object.keys(_utils.FLIPPED_ALIAS_KEYS)).concat(Object.keys(_utils.DEPRECATED_KEYS));
		(0, _toFastProperties().default)(_utils.VISITOR_KEYS);
		(0, _toFastProperties().default)(_utils.ALIAS_KEYS);
		(0, _toFastProperties().default)(_utils.FLIPPED_ALIAS_KEYS);
		(0, _toFastProperties().default)(_utils.NODE_FIELDS);
		(0, _toFastProperties().default)(_utils.BUILDER_KEYS);
		(0, _toFastProperties().default)(_utils.DEPRECATED_KEYS);
		const TYPES = Object.keys(_utils.VISITOR_KEYS).concat(Object.keys(_utils.FLIPPED_ALIAS_KEYS)).concat(Object.keys(_utils.DEPRECATED_KEYS));
		exports.TYPES = TYPES;

lib/definitions/typescript.js

		@@ -15,4 +15,4 @@ "use strict";

		var bool = (0, _utils.assertValueType)("boolean");
		var tSFunctionTypeAnnotationCommon = {
		const bool = (0, _utils.assertValueType)("boolean");
		const tSFunctionTypeAnnotationCommon = {
		returnType: {
		@@ -61,3 +61,3 @@ validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
		});
		var signatureDeclarationCommon = {
		const signatureDeclarationCommon = {
		typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
		@@ -67,3 +67,3 @@ parameters: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
		};
		var callConstructSignatureDeclaration = {
		const callConstructSignatureDeclaration = {
		aliases: ["TSTypeElement"],
		@@ -75,3 +75,3 @@ visitor: ["typeParameters", "parameters", "typeAnnotation"],
		(0, _utils.default)("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
		var namedTypeElementCommon = {
		const namedTypeElementCommon = {
		key: (0, _utils.validateType)("Expression"),
		@@ -104,6 +104,5 @@ computed: (0, _utils.validate)(bool),
		});
		var tsKeywordTypes = ["TSAnyKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSBooleanKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSVoidKeyword", "TSUndefinedKeyword", "TSNullKeyword", "TSNeverKeyword"];
		const tsKeywordTypes = ["TSAnyKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSBooleanKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSVoidKeyword", "TSUndefinedKeyword", "TSNullKeyword", "TSNeverKeyword"];

		for (var _i = 0; _i < tsKeywordTypes.length; _i++) {
		var type = tsKeywordTypes[_i];
		for (const type of tsKeywordTypes) {
		(0, _utils.default)(type, {
		@@ -121,3 +120,3 @@ aliases: ["TSType"],
		});
		var fnOrCtr = {
		const fnOrCtr = {
		aliases: ["TSType"],
		@@ -173,3 +172,3 @@ visitor: ["typeParameters", "typeAnnotation"],
		});
		var unionOrIntersection = {
		const unionOrIntersection = {
		aliases: ["TSType"],
		@@ -176,0 +175,0 @@ visitor: ["types"],

110

lib/definitions/utils.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.validate = validate;
		@@ -25,13 +27,13 @@ exports.typeIs = typeIs;

		var VISITOR_KEYS = {};
		const VISITOR_KEYS = {};
		exports.VISITOR_KEYS = VISITOR_KEYS;
		var ALIAS_KEYS = {};
		const ALIAS_KEYS = {};
		exports.ALIAS_KEYS = ALIAS_KEYS;
		var FLIPPED_ALIAS_KEYS = {};
		const FLIPPED_ALIAS_KEYS = {};
		exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
		var NODE_FIELDS = {};
		const NODE_FIELDS = {};
		exports.NODE_FIELDS = NODE_FIELDS;
		var BUILDER_KEYS = {};
		const BUILDER_KEYS = {};
		exports.BUILDER_KEYS = BUILDER_KEYS;
		var DEPRECATED_KEYS = {};
		const DEPRECATED_KEYS = {};
		exports.DEPRECATED_KEYS = DEPRECATED_KEYS;
		@@ -53,3 +55,3 @@
		return {
		validate: validate
		validate
		};
		@@ -59,3 +61,3 @@ }
		function typeIs(typeName) {
		return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType.apply(void 0, typeName);
		return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
		}
		@@ -69,3 +71,3 @@
		return {
		validate: validate,
		validate,
		optional: true
		@@ -98,4 +100,4 @@ };

		for (var i = 0; i < val.length; i++) {
		callback(node, key + "[" + i + "]", val[i]);
		for (let i = 0; i < val.length; i++) {
		callback(node, `${key}[${i}]`, val[i]);
		}
		@@ -108,10 +110,6 @@ }

		function assertOneOf() {
		for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
		values[_key] = arguments[_key];
		}

		function assertOneOf(...values) {
		function validate(node, key, val) {
		if (values.indexOf(val) < 0) {
		throw new TypeError("Property " + key + " expected value to be one of " + JSON.stringify(values) + " but got " + JSON.stringify(val));
		throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
		}
		@@ -124,13 +122,7 @@ }

		function assertNodeType() {
		for (var _len2 = arguments.length, types = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
		types[_key2] = arguments[_key2];
		}

		function assertNodeType(...types) {
		function validate(node, key, val) {
		var valid = false;
		let valid = false;

		for (var _i = 0; _i < types.length; _i++) {
		var type = types[_i];

		for (const type of types) {
		if ((0, _is.default)(type, val)) {
		@@ -143,3 +135,3 @@ valid = true;
		if (!valid) {
		throw new TypeError("Property " + key + " of " + node.type + " expected node to be of a type " + JSON.stringify(types) + " " + ("but instead got " + JSON.stringify(val && val.type)));
		throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} ` + `but instead got ${JSON.stringify(val && val.type)}`);
		}
		@@ -152,13 +144,7 @@ }

		function assertNodeOrValueType() {
		for (var _len3 = arguments.length, types = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
		types[_key3] = arguments[_key3];
		}

		function assertNodeOrValueType(...types) {
		function validate(node, key, val) {
		var valid = false;
		let valid = false;

		for (var _i2 = 0; _i2 < types.length; _i2++) {
		var type = types[_i2];

		for (const type of types) {
		if (getType(val) === type \|\| (0, _is.default)(type, val)) {
		@@ -171,3 +157,3 @@ valid = true;
		if (!valid) {
		throw new TypeError("Property " + key + " of " + node.type + " expected node to be of a type " + JSON.stringify(types) + " " + ("but instead got " + JSON.stringify(val && val.type)));
		throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} ` + `but instead got ${JSON.stringify(val && val.type)}`);
		}
		@@ -182,6 +168,6 @@ }
		function validate(node, key, val) {
		var valid = getType(val) === type;
		const valid = getType(val) === type;

		if (!valid) {
		throw new TypeError("Property " + key + " expected type of " + type + " but got " + getType(val));
		throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
		}
		@@ -194,11 +180,6 @@ }

		function chain() {
		for (var _len4 = arguments.length, fns = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
		fns[_key4] = arguments[_key4];
		}

		function validate() {
		for (var _i3 = 0; _i3 < fns.length; _i3++) {
		var fn = fns[_i3];
		fn.apply(void 0, arguments);
		function chain(...fns) {
		function validate(...args) {
		for (const fn of fns) {
		fn(...args);
		}
		@@ -211,13 +192,9 @@ }

		function defineType(type, opts) {
		if (opts === void 0) {
		opts = {};
		}
		function defineType(type, opts = {}) {
		const inherits = opts.inherits && store[opts.inherits] \|\| {};
		const fields = opts.fields \|\| inherits.fields \|\| {};
		const visitor = opts.visitor \|\| inherits.visitor \|\| [];
		const aliases = opts.aliases \|\| inherits.aliases \|\| [];
		const builder = opts.builder \|\| inherits.builder \|\| opts.visitor \|\| [];

		var inherits = opts.inherits && store[opts.inherits] \|\| {};
		var fields = opts.fields \|\| inherits.fields \|\| {};
		var visitor = opts.visitor \|\| inherits.visitor \|\| [];
		var aliases = opts.aliases \|\| inherits.aliases \|\| [];
		var builder = opts.builder \|\| inherits.builder \|\| opts.visitor \|\| [];

		if (opts.deprecatedAlias) {
		@@ -227,13 +204,10 @@ DEPRECATED_KEYS[opts.deprecatedAlias] = type;

		var _arr = visitor.concat(builder);

		for (var _i4 = 0; _i4 < _arr.length; _i4++) {
		var key = _arr[_i4];
		for (const key of visitor.concat(builder)) {
		fields[key] = fields[key] \|\| {};
		}

		for (var _key5 in fields) {
		var field = fields[_key5];
		for (const key in fields) {
		const field = fields[key];

		if (builder.indexOf(_key5) === -1) {
		if (builder.indexOf(key) === -1) {
		field.optional = true;
		@@ -253,3 +227,3 @@ }
		ALIAS_KEYS[type] = opts.aliases = aliases;
		aliases.forEach(function (alias) {
		aliases.forEach(alias => {
		FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] \|\| [];
		@@ -261,2 +235,2 @@ FLIPPED_ALIAS_KEYS[alias].push(type);

		var store = {};
		const store = {};

470

lib/index.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		var _exportNames = {
		react: true,
		assertNode: true,
		@@ -56,6 +59,317 @@ createTypeAnnotationBasedOnTypeof: true,
		validate: true,
		buildMatchMemberExpression: true,
		react: true
		buildMatchMemberExpression: true
		};
		exports.react = exports.buildMatchMemberExpression = exports.validate = exports.matchesPattern = exports.isVar = exports.isValidIdentifier = exports.isValidES3Identifier = exports.isType = exports.isSpecifierDefault = exports.isScope = exports.isReferenced = exports.isNodesEquivalent = exports.isNode = exports.isLet = exports.isImmutable = exports.isBlockScoped = exports.isBinding = exports.is = exports.shallowEqual = exports.traverseFast = exports.traverse = exports.getOuterBindingIdentifiers = exports.getBindingIdentifiers = exports.removeTypeDuplicates = exports.removePropertiesDeep = exports.removeProperties = exports.prependToMemberExpression = exports.inherits = exports.appendToMemberExpression = exports.valueToNode = exports.toStatement = exports.toSequenceExpression = exports.toKeyAlias = exports.toIdentifier = exports.toExpression = exports.toComputedKey = exports.toBlock = exports.toBindingIdentifierName = exports.ensureBlock = exports.removeComments = exports.inheritTrailingComments = exports.inheritsComments = exports.inheritLeadingComments = exports.inheritInnerComments = exports.addComments = exports.addComment = exports.cloneWithoutLoc = exports.cloneDeep = exports.clone = exports.cloneNode = exports.createUnionTypeAnnotation = exports.createTypeAnnotationBasedOnTypeof = exports.assertNode = void 0;
		Object.defineProperty(exports, "assertNode", {
		enumerable: true,
		get: function () {
		return _assertNode.default;
		}
		});
		Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
		enumerable: true,
		get: function () {
		return _createTypeAnnotationBasedOnTypeof.default;
		}
		});
		Object.defineProperty(exports, "createUnionTypeAnnotation", {
		enumerable: true,
		get: function () {
		return _createUnionTypeAnnotation.default;
		}
		});
		Object.defineProperty(exports, "cloneNode", {
		enumerable: true,
		get: function () {
		return _cloneNode.default;
		}
		});
		Object.defineProperty(exports, "clone", {
		enumerable: true,
		get: function () {
		return _clone.default;
		}
		});
		Object.defineProperty(exports, "cloneDeep", {
		enumerable: true,
		get: function () {
		return _cloneDeep.default;
		}
		});
		Object.defineProperty(exports, "cloneWithoutLoc", {
		enumerable: true,
		get: function () {
		return _cloneWithoutLoc.default;
		}
		});
		Object.defineProperty(exports, "addComment", {
		enumerable: true,
		get: function () {
		return _addComment.default;
		}
		});
		Object.defineProperty(exports, "addComments", {
		enumerable: true,
		get: function () {
		return _addComments.default;
		}
		});
		Object.defineProperty(exports, "inheritInnerComments", {
		enumerable: true,
		get: function () {
		return _inheritInnerComments.default;
		}
		});
		Object.defineProperty(exports, "inheritLeadingComments", {
		enumerable: true,
		get: function () {
		return _inheritLeadingComments.default;
		}
		});
		Object.defineProperty(exports, "inheritsComments", {
		enumerable: true,
		get: function () {
		return _inheritsComments.default;
		}
		});
		Object.defineProperty(exports, "inheritTrailingComments", {
		enumerable: true,
		get: function () {
		return _inheritTrailingComments.default;
		}
		});
		Object.defineProperty(exports, "removeComments", {
		enumerable: true,
		get: function () {
		return _removeComments.default;
		}
		});
		Object.defineProperty(exports, "ensureBlock", {
		enumerable: true,
		get: function () {
		return _ensureBlock.default;
		}
		});
		Object.defineProperty(exports, "toBindingIdentifierName", {
		enumerable: true,
		get: function () {
		return _toBindingIdentifierName.default;
		}
		});
		Object.defineProperty(exports, "toBlock", {
		enumerable: true,
		get: function () {
		return _toBlock.default;
		}
		});
		Object.defineProperty(exports, "toComputedKey", {
		enumerable: true,
		get: function () {
		return _toComputedKey.default;
		}
		});
		Object.defineProperty(exports, "toExpression", {
		enumerable: true,
		get: function () {
		return _toExpression.default;
		}
		});
		Object.defineProperty(exports, "toIdentifier", {
		enumerable: true,
		get: function () {
		return _toIdentifier.default;
		}
		});
		Object.defineProperty(exports, "toKeyAlias", {
		enumerable: true,
		get: function () {
		return _toKeyAlias.default;
		}
		});
		Object.defineProperty(exports, "toSequenceExpression", {
		enumerable: true,
		get: function () {
		return _toSequenceExpression.default;
		}
		});
		Object.defineProperty(exports, "toStatement", {
		enumerable: true,
		get: function () {
		return _toStatement.default;
		}
		});
		Object.defineProperty(exports, "valueToNode", {
		enumerable: true,
		get: function () {
		return _valueToNode.default;
		}
		});
		Object.defineProperty(exports, "appendToMemberExpression", {
		enumerable: true,
		get: function () {
		return _appendToMemberExpression.default;
		}
		});
		Object.defineProperty(exports, "inherits", {
		enumerable: true,
		get: function () {
		return _inherits.default;
		}
		});
		Object.defineProperty(exports, "prependToMemberExpression", {
		enumerable: true,
		get: function () {
		return _prependToMemberExpression.default;
		}
		});
		Object.defineProperty(exports, "removeProperties", {
		enumerable: true,
		get: function () {
		return _removeProperties.default;
		}
		});
		Object.defineProperty(exports, "removePropertiesDeep", {
		enumerable: true,
		get: function () {
		return _removePropertiesDeep.default;
		}
		});
		Object.defineProperty(exports, "removeTypeDuplicates", {
		enumerable: true,
		get: function () {
		return _removeTypeDuplicates.default;
		}
		});
		Object.defineProperty(exports, "getBindingIdentifiers", {
		enumerable: true,
		get: function () {
		return _getBindingIdentifiers.default;
		}
		});
		Object.defineProperty(exports, "getOuterBindingIdentifiers", {
		enumerable: true,
		get: function () {
		return _getOuterBindingIdentifiers.default;
		}
		});
		Object.defineProperty(exports, "traverse", {
		enumerable: true,
		get: function () {
		return _traverse.default;
		}
		});
		Object.defineProperty(exports, "traverseFast", {
		enumerable: true,
		get: function () {
		return _traverseFast.default;
		}
		});
		Object.defineProperty(exports, "shallowEqual", {
		enumerable: true,
		get: function () {
		return _shallowEqual.default;
		}
		});
		Object.defineProperty(exports, "is", {
		enumerable: true,
		get: function () {
		return _is.default;
		}
		});
		Object.defineProperty(exports, "isBinding", {
		enumerable: true,
		get: function () {
		return _isBinding.default;
		}
		});
		Object.defineProperty(exports, "isBlockScoped", {
		enumerable: true,
		get: function () {
		return _isBlockScoped.default;
		}
		});
		Object.defineProperty(exports, "isImmutable", {
		enumerable: true,
		get: function () {
		return _isImmutable.default;
		}
		});
		Object.defineProperty(exports, "isLet", {
		enumerable: true,
		get: function () {
		return _isLet.default;
		}
		});
		Object.defineProperty(exports, "isNode", {
		enumerable: true,
		get: function () {
		return _isNode.default;
		}
		});
		Object.defineProperty(exports, "isNodesEquivalent", {
		enumerable: true,
		get: function () {
		return _isNodesEquivalent.default;
		}
		});
		Object.defineProperty(exports, "isReferenced", {
		enumerable: true,
		get: function () {
		return _isReferenced.default;
		}
		});
		Object.defineProperty(exports, "isScope", {
		enumerable: true,
		get: function () {
		return _isScope.default;
		}
		});
		Object.defineProperty(exports, "isSpecifierDefault", {
		enumerable: true,
		get: function () {
		return _isSpecifierDefault.default;
		}
		});
		Object.defineProperty(exports, "isType", {
		enumerable: true,
		get: function () {
		return _isType.default;
		}
		});
		Object.defineProperty(exports, "isValidES3Identifier", {
		enumerable: true,
		get: function () {
		return _isValidES3Identifier.default;
		}
		});
		Object.defineProperty(exports, "isValidIdentifier", {
		enumerable: true,
		get: function () {
		return _isValidIdentifier.default;
		}
		});
		Object.defineProperty(exports, "isVar", {
		enumerable: true,
		get: function () {
		return _isVar.default;
		}
		});
		Object.defineProperty(exports, "matchesPattern", {
		enumerable: true,
		get: function () {
		return _matchesPattern.default;
		}
		});
		Object.defineProperty(exports, "validate", {
		enumerable: true,
		get: function () {
		return _validate.default;
		}
		});
		Object.defineProperty(exports, "buildMatchMemberExpression", {
		enumerable: true,
		get: function () {
		return _buildMatchMemberExpression.default;
		}
		});
		exports.react = void 0;

		@@ -70,4 +384,2 @@ var _isReactComponent = _interopRequireDefault(require("./validators/react/isReactComponent"));

		exports.assertNode = _assertNode.default;

		var _generated = require("./asserts/generated");
		@@ -78,3 +390,8 @@
		if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
		exports[key] = _generated[key];
		Object.defineProperty(exports, key, {
		enumerable: true,
		get: function () {
		return _generated[key];
		}
		});
		});
		@@ -84,8 +401,4 @@

		exports.createTypeAnnotationBasedOnTypeof = _createTypeAnnotationBasedOnTypeof.default;

		var _createUnionTypeAnnotation = _interopRequireDefault(require("./builders/flow/createUnionTypeAnnotation"));

		exports.createUnionTypeAnnotation = _createUnionTypeAnnotation.default;

		var _generated2 = require("./builders/generated");
		@@ -96,3 +409,8 @@
		if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
		exports[key] = _generated2[key];
		Object.defineProperty(exports, key, {
		enumerable: true,
		get: function () {
		return _generated2[key];
		}
		});
		});
		@@ -102,44 +420,22 @@

		exports.cloneNode = _cloneNode.default;

		var _clone = _interopRequireDefault(require("./clone/clone"));

		exports.clone = _clone.default;

		var _cloneDeep = _interopRequireDefault(require("./clone/cloneDeep"));

		exports.cloneDeep = _cloneDeep.default;

		var _cloneWithoutLoc = _interopRequireDefault(require("./clone/cloneWithoutLoc"));

		exports.cloneWithoutLoc = _cloneWithoutLoc.default;

		var _addComment = _interopRequireDefault(require("./comments/addComment"));

		exports.addComment = _addComment.default;

		var _addComments = _interopRequireDefault(require("./comments/addComments"));

		exports.addComments = _addComments.default;

		var _inheritInnerComments = _interopRequireDefault(require("./comments/inheritInnerComments"));

		exports.inheritInnerComments = _inheritInnerComments.default;

		var _inheritLeadingComments = _interopRequireDefault(require("./comments/inheritLeadingComments"));

		exports.inheritLeadingComments = _inheritLeadingComments.default;

		var _inheritsComments = _interopRequireDefault(require("./comments/inheritsComments"));

		exports.inheritsComments = _inheritsComments.default;

		var _inheritTrailingComments = _interopRequireDefault(require("./comments/inheritTrailingComments"));

		exports.inheritTrailingComments = _inheritTrailingComments.default;

		var _removeComments = _interopRequireDefault(require("./comments/removeComments"));

		exports.removeComments = _removeComments.default;

		var _generated3 = require("./constants/generated");
		@@ -150,3 +446,8 @@
		if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
		exports[key] = _generated3[key];
		Object.defineProperty(exports, key, {
		enumerable: true,
		get: function () {
		return _generated3[key];
		}
		});
		});
		@@ -159,3 +460,8 @@
		if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
		exports[key] = _constants[key];
		Object.defineProperty(exports, key, {
		enumerable: true,
		get: function () {
		return _constants[key];
		}
		});
		});
		@@ -165,40 +471,20 @@

		exports.ensureBlock = _ensureBlock.default;

		var _toBindingIdentifierName = _interopRequireDefault(require("./converters/toBindingIdentifierName"));

		exports.toBindingIdentifierName = _toBindingIdentifierName.default;

		var _toBlock = _interopRequireDefault(require("./converters/toBlock"));

		exports.toBlock = _toBlock.default;

		var _toComputedKey = _interopRequireDefault(require("./converters/toComputedKey"));

		exports.toComputedKey = _toComputedKey.default;

		var _toExpression = _interopRequireDefault(require("./converters/toExpression"));

		exports.toExpression = _toExpression.default;

		var _toIdentifier = _interopRequireDefault(require("./converters/toIdentifier"));

		exports.toIdentifier = _toIdentifier.default;

		var _toKeyAlias = _interopRequireDefault(require("./converters/toKeyAlias"));

		exports.toKeyAlias = _toKeyAlias.default;

		var _toSequenceExpression = _interopRequireDefault(require("./converters/toSequenceExpression"));

		exports.toSequenceExpression = _toSequenceExpression.default;

		var _toStatement = _interopRequireDefault(require("./converters/toStatement"));

		exports.toStatement = _toStatement.default;

		var _valueToNode = _interopRequireDefault(require("./converters/valueToNode"));

		exports.valueToNode = _valueToNode.default;

		var _definitions = require("./definitions");
		@@ -209,3 +495,8 @@
		if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
		exports[key] = _definitions[key];
		Object.defineProperty(exports, key, {
		enumerable: true,
		get: function () {
		return _definitions[key];
		}
		});
		});
		@@ -215,112 +506,56 @@

		exports.appendToMemberExpression = _appendToMemberExpression.default;

		var _inherits = _interopRequireDefault(require("./modifications/inherits"));

		exports.inherits = _inherits.default;

		var _prependToMemberExpression = _interopRequireDefault(require("./modifications/prependToMemberExpression"));

		exports.prependToMemberExpression = _prependToMemberExpression.default;

		var _removeProperties = _interopRequireDefault(require("./modifications/removeProperties"));

		exports.removeProperties = _removeProperties.default;

		var _removePropertiesDeep = _interopRequireDefault(require("./modifications/removePropertiesDeep"));

		exports.removePropertiesDeep = _removePropertiesDeep.default;

		var _removeTypeDuplicates = _interopRequireDefault(require("./modifications/flow/removeTypeDuplicates"));

		exports.removeTypeDuplicates = _removeTypeDuplicates.default;

		var _getBindingIdentifiers = _interopRequireDefault(require("./retrievers/getBindingIdentifiers"));

		exports.getBindingIdentifiers = _getBindingIdentifiers.default;

		var _getOuterBindingIdentifiers = _interopRequireDefault(require("./retrievers/getOuterBindingIdentifiers"));

		exports.getOuterBindingIdentifiers = _getOuterBindingIdentifiers.default;

		var _traverse = _interopRequireDefault(require("./traverse/traverse"));

		exports.traverse = _traverse.default;

		var _traverseFast = _interopRequireDefault(require("./traverse/traverseFast"));

		exports.traverseFast = _traverseFast.default;

		var _shallowEqual = _interopRequireDefault(require("./utils/shallowEqual"));

		exports.shallowEqual = _shallowEqual.default;

		var _is = _interopRequireDefault(require("./validators/is"));

		exports.is = _is.default;

		var _isBinding = _interopRequireDefault(require("./validators/isBinding"));

		exports.isBinding = _isBinding.default;

		var _isBlockScoped = _interopRequireDefault(require("./validators/isBlockScoped"));

		exports.isBlockScoped = _isBlockScoped.default;

		var _isImmutable = _interopRequireDefault(require("./validators/isImmutable"));

		exports.isImmutable = _isImmutable.default;

		var _isLet = _interopRequireDefault(require("./validators/isLet"));

		exports.isLet = _isLet.default;

		var _isNode = _interopRequireDefault(require("./validators/isNode"));

		exports.isNode = _isNode.default;

		var _isNodesEquivalent = _interopRequireDefault(require("./validators/isNodesEquivalent"));

		exports.isNodesEquivalent = _isNodesEquivalent.default;

		var _isReferenced = _interopRequireDefault(require("./validators/isReferenced"));

		exports.isReferenced = _isReferenced.default;

		var _isScope = _interopRequireDefault(require("./validators/isScope"));

		exports.isScope = _isScope.default;

		var _isSpecifierDefault = _interopRequireDefault(require("./validators/isSpecifierDefault"));

		exports.isSpecifierDefault = _isSpecifierDefault.default;

		var _isType = _interopRequireDefault(require("./validators/isType"));

		exports.isType = _isType.default;

		var _isValidES3Identifier = _interopRequireDefault(require("./validators/isValidES3Identifier"));

		exports.isValidES3Identifier = _isValidES3Identifier.default;

		var _isValidIdentifier = _interopRequireDefault(require("./validators/isValidIdentifier"));

		exports.isValidIdentifier = _isValidIdentifier.default;

		var _isVar = _interopRequireDefault(require("./validators/isVar"));

		exports.isVar = _isVar.default;

		var _matchesPattern = _interopRequireDefault(require("./validators/matchesPattern"));

		exports.matchesPattern = _matchesPattern.default;

		var _validate = _interopRequireDefault(require("./validators/validate"));

		exports.validate = _validate.default;

		var _buildMatchMemberExpression = _interopRequireDefault(require("./validators/buildMatchMemberExpression"));

		exports.buildMatchMemberExpression = _buildMatchMemberExpression.default;

		var _generated4 = require("./validators/generated");
		@@ -331,3 +566,8 @@
		if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
		exports[key] = _generated4[key];
		Object.defineProperty(exports, key, {
		enumerable: true,
		get: function () {
		return _generated4[key];
		}
		});
		});
		@@ -337,3 +577,3 @@

		var react = {
		const react = {
		isReactComponent: _isReactComponent.default,
		@@ -340,0 +580,0 @@ isCompatTag: _isCompatTag.default,

lib/modifications/appendToMemberExpression.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = appendToMemberExpression;
		@@ -8,7 +10,3 @@

		function appendToMemberExpression(member, append, computed) {
		if (computed === void 0) {
		computed = false;
		}

		function appendToMemberExpression(member, append, computed = false) {
		member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed);
		@@ -15,0 +13,0 @@ member.property = append;

lib/modifications/flow/removeTypeDuplicates.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = removeTypeDuplicates;
		@@ -9,9 +11,9 @@
		function removeTypeDuplicates(nodes) {
		var generics = {};
		var bases = {};
		var typeGroups = [];
		var types = [];
		const generics = {};
		const bases = {};
		const typeGroups = [];
		const types = [];

		for (var i = 0; i < nodes.length; i++) {
		var node = nodes[i];
		for (let i = 0; i < nodes.length; i++) {
		const node = nodes[i];
		if (!node) continue;
		@@ -42,6 +44,6 @@
		if ((0, _generated.isGenericTypeAnnotation)(node)) {
		var name = node.id.name;
		const name = node.id.name;

		if (generics[name]) {
		var existing = generics[name];
		let existing = generics[name];

		@@ -65,8 +67,8 @@ if (existing.typeParameters) {

		for (var type in bases) {
		for (const type in bases) {
		types.push(bases[type]);
		}

		for (var _name in generics) {
		types.push(generics[_name]);
		for (const name in generics) {
		types.push(generics[name]);
		}
		@@ -73,0 +75,0 @@

lib/modifications/inherits.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = inherits;
		@@ -14,7 +16,4 @@
		if (!child \|\| !parent) return child;
		var _arr = _constants.INHERIT_KEYS.optional;

		for (var _i = 0; _i < _arr.length; _i++) {
		var key = _arr[_i];

		for (const key of _constants.INHERIT_KEYS.optional) {
		if (child[key] == null) {
		@@ -25,11 +24,8 @@ child[key] = parent[key];

		for (var _key in parent) {
		if (_key[0] === "_" && _key !== "__clone") child[_key] = parent[_key];
		for (const key in parent) {
		if (key[0] === "_" && key !== "__clone") child[key] = parent[key];
		}

		var _arr2 = _constants.INHERIT_KEYS.force;

		for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
		var _key2 = _arr2[_i2];
		child[_key2] = parent[_key2];
		for (const key of _constants.INHERIT_KEYS.force) {
		child[key] = parent[key];
		}
		@@ -36,0 +32,0 @@

lib/modifications/prependToMemberExpression.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = prependToMemberExpression;
		@@ -5,0 +7,0 @@

lib/modifications/removeProperties.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = removeProperties;
		@@ -8,50 +10,22 @@

		var CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
		const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];

		var CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
		const CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);

		function removeProperties(node, opts) {
		if (opts === void 0) {
		opts = {};
		}
		function removeProperties(node, opts = {}) {
		const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;

		var map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;

		for (var _iterator = map, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
		var _ref;

		if (_isArray) {
		if (_i >= _iterator.length) break;
		_ref = _iterator[_i++];
		} else {
		_i = _iterator.next();
		if (_i.done) break;
		_ref = _i.value;
		}

		var _key2 = _ref;
		if (node[_key2] != null) node[_key2] = undefined;
		for (const key of map) {
		if (node[key] != null) node[key] = undefined;
		}

		for (var _key in node) {
		if (_key[0] === "_" && node[_key] != null) node[_key] = undefined;
		for (const key in node) {
		if (key[0] === "_" && node[key] != null) node[key] = undefined;
		}

		var symbols = Object.getOwnPropertySymbols(node);
		const symbols = Object.getOwnPropertySymbols(node);

		for (var _iterator2 = symbols, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
		var _ref2;

		if (_isArray2) {
		if (_i2 >= _iterator2.length) break;
		_ref2 = _iterator2[_i2++];
		} else {
		_i2 = _iterator2.next();
		if (_i2.done) break;
		_ref2 = _i2.value;
		}

		var _sym = _ref2;
		node[_sym] = null;
		for (const sym of symbols) {
		node[sym] = null;
		}
		}

lib/modifications/removePropertiesDeep.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = removePropertiesDeep;
		@@ -5,0 +7,0 @@

lib/retrievers/getBindingIdentifiers.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = getBindingIdentifiers;
		@@ -9,13 +11,13 @@
		function getBindingIdentifiers(node, duplicates, outerOnly) {
		var search = [].concat(node);
		var ids = Object.create(null);
		let search = [].concat(node);
		const ids = Object.create(null);

		while (search.length) {
		var id = search.shift();
		const id = search.shift();
		if (!id) continue;
		var keys = getBindingIdentifiers.keys[id.type];
		const keys = getBindingIdentifiers.keys[id.type];

		if ((0, _generated.isIdentifier)(id)) {
		if (duplicates) {
		var _ids = ids[id.name] = ids[id.name] \|\| [];
		const _ids = ids[id.name] = ids[id.name] \|\| [];

		@@ -50,4 +52,4 @@ _ids.push(id);
		if (keys) {
		for (var i = 0; i < keys.length; i++) {
		var key = keys[i];
		for (let i = 0; i < keys.length; i++) {
		const key = keys[i];

		@@ -54,0 +56,0 @@ if (id[key]) {

lib/retrievers/getOuterBindingIdentifiers.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = getOuterBindingIdentifiers;
		@@ -5,0 +7,0 @@

lib/traverse/traverse.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = traverse;
		@@ -15,5 +17,6 @@

		var _ref = handlers,
		enter = _ref.enter,
		exit = _ref.exit;
		const {
		enter,
		exit
		} = handlers;
		traverseSimpleImpl(node, enter, exit, state, []);
		@@ -23,28 +26,16 @@ }
		function traverseSimpleImpl(node, enter, exit, state, ancestors) {
		var keys = _definitions.VISITOR_KEYS[node.type];
		const keys = _definitions.VISITOR_KEYS[node.type];
		if (!keys) return;
		if (enter) enter(node, ancestors, state);

		for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
		var _ref2;
		for (const key of keys) {
		const subNode = node[key];

		if (_isArray) {
		if (_i >= _iterator.length) break;
		_ref2 = _iterator[_i++];
		} else {
		_i = _iterator.next();
		if (_i.done) break;
		_ref2 = _i.value;
		}

		var _key2 = _ref2;
		var subNode = node[_key2];

		if (Array.isArray(subNode)) {
		for (var i = 0; i < subNode.length; i++) {
		var child = subNode[i];
		for (let i = 0; i < subNode.length; i++) {
		const child = subNode[i];
		if (!child) continue;
		ancestors.push({
		node: node,
		key: _key2,
		node,
		key,
		index: i
		@@ -57,4 +48,4 @@ });
		ancestors.push({
		node: node,
		key: _key2
		node,
		key
		});
		@@ -61,0 +52,0 @@ traverseSimpleImpl(subNode, enter, exit, state, ancestors);

lib/traverse/traverseFast.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = traverseFast;
		@@ -10,3 +12,3 @@
		if (!node) return;
		var keys = _definitions.VISITOR_KEYS[node.type];
		const keys = _definitions.VISITOR_KEYS[node.type];
		if (!keys) return;
		@@ -16,32 +18,8 @@ opts = opts \|\| {};

		for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
		var _ref;
		for (const key of keys) {
		const subNode = node[key];

		if (_isArray) {
		if (_i >= _iterator.length) break;
		_ref = _iterator[_i++];
		} else {
		_i = _iterator.next();
		if (_i.done) break;
		_ref = _i.value;
		}

		var _key = _ref;
		var subNode = node[_key];

		if (Array.isArray(subNode)) {
		for (var _iterator2 = subNode, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
		var _ref2;

		if (_isArray2) {
		if (_i2 >= _iterator2.length) break;
		_ref2 = _iterator2[_i2++];
		} else {
		_i2 = _iterator2.next();
		if (_i2.done) break;
		_ref2 = _i2.value;
		}

		var _node2 = _ref2;
		traverseFast(_node2, enter, opts);
		for (const node of subNode) {
		traverseFast(node, enter, opts);
		}
		@@ -48,0 +26,0 @@ } else {

lib/utils/inherit.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = inherit;

		var _uniq = _interopRequireDefault(require("lodash/uniq"));
		function _uniq() {
		const data = _interopRequireDefault(require("lodash/uniq"));

		_uniq = function () {
		return data;
		};

		return data;
		}

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
		@@ -12,4 +22,4 @@
		if (child && parent) {
		child[key] = (0, _uniq.default)([].concat(child[key], parent[key]).filter(Boolean));
		child[key] = (0, _uniq().default)([].concat(child[key], parent[key]).filter(Boolean));
		}
		}

lib/utils/react/cleanJSXElementLiteralChild.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = cleanJSXElementLiteralChild;
		@@ -9,6 +11,6 @@
		function cleanJSXElementLiteralChild(child, args) {
		var lines = child.value.split(/\r\n\|\n\|\r/);
		var lastNonEmptyLine = 0;
		const lines = child.value.split(/\r\n\|\n\|\r/);
		let lastNonEmptyLine = 0;

		for (var i = 0; i < lines.length; i++) {
		for (let i = 0; i < lines.length; i++) {
		if (lines[i].match(/[^ \t]/)) {
		@@ -19,10 +21,10 @@ lastNonEmptyLine = i;

		var str = "";
		let str = "";

		for (var _i = 0; _i < lines.length; _i++) {
		var line = lines[_i];
		var isFirstLine = _i === 0;
		var isLastLine = _i === lines.length - 1;
		var isLastNonEmptyLine = _i === lastNonEmptyLine;
		var trimmedLine = line.replace(/\t/g, " ");
		for (let i = 0; i < lines.length; i++) {
		const line = lines[i];
		const isFirstLine = i === 0;
		const isLastLine = i === lines.length - 1;
		const isLastNonEmptyLine = i === lastNonEmptyLine;
		let trimmedLine = line.replace(/\t/g, " ");

		@@ -29,0 +31,0 @@ if (!isFirstLine) {

lib/utils/shallowEqual.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = shallowEqual;

		function shallowEqual(actual, expected) {
		var keys = Object.keys(expected);
		var _arr = keys;
		const keys = Object.keys(expected);

		for (var _i = 0; _i < _arr.length; _i++) {
		var key = _arr[_i];

		for (const key of keys) {
		if (actual[key] !== expected[key]) {
		@@ -14,0 +13,0 @@ return false;

lib/validators/buildMatchMemberExpression.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = buildMatchMemberExpression;
		@@ -11,6 +13,4 @@
		function buildMatchMemberExpression(match, allowPartial) {
		var parts = match.split(".");
		return function (member) {
		return (0, _matchesPattern.default)(member, parts, allowPartial);
		};
		const parts = match.split(".");
		return member => (0, _matchesPattern.default)(member, parts, allowPartial);
		}

lib/validators/generated/index.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.isArrayExpression = isArrayExpression;
		@@ -5,0 +7,0 @@ exports.isAssignmentExpression = isAssignmentExpression;

lib/validators/is.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = is;
		@@ -14,3 +16,3 @@
		if (!node) return false;
		var matches = (0, _isType.default)(node.type, type);
		const matches = (0, _isType.default)(node.type, type);
		if (!matches) return false;
		@@ -17,0 +19,0 @@

lib/validators/isBinding.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isBinding;
		@@ -11,8 +13,8 @@
		function isBinding(node, parent) {
		var keys = _getBindingIdentifiers.default.keys[parent.type];
		const keys = _getBindingIdentifiers.default.keys[parent.type];

		if (keys) {
		for (var i = 0; i < keys.length; i++) {
		var key = keys[i];
		var val = parent[key];
		for (let i = 0; i < keys.length; i++) {
		const key = keys[i];
		const val = parent[key];

		@@ -19,0 +21,0 @@ if (Array.isArray(val)) {

lib/validators/isBlockScoped.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isBlockScoped;
		@@ -5,0 +7,0 @@

lib/validators/isImmutable.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isImmutable;
		@@ -5,0 +7,0 @@

lib/validators/isLet.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isLet;
		@@ -5,0 +7,0 @@

lib/validators/isNode.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isNode;
		@@ -5,0 +7,0 @@

lib/validators/isNodesEquivalent.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isNodesEquivalent;
		@@ -17,7 +19,5 @@

		var fields = Object.keys(_definitions.NODE_FIELDS[a.type] \|\| a.type);
		const fields = Object.keys(_definitions.NODE_FIELDS[a.type] \|\| a.type);

		for (var _i = 0; _i < fields.length; _i++) {
		var field = fields[_i];

		for (const field of fields) {
		if (typeof a[field] !== typeof b[field]) {
		@@ -36,3 +36,3 @@ return false;

		for (var i = 0; i < a[field].length; i++) {
		for (let i = 0; i < a[field].length; i++) {
		if (!isNodesEquivalent(a[field][i], b[field][i])) {
		@@ -39,0 +39,0 @@ return false;

lib/validators/isReferenced.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isReferenced;
		@@ -35,6 +37,3 @@
		case "FunctionExpression":
		var _arr = parent.params;

		for (var _i = 0; _i < _arr.length; _i++) {
		var param = _arr[_i];
		for (const param of parent.params) {
		if (param === node) return false;
		@@ -41,0 +40,0 @@ }

lib/validators/isScope.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isScope;
		@@ -5,0 +7,0 @@

lib/validators/isSpecifierDefault.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isSpecifierDefault;
		@@ -5,0 +7,0 @@

lib/validators/isType.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isType;
		@@ -11,3 +13,3 @@
		if (_definitions.ALIAS_KEYS[targetType]) return false;
		var aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType];
		const aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType];

		@@ -17,16 +19,4 @@ if (aliases) {

		for (var _iterator = aliases, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
		var _ref;

		if (_isArray) {
		if (_i >= _iterator.length) break;
		_ref = _iterator[_i++];
		} else {
		_i = _iterator.next();
		if (_i.done) break;
		_ref = _i.value;
		}

		var _alias = _ref;
		if (nodeType === _alias) return true;
		for (const alias of aliases) {
		if (nodeType === alias) return true;
		}
		@@ -33,0 +23,0 @@ }

lib/validators/isValidES3Identifier.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isValidES3Identifier;
		@@ -10,3 +12,3 @@

		var RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]);
		const RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]);

		@@ -13,0 +15,0 @@ function isValidES3Identifier(name) {

lib/validators/isValidIdentifier.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isValidIdentifier;

		var _esutils = _interopRequireDefault(require("esutils"));
		function _esutils() {
		const data = _interopRequireDefault(require("esutils"));

		_esutils = function () {
		return data;
		};

		return data;
		}

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function isValidIdentifier(name) {
		if (typeof name !== "string" \|\| _esutils.default.keyword.isReservedWordES6(name, true)) {
		if (typeof name !== "string" \|\| _esutils().default.keyword.isReservedWordES6(name, true)) {
		return false;
		@@ -16,4 +26,4 @@ } else if (name === "await") {
		} else {
		return _esutils.default.keyword.isIdentifierNameES6(name);
		return _esutils().default.keyword.isIdentifierNameES6(name);
		}
		}

lib/validators/isVar.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isVar;
		@@ -5,0 +7,0 @@

lib/validators/matchesPattern.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = matchesPattern;
		@@ -10,5 +12,5 @@
		if (!(0, _generated.isMemberExpression)(member)) return false;
		var parts = Array.isArray(match) ? match : match.split(".");
		var nodes = [];
		var node;
		const parts = Array.isArray(match) ? match : match.split(".");
		const nodes = [];
		let node;

		@@ -23,10 +25,10 @@ for (node = member; (0, _generated.isMemberExpression)(node); node = node.object) {

		for (var i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {
		var _node = nodes[j];
		var value = void 0;
		for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {
		const node = nodes[j];
		let value;

		if ((0, _generated.isIdentifier)(_node)) {
		value = _node.name;
		} else if ((0, _generated.isStringLiteral)(_node)) {
		value = _node.value;
		if ((0, _generated.isIdentifier)(node)) {
		value = node.name;
		} else if ((0, _generated.isStringLiteral)(node)) {
		value = node.value;
		} else {
		@@ -33,0 +35,0 @@ return false;

lib/validators/react/isCompatTag.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isCompatTag;
		@@ -5,0 +7,0 @@

lib/validators/react/isReactComponent.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = void 0;
		@@ -10,4 +12,4 @@

		var isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component");
		const isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component");
		var _default = isReactComponent;
		exports.default = _default;

lib/validators/validate.js

		"use strict";

		exports.__esModule = true;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = validate;
		@@ -10,5 +12,5 @@
		if (!node) return;
		var fields = _definitions.NODE_FIELDS[node.type];
		const fields = _definitions.NODE_FIELDS[node.type];
		if (!fields) return;
		var field = fields[key];
		const field = fields[key];
		if (!field \|\| !field.validate) return;
		@@ -15,0 +17,0 @@ if (field.optional && val == null) return;

package.json

		{
		"name": "@babel/types",
		"version": "7.0.0-beta.42",
		"version": "7.0.0-beta.43",
		"description": "Babel Types is a Lodash-esque utility library for AST nodes",
		@@ -17,5 +17,5 @@ "author": "Sebastian McKenzie <sebmck@gmail.com>",
		"devDependencies": {
		"@babel/generator": "7.0.0-beta.42",
		"babylon": "7.0.0-beta.42"
		"@babel/generator": "7.0.0-beta.43",
		"babylon": "7.0.0-beta.43"
		}
		}

lib/builders/generated/index.js

Sorry, the diff of this file is too big to display

lib/index.d.ts

Sorry, the diff of this file is too big to display

lib/index.js.flow

Sorry, the diff of this file is not supported yet

README.md

Sorry, the diff of this file is too big to display

@babel/types - npm Package Compare versions

New alerts

Fixed alerts

Worsened metrics