Bug 1480838 - Update Debugger Frontend v78. r=dwalsh
authorJason Laster <jason.laster.11@gmail.com>
Fri, 03 Aug 2018 13:34:43 -0400
changeset 430101 a4b6c12158a9c47b5d75024e3f29cc6114be861d
parent 430100 3570d0c7b0c72804a15d285978d97b64441c5a62
child 430102 cb97b513e80eacbf60518002acd95f1591023bc7
push id34383
push usernerli@mozilla.com
push dateSat, 04 Aug 2018 12:28:43 +0000
treeherdermozilla-central@4146a5857135 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdwalsh
bugs1480838
milestone63.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1480838 - Update Debugger Frontend v78. r=dwalsh
devtools/client/debugger/new/README.mozilla
devtools/client/debugger/new/dist/parser-worker.js
devtools/client/debugger/new/dist/vendors.js
devtools/client/debugger/new/src/actions/sources/newSources.js
devtools/client/debugger/new/src/actions/sources/prettyPrint.js
devtools/client/debugger/new/src/client/firefox/commands.js
devtools/client/debugger/new/src/client/firefox/create.js
devtools/client/debugger/new/src/components/App.js
devtools/client/debugger/new/src/components/SecondaryPanes/CommandBar.js
devtools/client/debugger/new/src/utils/bootstrap.js
devtools/client/debugger/new/src/utils/moz.build
devtools/client/debugger/new/src/utils/prefs.js
devtools/client/debugger/new/src/utils/source.js
devtools/client/debugger/new/src/utils/sources-tree/getURL.js
devtools/client/debugger/new/src/utils/sources-tree/treeOrder.js
devtools/client/debugger/new/src/utils/sources-tree/utils.js
devtools/client/debugger/new/src/utils/text.js
devtools/client/debugger/new/src/utils/url.js
devtools/client/debugger/new/test/mochitest/browser_dbg-sources-named-eval.js
devtools/client/shared/components/reps/reps.js
--- a/devtools/client/debugger/new/README.mozilla
+++ b/devtools/client/debugger/new/README.mozilla
@@ -1,13 +1,13 @@
 This is the debugger.html project output.
 See https://github.com/devtools-html/debugger.html
 
-Version 77
+Version 78
 
-Comparison: https://github.com/devtools-html/debugger.html/compare/release-76...release-77
+Comparison: https://github.com/devtools-html/debugger.html/compare/release-77...release-78
 
 Packages:
 - babel-plugin-transform-es2015-modules-commonjs @6.26.2
 - babel-preset-react @6.24.1
 - react @16.4.1
 - react-dom @16.4.1
-- webpack @3.11.0
+- webpack @3.12.0
--- a/devtools/client/debugger/new/dist/parser-worker.js
+++ b/devtools/client/debugger/new/dist/parser-worker.js
@@ -210,17 +210,17 @@ Object.defineProperty(exports, "__esModu
   value: true
 });
 exports.parseScriptTags = exports.parseScripts = exports.parseScript = exports.getCandidateScriptLocations = exports.generateWhitespace = exports.extractScriptTags = undefined;
 
 var _types = __webpack_require__(2268);
 
 var types = _interopRequireWildcard(_types);
 
-var _babylon = __webpack_require__(435);
+var _babylon = __webpack_require__(3771);
 
 var babylon = _interopRequireWildcard(_babylon);
 
 var _customParse = __webpack_require__(2337);
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
 function parseScript(_ref) {
@@ -782,19 +782,19 @@ exports.parseScript = parseScript;
 exports.getAst = getAst;
 exports.clearASTs = clearASTs;
 exports.traverseAst = traverseAst;
 
 var _parseScriptTags = __webpack_require__(1023);
 
 var _parseScriptTags2 = _interopRequireDefault(_parseScriptTags);
 
-var _babylon = __webpack_require__(435);
-
-var babylon = _interopRequireWildcard(_babylon);
+var _parser = __webpack_require__(3773);
+
+var babelParser = _interopRequireWildcard(_parser);
 
 var _types = __webpack_require__(2268);
 
 var t = _interopRequireWildcard(_types);
 
 var _isEmpty = __webpack_require__(963);
 
 var _isEmpty2 = _interopRequireDefault(_isEmpty);
@@ -803,31 +803,31 @@ var _sources = __webpack_require__(1458)
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 let ASTs = new Map();
 
 function _parse(code, opts) {
-  return babylon.parse(code, _extends({}, opts, {
+  return babelParser.parse(code, _extends({}, opts, {
     tokens: true
   }));
 }
 
 const sourceOptions = {
   generated: {
     sourceType: "unambiguous",
     tokens: true,
     plugins: ["objectRestSpread"]
   },
   original: {
     sourceType: "unambiguous",
     tokens: true,
-    plugins: ["jsx", "flow", "doExpressions", "decorators", "objectRestSpread", "classProperties", "exportDefaultFrom", "exportNamespaceFrom", "asyncGenerators", "functionBind", "functionSent", "dynamicImport", "react-jsx"]
+    plugins: ["jsx", "flow", "doExpressions", "decorators-legacy", "objectRestSpread", "classProperties", "exportDefaultFrom", "exportNamespaceFrom", "asyncGenerators", "functionBind", "functionSent", "dynamicImport", "react-jsx"]
   }
 };
 
 function parse(text, opts) {
   let ast;
   if (!text) {
     return;
   }
@@ -895,17 +895,17 @@ function getAst(sourceId) {
   } else if (contentType && contentType === "text/vue") {
     ast = parseVueScript(source.text) || {};
   } else if (contentType && contentType.match(/(javascript|jsx)/) && !contentType.match(/typescript-jsx/)) {
     const type = source.id.includes("original") ? "original" : "generated";
     const options = sourceOptions[type];
     ast = parse(source.text, options);
   } else if (contentType && contentType.match(/typescript/)) {
     const options = _extends({}, sourceOptions.original, {
-      plugins: [...sourceOptions.original.plugins.filter(p => p !== "flow" && p !== "decorators" && p !== "decorators2" && (p !== "jsx" || contentType.match(/typescript-jsx/))), "decorators", "typescript"]
+      plugins: [...sourceOptions.original.plugins.filter(p => p !== "flow" && p !== "decorators" && p !== "decorators2" && (p !== "jsx" || contentType.match(/typescript-jsx/))), "decorators-legacy", "typescript"]
     });
     ast = parse(source.text, options);
   }
 
   ASTs.set(source.id, ast);
   return ast;
 }
 
@@ -3131,16 +3131,17 @@ module.exports = isArrayLike;
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.isArrayExpression = isArrayExpression;
 exports.isAssignmentExpression = isAssignmentExpression;
 exports.isBinaryExpression = isBinaryExpression;
+exports.isInterpreterDirective = isInterpreterDirective;
 exports.isDirective = isDirective;
 exports.isDirectiveLiteral = isDirectiveLiteral;
 exports.isBlockStatement = isBlockStatement;
 exports.isBreakStatement = isBreakStatement;
 exports.isCallExpression = isCallExpression;
 exports.isCatchClause = isCatchClause;
 exports.isConditionalExpression = isConditionalExpression;
 exports.isContinueStatement = isContinueStatement;
@@ -3225,23 +3226,25 @@ exports.isDeclareExportAllDeclaration = 
 exports.isDeclaredPredicate = isDeclaredPredicate;
 exports.isExistsTypeAnnotation = isExistsTypeAnnotation;
 exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation;
 exports.isFunctionTypeParam = isFunctionTypeParam;
 exports.isGenericTypeAnnotation = isGenericTypeAnnotation;
 exports.isInferredPredicate = isInferredPredicate;
 exports.isInterfaceExtends = isInterfaceExtends;
 exports.isInterfaceDeclaration = isInterfaceDeclaration;
+exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation;
 exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;
 exports.isMixedTypeAnnotation = isMixedTypeAnnotation;
 exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
 exports.isNullableTypeAnnotation = isNullableTypeAnnotation;
 exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;
 exports.isNumberTypeAnnotation = isNumberTypeAnnotation;
 exports.isObjectTypeAnnotation = isObjectTypeAnnotation;
+exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
 exports.isObjectTypeCallProperty = isObjectTypeCallProperty;
 exports.isObjectTypeIndexer = isObjectTypeIndexer;
 exports.isObjectTypeProperty = isObjectTypeProperty;
 exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
 exports.isOpaqueType = isOpaqueType;
 exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
 exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;
 exports.isStringTypeAnnotation = isStringTypeAnnotation;
@@ -3281,16 +3284,17 @@ exports.isOptionalMemberExpression = isO
 exports.isOptionalCallExpression = isOptionalCallExpression;
 exports.isClassPrivateProperty = isClassPrivateProperty;
 exports.isImport = isImport;
 exports.isDecorator = isDecorator;
 exports.isDoExpression = isDoExpression;
 exports.isExportDefaultSpecifier = isExportDefaultSpecifier;
 exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
 exports.isPrivateName = isPrivateName;
+exports.isBigIntLiteral = isBigIntLiteral;
 exports.isTSParameterProperty = isTSParameterProperty;
 exports.isTSDeclareFunction = isTSDeclareFunction;
 exports.isTSDeclareMethod = isTSDeclareMethod;
 exports.isTSQualifiedName = isTSQualifiedName;
 exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration;
 exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration;
 exports.isTSPropertySignature = isTSPropertySignature;
 exports.isTSMethodSignature = isTSMethodSignature;
@@ -3390,3831 +3394,3891 @@ exports.isRestProperty = isRestProperty;
 exports.isSpreadProperty = isSpreadProperty;
 
 var _shallowEqual = _interopRequireDefault(__webpack_require__(2271));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function isArrayExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ArrayExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isAssignmentExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "AssignmentExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isBinaryExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "BinaryExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
+function isInterpreterDirective(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "InterpreterDirective") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
 function isDirective(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Directive") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDirectiveLiteral(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DirectiveLiteral") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isBlockStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "BlockStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isBreakStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "BreakStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isCallExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "CallExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isCatchClause(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "CatchClause") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isConditionalExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ConditionalExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isContinueStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ContinueStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDebuggerStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DebuggerStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDoWhileStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DoWhileStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isEmptyStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "EmptyStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExpressionStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ExpressionStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFile(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "File") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isForInStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ForInStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isForStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ForStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFunctionDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "FunctionDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFunctionExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "FunctionExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isIdentifier(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Identifier") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isIfStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "IfStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isLabeledStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "LabeledStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isStringLiteral(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "StringLiteral") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isNumericLiteral(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "NumericLiteral") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isNullLiteral(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "NullLiteral") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isBooleanLiteral(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "BooleanLiteral") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isRegExpLiteral(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "RegExpLiteral") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isLogicalExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "LogicalExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isMemberExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "MemberExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isNewExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "NewExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isProgram(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Program") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isObjectExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ObjectExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isObjectMethod(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ObjectMethod") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isObjectProperty(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ObjectProperty") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isRestElement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "RestElement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isReturnStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ReturnStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isSequenceExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "SequenceExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isSwitchCase(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "SwitchCase") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isSwitchStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "SwitchStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isThisExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ThisExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isThrowStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ThrowStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTryStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TryStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isUnaryExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "UnaryExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isUpdateExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "UpdateExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isVariableDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "VariableDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isVariableDeclarator(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "VariableDeclarator") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isWhileStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "WhileStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isWithStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "WithStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isAssignmentPattern(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "AssignmentPattern") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isArrayPattern(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ArrayPattern") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isArrowFunctionExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ArrowFunctionExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isClassBody(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ClassBody") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isClassDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ClassDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isClassExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ClassExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExportAllDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ExportAllDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExportDefaultDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ExportDefaultDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExportNamedDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ExportNamedDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExportSpecifier(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ExportSpecifier") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isForOfStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ForOfStatement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isImportDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ImportDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isImportDefaultSpecifier(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ImportDefaultSpecifier") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isImportNamespaceSpecifier(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ImportNamespaceSpecifier") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isImportSpecifier(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ImportSpecifier") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isMetaProperty(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "MetaProperty") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isClassMethod(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ClassMethod") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isObjectPattern(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ObjectPattern") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isSpreadElement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "SpreadElement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isSuper(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Super") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTaggedTemplateExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TaggedTemplateExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTemplateElement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TemplateElement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTemplateLiteral(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TemplateLiteral") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isYieldExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "YieldExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isAnyTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "AnyTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isArrayTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ArrayTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isBooleanTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "BooleanTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isBooleanLiteralTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "BooleanLiteralTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isNullLiteralTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "NullLiteralTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isClassImplements(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ClassImplements") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclareClass(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclareClass") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclareFunction(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclareFunction") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclareInterface(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclareInterface") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclareModule(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclareModule") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclareModuleExports(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclareModuleExports") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclareTypeAlias(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclareTypeAlias") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclareOpaqueType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclareOpaqueType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclareVariable(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclareVariable") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclareExportDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclareExportDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclareExportAllDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclareExportAllDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclaredPredicate(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DeclaredPredicate") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExistsTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ExistsTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFunctionTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "FunctionTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFunctionTypeParam(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "FunctionTypeParam") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isGenericTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "GenericTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isInferredPredicate(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "InferredPredicate") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isInterfaceExtends(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "InterfaceExtends") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isInterfaceDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "InterfaceDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
+function isInterfaceTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "InterfaceTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
 function isIntersectionTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "IntersectionTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isMixedTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "MixedTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isEmptyTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "EmptyTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isNullableTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "NullableTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isNumberLiteralTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "NumberLiteralTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isNumberTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "NumberTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isObjectTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ObjectTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
+function isObjectTypeInternalSlot(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectTypeInternalSlot") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
 function isObjectTypeCallProperty(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ObjectTypeCallProperty") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isObjectTypeIndexer(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ObjectTypeIndexer") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isObjectTypeProperty(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ObjectTypeProperty") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isObjectTypeSpreadProperty(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ObjectTypeSpreadProperty") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isOpaqueType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "OpaqueType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isQualifiedTypeIdentifier(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "QualifiedTypeIdentifier") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isStringLiteralTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "StringLiteralTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isStringTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "StringTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isThisTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ThisTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTupleTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TupleTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTypeofTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TypeofTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTypeAlias(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TypeAlias") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTypeCastExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TypeCastExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTypeParameter(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TypeParameter") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTypeParameterDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TypeParameterDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTypeParameterInstantiation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TypeParameterInstantiation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isUnionTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "UnionTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isVariance(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Variance") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isVoidTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "VoidTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXAttribute(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXAttribute") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXClosingElement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXClosingElement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXElement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXElement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXEmptyExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXEmptyExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXExpressionContainer(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXExpressionContainer") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXSpreadChild(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXSpreadChild") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXIdentifier(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXIdentifier") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXMemberExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXMemberExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXNamespacedName(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXNamespacedName") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXOpeningElement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXOpeningElement") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXSpreadAttribute(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXSpreadAttribute") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXText(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXText") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXFragment(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXFragment") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXOpeningFragment(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXOpeningFragment") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSXClosingFragment(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSXClosingFragment") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isNoop(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Noop") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isParenthesizedExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ParenthesizedExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isAwaitExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "AwaitExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isBindExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "BindExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isClassProperty(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ClassProperty") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isOptionalMemberExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "OptionalMemberExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isOptionalCallExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "OptionalCallExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isClassPrivateProperty(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ClassPrivateProperty") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isImport(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Import") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDecorator(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Decorator") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDoExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "DoExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExportDefaultSpecifier(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ExportDefaultSpecifier") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExportNamespaceSpecifier(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ExportNamespaceSpecifier") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isPrivateName(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "PrivateName") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
+function isBigIntLiteral(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "BigIntLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
 function isTSParameterProperty(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSParameterProperty") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSDeclareFunction(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSDeclareFunction") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSDeclareMethod(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSDeclareMethod") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSQualifiedName(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSQualifiedName") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSCallSignatureDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSCallSignatureDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSConstructSignatureDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSConstructSignatureDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSPropertySignature(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSPropertySignature") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSMethodSignature(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSMethodSignature") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSIndexSignature(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSIndexSignature") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSAnyKeyword(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSAnyKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSNumberKeyword(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSNumberKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSObjectKeyword(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSObjectKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSBooleanKeyword(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSBooleanKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSStringKeyword(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSStringKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSSymbolKeyword(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSSymbolKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSVoidKeyword(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSVoidKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSUndefinedKeyword(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSUndefinedKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSNullKeyword(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSNullKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSNeverKeyword(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSNeverKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSThisType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSThisType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSFunctionType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSFunctionType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSConstructorType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSConstructorType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeReference(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeReference") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypePredicate(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypePredicate") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeQuery(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeQuery") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeLiteral(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeLiteral") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSArrayType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSArrayType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTupleType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTupleType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSUnionType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSUnionType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSIntersectionType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSIntersectionType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSConditionalType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSConditionalType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSInferType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSInferType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSParenthesizedType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSParenthesizedType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeOperator(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeOperator") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSIndexedAccessType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSIndexedAccessType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSMappedType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSMappedType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSLiteralType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSLiteralType") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSExpressionWithTypeArguments(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSExpressionWithTypeArguments") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSInterfaceDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSInterfaceDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSInterfaceBody(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSInterfaceBody") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeAliasDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeAliasDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSAsExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSAsExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeAssertion(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeAssertion") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSEnumDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSEnumDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSEnumMember(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSEnumMember") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSModuleDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSModuleDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSModuleBlock(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSModuleBlock") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSImportEqualsDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSImportEqualsDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSExternalModuleReference(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSExternalModuleReference") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSNonNullExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSNonNullExpression") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSExportAssignment(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSExportAssignment") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSNamespaceExportDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSNamespaceExportDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeAnnotation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeParameterInstantiation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeParameterInstantiation") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeParameterDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeParameterDeclaration") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeParameter(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeParameter") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExpression(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
-
-  if (nodeType === "Expression" || "ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "CallExpression" === nodeType || "ConditionalExpression" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "ObjectExpression" === nodeType || "SequenceExpression" === nodeType || "ThisExpression" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "MetaProperty" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "ParenthesizedExpression" === nodeType || "AwaitExpression" === nodeType || "BindExpression" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "Import" === nodeType || "DoExpression" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType) {
+  const nodeType = node.type;
+
+  if (nodeType === "Expression" || "ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "CallExpression" === nodeType || "ConditionalExpression" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "ObjectExpression" === nodeType || "SequenceExpression" === nodeType || "ThisExpression" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "MetaProperty" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "ParenthesizedExpression" === nodeType || "AwaitExpression" === nodeType || "BindExpression" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "Import" === nodeType || "DoExpression" === nodeType || "BigIntLiteral" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isBinary(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Binary" || "BinaryExpression" === nodeType || "LogicalExpression" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isScopable(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Scopable" || "BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isBlockParent(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "BlockParent" || "BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isBlock(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Block" || "BlockStatement" === nodeType || "Program" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Statement" || "BlockStatement" === nodeType || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "ReturnStatement" === nodeType || "SwitchStatement" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "VariableDeclaration" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTerminatorless(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Terminatorless" || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isCompletionStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "CompletionStatement" || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isConditional(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Conditional" || "ConditionalExpression" === nodeType || "IfStatement" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isLoop(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Loop" || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "WhileStatement" === nodeType || "ForOfStatement" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isWhile(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "While" || "DoWhileStatement" === nodeType || "WhileStatement" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExpressionWrapper(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ExpressionWrapper" || "ExpressionStatement" === nodeType || "TypeCastExpression" === nodeType || "ParenthesizedExpression" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFor(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "For" || "ForInStatement" === nodeType || "ForStatement" === nodeType || "ForOfStatement" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isForXStatement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ForXStatement" || "ForInStatement" === nodeType || "ForOfStatement" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFunction(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Function" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFunctionParent(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "FunctionParent" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isPureish(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
-
-  if (nodeType === "Pureish" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType) {
+  const nodeType = node.type;
+
+  if (nodeType === "Pureish" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType || "BigIntLiteral" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Declaration" || "FunctionDeclaration" === nodeType || "VariableDeclaration" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isPatternLike(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "PatternLike" || "Identifier" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isLVal(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "LVal" || "Identifier" === nodeType || "MemberExpression" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || "TSParameterProperty" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSEntityName(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSEntityName" || "Identifier" === nodeType || "TSQualifiedName" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isLiteral(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
-
-  if (nodeType === "Literal" || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "TemplateLiteral" === nodeType) {
+  const nodeType = node.type;
+
+  if (nodeType === "Literal" || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "TemplateLiteral" === nodeType || "BigIntLiteral" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isImmutable(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
-
-  if (nodeType === "Immutable" || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXOpeningElement" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType) {
+  const nodeType = node.type;
+
+  if (nodeType === "Immutable" || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXOpeningElement" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType || "BigIntLiteral" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isUserWhitespacable(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
-
-  if (nodeType === "UserWhitespacable" || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType) {
+  const nodeType = node.type;
+
+  if (nodeType === "UserWhitespacable" || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isMethod(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Method" || "ObjectMethod" === nodeType || "ClassMethod" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isObjectMember(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ObjectMember" || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isProperty(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Property" || "ObjectProperty" === nodeType || "ClassProperty" === nodeType || "ClassPrivateProperty" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isUnaryLike(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "UnaryLike" || "UnaryExpression" === nodeType || "SpreadElement" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isPattern(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Pattern" || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isClass(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Class" || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isModuleDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ModuleDeclaration" || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isExportDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ExportDeclaration" || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isModuleSpecifier(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "ModuleSpecifier" || "ExportSpecifier" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "ExportDefaultSpecifier" === nodeType || "ExportNamespaceSpecifier" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFlow(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
-
-  if (nodeType === "Flow" || "AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ClassImplements" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "DeclaredPredicate" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "FunctionTypeParam" === nodeType || "GenericTypeAnnotation" === nodeType || "InferredPredicate" === nodeType || "InterfaceExtends" === nodeType || "InterfaceDeclaration" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType || "OpaqueType" === nodeType || "QualifiedTypeIdentifier" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "TypeAlias" === nodeType || "TypeAnnotation" === nodeType || "TypeCastExpression" === nodeType || "TypeParameter" === nodeType || "TypeParameterDeclaration" === nodeType || "TypeParameterInstantiation" === nodeType || "UnionTypeAnnotation" === nodeType || "Variance" === nodeType || "VoidTypeAnnotation" === nodeType) {
+  const nodeType = node.type;
+
+  if (nodeType === "Flow" || "AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ClassImplements" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "DeclaredPredicate" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "FunctionTypeParam" === nodeType || "GenericTypeAnnotation" === nodeType || "InferredPredicate" === nodeType || "InterfaceExtends" === nodeType || "InterfaceDeclaration" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType || "OpaqueType" === nodeType || "QualifiedTypeIdentifier" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "TypeAlias" === nodeType || "TypeAnnotation" === nodeType || "TypeCastExpression" === nodeType || "TypeParameter" === nodeType || "TypeParameterDeclaration" === nodeType || "TypeParameterInstantiation" === nodeType || "UnionTypeAnnotation" === nodeType || "Variance" === nodeType || "VoidTypeAnnotation" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFlowType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
-
-  if (nodeType === "FlowType" || "AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "GenericTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "UnionTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
+  const nodeType = node.type;
+
+  if (nodeType === "FlowType" || "AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "GenericTypeAnnotation" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "UnionTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFlowBaseAnnotation(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "FlowBaseAnnotation" || "AnyTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFlowDeclaration(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "FlowDeclaration" || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isFlowPredicate(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "FlowPredicate" || "DeclaredPredicate" === nodeType || "InferredPredicate" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isJSX(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "JSX" || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXEmptyExpression" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXIdentifier" === nodeType || "JSXMemberExpression" === nodeType || "JSXNamespacedName" === nodeType || "JSXOpeningElement" === nodeType || "JSXSpreadAttribute" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isPrivate(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "Private" || "ClassPrivateProperty" === nodeType || "PrivateName" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSTypeElement(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSTypeElement" || "TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isTSType(node, opts) {
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "TSType" || "TSAnyKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSThisType" === nodeType || "TSFunctionType" === nodeType || "TSConstructorType" === nodeType || "TSTypeReference" === nodeType || "TSTypePredicate" === nodeType || "TSTypeQuery" === nodeType || "TSTypeLiteral" === nodeType || "TSArrayType" === nodeType || "TSTupleType" === nodeType || "TSUnionType" === nodeType || "TSIntersectionType" === nodeType || "TSConditionalType" === nodeType || "TSInferType" === nodeType || "TSParenthesizedType" === nodeType || "TSTypeOperator" === nodeType || "TSIndexedAccessType" === nodeType || "TSMappedType" === nodeType || "TSLiteralType" === nodeType || "TSExpressionWithTypeArguments" === nodeType) {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isNumberLiteral(node, opts) {
   console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "NumberLiteral") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isRegexLiteral(node, opts) {
   console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "RegexLiteral") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isRestProperty(node, opts) {
   console.trace("The node type RestProperty has been renamed to RestElement");
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "RestProperty") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
 
   return false;
 }
 
 function isSpreadProperty(node, opts) {
   console.trace("The node type SpreadProperty has been renamed to SpreadElement");
   if (!node) return false;
-  var nodeType = node.type;
+  const nodeType = node.type;
 
   if (nodeType === "SpreadProperty") {
     if (typeof opts === "undefined") {
       return true;
     } else {
       return (0, _shallowEqual.default)(node, opts);
     }
   }
@@ -7231,16 +7295,17 @@ function isSpreadProperty(node, opts) {
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.arrayExpression = exports.ArrayExpression = ArrayExpression;
 exports.assignmentExpression = exports.AssignmentExpression = AssignmentExpression;
 exports.binaryExpression = exports.BinaryExpression = BinaryExpression;
+exports.interpreterDirective = exports.InterpreterDirective = InterpreterDirective;
 exports.directive = exports.Directive = Directive;
 exports.directiveLiteral = exports.DirectiveLiteral = DirectiveLiteral;
 exports.blockStatement = exports.BlockStatement = BlockStatement;
 exports.breakStatement = exports.BreakStatement = BreakStatement;
 exports.callExpression = exports.CallExpression = CallExpression;
 exports.catchClause = exports.CatchClause = CatchClause;
 exports.conditionalExpression = exports.ConditionalExpression = ConditionalExpression;
 exports.continueStatement = exports.ContinueStatement = ContinueStatement;
@@ -7325,23 +7390,25 @@ exports.declareExportAllDeclaration = ex
 exports.declaredPredicate = exports.DeclaredPredicate = DeclaredPredicate;
 exports.existsTypeAnnotation = exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
 exports.functionTypeAnnotation = exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
 exports.functionTypeParam = exports.FunctionTypeParam = FunctionTypeParam;
 exports.genericTypeAnnotation = exports.GenericTypeAnnotation = GenericTypeAnnotation;
 exports.inferredPredicate = exports.InferredPredicate = InferredPredicate;
 exports.interfaceExtends = exports.InterfaceExtends = InterfaceExtends;
 exports.interfaceDeclaration = exports.InterfaceDeclaration = InterfaceDeclaration;
+exports.interfaceTypeAnnotation = exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation;
 exports.intersectionTypeAnnotation = exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
 exports.mixedTypeAnnotation = exports.MixedTypeAnnotation = MixedTypeAnnotation;
 exports.emptyTypeAnnotation = exports.EmptyTypeAnnotation = EmptyTypeAnnotation;
 exports.nullableTypeAnnotation = exports.NullableTypeAnnotation = NullableTypeAnnotation;
 exports.numberLiteralTypeAnnotation = exports.NumberLiteralTypeAnnotation = NumberLiteralTypeAnnotation;
 exports.numberTypeAnnotation = exports.NumberTypeAnnotation = NumberTypeAnnotation;
 exports.objectTypeAnnotation = exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
+exports.objectTypeInternalSlot = exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot;
 exports.objectTypeCallProperty = exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
 exports.objectTypeIndexer = exports.ObjectTypeIndexer = ObjectTypeIndexer;
 exports.objectTypeProperty = exports.ObjectTypeProperty = ObjectTypeProperty;
 exports.objectTypeSpreadProperty = exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
 exports.opaqueType = exports.OpaqueType = OpaqueType;
 exports.qualifiedTypeIdentifier = exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
 exports.stringLiteralTypeAnnotation = exports.StringLiteralTypeAnnotation = StringLiteralTypeAnnotation;
 exports.stringTypeAnnotation = exports.StringTypeAnnotation = StringTypeAnnotation;
@@ -7381,16 +7448,17 @@ exports.optionalMemberExpression = expor
 exports.optionalCallExpression = exports.OptionalCallExpression = OptionalCallExpression;
 exports.classPrivateProperty = exports.ClassPrivateProperty = ClassPrivateProperty;
 exports.import = exports.Import = Import;
 exports.decorator = exports.Decorator = Decorator;
 exports.doExpression = exports.DoExpression = DoExpression;
 exports.exportDefaultSpecifier = exports.ExportDefaultSpecifier = ExportDefaultSpecifier;
 exports.exportNamespaceSpecifier = exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
 exports.privateName = exports.PrivateName = PrivateName;
+exports.bigIntLiteral = exports.BigIntLiteral = BigIntLiteral;
 exports.tSParameterProperty = exports.tsParameterProperty = exports.TSParameterProperty = TSParameterProperty;
 exports.tSDeclareFunction = exports.tsDeclareFunction = exports.TSDeclareFunction = TSDeclareFunction;
 exports.tSDeclareMethod = exports.tsDeclareMethod = exports.TSDeclareMethod = TSDeclareMethod;
 exports.tSQualifiedName = exports.tsQualifiedName = exports.TSQualifiedName = TSQualifiedName;
 exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
 exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
 exports.tSPropertySignature = exports.tsPropertySignature = exports.TSPropertySignature = TSPropertySignature;
 exports.tSMethodSignature = exports.tsMethodSignature = exports.TSMethodSignature = TSMethodSignature;
@@ -7446,1781 +7514,941 @@ exports.numberLiteral = exports.NumberLi
 exports.regexLiteral = exports.RegexLiteral = RegexLiteral;
 exports.restProperty = exports.RestProperty = RestProperty;
 exports.spreadProperty = exports.SpreadProperty = SpreadProperty;
 
 var _builder = _interopRequireDefault(__webpack_require__(2304));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function ArrayExpression() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-
-  return _builder.default.apply(void 0, ["ArrayExpression"].concat(args));
-}
-
-function AssignmentExpression() {
-  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-    args[_key2] = arguments[_key2];
-  }
-
-  return _builder.default.apply(void 0, ["AssignmentExpression"].concat(args));
-}
-
-function BinaryExpression() {
-  for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-    args[_key3] = arguments[_key3];
-  }
-
-  return _builder.default.apply(void 0, ["BinaryExpression"].concat(args));
-}
-
-function Directive() {
-  for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-    args[_key4] = arguments[_key4];
-  }
-
-  return _builder.default.apply(void 0, ["Directive"].concat(args));
-}
-
-function DirectiveLiteral() {
-  for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
-    args[_key5] = arguments[_key5];
-  }
-
-  return _builder.default.apply(void 0, ["DirectiveLiteral"].concat(args));
-}
-
-function BlockStatement() {
-  for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
-    args[_key6] = arguments[_key6];
-  }
-
-  return _builder.default.apply(void 0, ["BlockStatement"].concat(args));
-}
-
-function BreakStatement() {
-  for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
-    args[_key7] = arguments[_key7];
-  }
-
-  return _builder.default.apply(void 0, ["BreakStatement"].concat(args));
-}
-
-function CallExpression() {
-  for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
-    args[_key8] = arguments[_key8];
-  }
-
-  return _builder.default.apply(void 0, ["CallExpression"].concat(args));
-}
-
-function CatchClause() {
-  for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
-    args[_key9] = arguments[_key9];
-  }
-
-  return _builder.default.apply(void 0, ["CatchClause"].concat(args));
-}
-
-function ConditionalExpression() {
-  for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
-    args[_key10] = arguments[_key10];
-  }
-
-  return _builder.default.apply(void 0, ["ConditionalExpression"].concat(args));
-}
-
-function ContinueStatement() {
-  for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
-    args[_key11] = arguments[_key11];
-  }
-
-  return _builder.default.apply(void 0, ["ContinueStatement"].concat(args));
-}
-
-function DebuggerStatement() {
-  for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
-    args[_key12] = arguments[_key12];
-  }
-
-  return _builder.default.apply(void 0, ["DebuggerStatement"].concat(args));
-}
-
-function DoWhileStatement() {
-  for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
-    args[_key13] = arguments[_key13];
-  }
-
-  return _builder.default.apply(void 0, ["DoWhileStatement"].concat(args));
-}
-
-function EmptyStatement() {
-  for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
-    args[_key14] = arguments[_key14];
-  }
-
-  return _builder.default.apply(void 0, ["EmptyStatement"].concat(args));
-}
-
-function ExpressionStatement() {
-  for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
-    args[_key15] = arguments[_key15];
-  }
-
-  return _builder.default.apply(void 0, ["ExpressionStatement"].concat(args));
-}
-
-function File() {
-  for (var _len16 = arguments.length, args = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {
-    args[_key16] = arguments[_key16];
-  }
-
-  return _builder.default.apply(void 0, ["File"].concat(args));
-}
-
-function ForInStatement() {
-  for (var _len17 = arguments.length, args = new Array(_len17), _key17 = 0; _key17 < _len17; _key17++) {
-    args[_key17] = arguments[_key17];
-  }
-
-  return _builder.default.apply(void 0, ["ForInStatement"].concat(args));
-}
-
-function ForStatement() {
-  for (var _len18 = arguments.length, args = new Array(_len18), _key18 = 0; _key18 < _len18; _key18++) {
-    args[_key18] = arguments[_key18];
-  }
-
-  return _builder.default.apply(void 0, ["ForStatement"].concat(args));
-}
-
-function FunctionDeclaration() {
-  for (var _len19 = arguments.length, args = new Array(_len19), _key19 = 0; _key19 < _len19; _key19++) {
-    args[_key19] = arguments[_key19];
-  }
-
-  return _builder.default.apply(void 0, ["FunctionDeclaration"].concat(args));
-}
-
-function FunctionExpression() {
-  for (var _len20 = arguments.length, args = new Array(_len20), _key20 = 0; _key20 < _len20; _key20++) {
-    args[_key20] = arguments[_key20];
-  }
-
-  return _builder.default.apply(void 0, ["FunctionExpression"].concat(args));
-}
-
-function Identifier() {
-  for (var _len21 = arguments.length, args = new Array(_len21), _key21 = 0; _key21 < _len21; _key21++) {
-    args[_key21] = arguments[_key21];
-  }
-
-  return _builder.default.apply(void 0, ["Identifier"].concat(args));
-}
-
-function IfStatement() {
-  for (var _len22 = arguments.length, args = new Array(_len22), _key22 = 0; _key22 < _len22; _key22++) {
-    args[_key22] = arguments[_key22];
-  }
-
-  return _builder.default.apply(void 0, ["IfStatement"].concat(args));
-}
-
-function LabeledStatement() {
-  for (var _len23 = arguments.length, args = new Array(_len23), _key23 = 0; _key23 < _len23; _key23++) {
-    args[_key23] = arguments[_key23];
-  }
-
-  return _builder.default.apply(void 0, ["LabeledStatement"].concat(args));
-}
-
-function StringLiteral() {
-  for (var _len24 = arguments.length, args = new Array(_len24), _key24 = 0; _key24 < _len24; _key24++) {
-    args[_key24] = arguments[_key24];
-  }
-
-  return _builder.default.apply(void 0, ["StringLiteral"].concat(args));
-}
-
-function NumericLiteral() {
-  for (var _len25 = arguments.length, args = new Array(_len25), _key25 = 0; _key25 < _len25; _key25++) {
-    args[_key25] = arguments[_key25];
-  }
-
-  return _builder.default.apply(void 0, ["NumericLiteral"].concat(args));
-}
-
-function NullLiteral() {
-  for (var _len26 = arguments.length, args = new Array(_len26), _key26 = 0; _key26 < _len26; _key26++) {
-    args[_key26] = arguments[_key26];
-  }
-
-  return _builder.default.apply(void 0, ["NullLiteral"].concat(args));
-}
-
-function BooleanLiteral() {
-  for (var _len27 = arguments.length, args = new Array(_len27), _key27 = 0; _key27 < _len27; _key27++) {
-    args[_key27] = arguments[_key27];
-  }
-
-  return _builder.default.apply(void 0, ["BooleanLiteral"].concat(args));
-}
-
-function RegExpLiteral() {
-  for (var _len28 = arguments.length, args = new Array(_len28), _key28 = 0; _key28 < _len28; _key28++) {
-    args[_key28] = arguments[_key28];
-  }
-
-  return _builder.default.apply(void 0, ["RegExpLiteral"].concat(args));
-}
-
-function LogicalExpression() {
-  for (var _len29 = arguments.length, args = new Array(_len29), _key29 = 0; _key29 < _len29; _key29++) {
-    args[_key29] = arguments[_key29];
-  }
-
-  return _builder.default.apply(void 0, ["LogicalExpression"].concat(args));
-}
-
-function MemberExpression() {
-  for (var _len30 = arguments.length, args = new Array(_len30), _key30 = 0; _key30 < _len30; _key30++) {
-    args[_key30] = arguments[_key30];
-  }
-
-  return _builder.default.apply(void 0, ["MemberExpression"].concat(args));
-}
-
-function NewExpression() {
-  for (var _len31 = arguments.length, args = new Array(_len31), _key31 = 0; _key31 < _len31; _key31++) {
-    args[_key31] = arguments[_key31];
-  }
-
-  return _builder.default.apply(void 0, ["NewExpression"].concat(args));
-}
-
-function Program() {
-  for (var _len32 = arguments.length, args = new Array(_len32), _key32 = 0; _key32 < _len32; _key32++) {
-    args[_key32] = arguments[_key32];
-  }
-
-  return _builder.default.apply(void 0, ["Program"].concat(args));
-}
-
-function ObjectExpression() {
-  for (var _len33 = arguments.length, args = new Array(_len33), _key33 = 0; _key33 < _len33; _key33++) {
-    args[_key33] = arguments[_key33];
-  }
-
-  return _builder.default.apply(void 0, ["ObjectExpression"].concat(args));
-}
-
-function ObjectMethod() {
-  for (var _len34 = arguments.length, args = new Array(_len34), _key34 = 0; _key34 < _len34; _key34++) {
-    args[_key34] = arguments[_key34];
-  }
-
-  return _builder.default.apply(void 0, ["ObjectMethod"].concat(args));
-}
-
-function ObjectProperty() {
-  for (var _len35 = arguments.length, args = new Array(_len35), _key35 = 0; _key35 < _len35; _key35++) {
-    args[_key35] = arguments[_key35];
-  }
-
-  return _builder.default.apply(void 0, ["ObjectProperty"].concat(args));
-}
-
-function RestElement() {
-  for (var _len36 = arguments.length, args = new Array(_len36), _key36 = 0; _key36 < _len36; _key36++) {
-    args[_key36] = arguments[_key36];
-  }
-
-  return _builder.default.apply(void 0, ["RestElement"].concat(args));
-}
-
-function ReturnStatement() {
-  for (var _len37 = arguments.length, args = new Array(_len37), _key37 = 0; _key37 < _len37; _key37++) {
-    args[_key37] = arguments[_key37];
-  }
-
-  return _builder.default.apply(void 0, ["ReturnStatement"].concat(args));
-}
-
-function SequenceExpression() {
-  for (var _len38 = arguments.length, args = new Array(_len38), _key38 = 0; _key38 < _len38; _key38++) {
-    args[_key38] = arguments[_key38];
-  }
-
-  return _builder.default.apply(void 0, ["SequenceExpression"].concat(args));
-}
-
-function SwitchCase() {
-  for (var _len39 = arguments.length, args = new Array(_len39), _key39 = 0; _key39 < _len39; _key39++) {
-    args[_key39] = arguments[_key39];
-  }
-
-  return _builder.default.apply(void 0, ["SwitchCase"].concat(args));
-}
-
-function SwitchStatement() {
-  for (var _len40 = arguments.length, args = new Array(_len40), _key40 = 0; _key40 < _len40; _key40++) {
-    args[_key40] = arguments[_key40];
-  }
-
-  return _builder.default.apply(void 0, ["SwitchStatement"].concat(args));
-}
-
-function ThisExpression() {
-  for (var _len41 = arguments.length, args = new Array(_len41), _key41 = 0; _key41 < _len41; _key41++) {
-    args[_key41] = arguments[_key41];
-  }
-
-  return _builder.default.apply(void 0, ["ThisExpression"].concat(args));
-}
-
-function ThrowStatement() {
-  for (var _len42 = arguments.length, args = new Array(_len42), _key42 = 0; _key42 < _len42; _key42++) {
-    args[_key42] = arguments[_key42];
-  }
-
-  return _builder.default.apply(void 0, ["ThrowStatement"].concat(args));
-}
-
-function TryStatement() {
-  for (var _len43 = arguments.length, args = new Array(_len43), _key43 = 0; _key43 < _len43; _key43++) {
-    args[_key43] = arguments[_key43];
-  }
-
-  return _builder.default.apply(void 0, ["TryStatement"].concat(args));
-}
-
-function UnaryExpression() {
-  for (var _len44 = arguments.length, args = new Array(_len44), _key44 = 0; _key44 < _len44; _key44++) {
-    args[_key44] = arguments[_key44];
-  }
-
-  return _builder.default.apply(void 0, ["UnaryExpression"].concat(args));
-}
-
-function UpdateExpression() {
-  for (var _len45 = arguments.length, args = new Array(_len45), _key45 = 0; _key45 < _len45; _key45++) {
-    args[_key45] = arguments[_key45];
-  }
-
-  return _builder.default.apply(void 0, ["UpdateExpression"].concat(args));
-}
-
-function VariableDeclaration() {
-  for (var _len46 = arguments.length, args = new Array(_len46), _key46 = 0; _key46 < _len46; _key46++) {
-    args[_key46] = arguments[_key46];
-  }
-
-  return _builder.default.apply(void 0, ["VariableDeclaration"].concat(args));
-}
-
-function VariableDeclarator() {
-  for (var _len47 = arguments.length, args = new Array(_len47), _key47 = 0; _key47 < _len47; _key47++) {
-    args[_key47] = arguments[_key47];
-  }
-
-  return _builder.default.apply(void 0, ["VariableDeclarator"].concat(args));
-}
-
-function WhileStatement() {
-  for (var _len48 = arguments.length, args = new Array(_len48), _key48 = 0; _key48 < _len48; _key48++) {
-    args[_key48] = arguments[_key48];
-  }
-
-  return _builder.default.apply(void 0, ["WhileStatement"].concat(args));
-}
-
-function WithStatement() {
-  for (var _len49 = arguments.length, args = new Array(_len49), _key49 = 0; _key49 < _len49; _key49++) {
-    args[_key49] = arguments[_key49];
-  }
-
-  return _builder.default.apply(void 0, ["WithStatement"].concat(args));
-}
-
-function AssignmentPattern() {
-  for (var _len50 = arguments.length, args = new Array(_len50), _key50 = 0; _key50 < _len50; _key50++) {
-    args[_key50] = arguments[_key50];
-  }
-
-  return _builder.default.apply(void 0, ["AssignmentPattern"].concat(args));
-}
-
-function ArrayPattern() {
-  for (var _len51 = arguments.length, args = new Array(_len51), _key51 = 0; _key51 < _len51; _key51++) {
-    args[_key51] = arguments[_key51];
-  }
-
-  return _builder.default.apply(void 0, ["ArrayPattern"].concat(args));
-}
-
-function ArrowFunctionExpression() {
-  for (var _len52 = arguments.length, args = new Array(_len52), _key52 = 0; _key52 < _len52; _key52++) {
-    args[_key52] = arguments[_key52];
-  }
-
-  return _builder.default.apply(void 0, ["ArrowFunctionExpression"].concat(args));
-}
-
-function ClassBody() {
-  for (var _len53 = arguments.length, args = new Array(_len53), _key53 = 0; _key53 < _len53; _key53++) {
-    args[_key53] = arguments[_key53];
-  }
-
-  return _builder.default.apply(void 0, ["ClassBody"].concat(args));
-}
-
-function ClassDeclaration() {
-  for (var _len54 = arguments.length, args = new Array(_len54), _key54 = 0; _key54 < _len54; _key54++) {
-    args[_key54] = arguments[_key54];
-  }
-
-  return _builder.default.apply(void 0, ["ClassDeclaration"].concat(args));
-}
-
-function ClassExpression() {
-  for (var _len55 = arguments.length, args = new Array(_len55), _key55 = 0; _key55 < _len55; _key55++) {
-    args[_key55] = arguments[_key55];
-  }
-
-  return _builder.default.apply(void 0, ["ClassExpression"].concat(args));
-}
-
-function ExportAllDeclaration() {
-  for (var _len56 = arguments.length, args = new Array(_len56), _key56 = 0; _key56 < _len56; _key56++) {
-    args[_key56] = arguments[_key56];
-  }
-
-  return _builder.default.apply(void 0, ["ExportAllDeclaration"].concat(args));
-}
-
-function ExportDefaultDeclaration() {
-  for (var _len57 = arguments.length, args = new Array(_len57), _key57 = 0; _key57 < _len57; _key57++) {
-    args[_key57] = arguments[_key57];
-  }
-
-  return _builder.default.apply(void 0, ["ExportDefaultDeclaration"].concat(args));
-}
-
-function ExportNamedDeclaration() {
-  for (var _len58 = arguments.length, args = new Array(_len58), _key58 = 0; _key58 < _len58; _key58++) {
-    args[_key58] = arguments[_key58];
-  }
-
-  return _builder.default.apply(void 0, ["ExportNamedDeclaration"].concat(args));
-}
-
-function ExportSpecifier() {
-  for (var _len59 = arguments.length, args = new Array(_len59), _key59 = 0; _key59 < _len59; _key59++) {
-    args[_key59] = arguments[_key59];
-  }
-
-  return _builder.default.apply(void 0, ["ExportSpecifier"].concat(args));
-}
-
-function ForOfStatement() {
-  for (var _len60 = arguments.length, args = new Array(_len60), _key60 = 0; _key60 < _len60; _key60++) {
-    args[_key60] = arguments[_key60];
-  }
-
-  return _builder.default.apply(void 0, ["ForOfStatement"].concat(args));
-}
-
-function ImportDeclaration() {
-  for (var _len61 = arguments.length, args = new Array(_len61), _key61 = 0; _key61 < _len61; _key61++) {
-    args[_key61] = arguments[_key61];
-  }
-
-  return _builder.default.apply(void 0, ["ImportDeclaration"].concat(args));
-}
-
-function ImportDefaultSpecifier() {
-  for (var _len62 = arguments.length, args = new Array(_len62), _key62 = 0; _key62 < _len62; _key62++) {
-    args[_key62] = arguments[_key62];
-  }
-
-  return _builder.default.apply(void 0, ["ImportDefaultSpecifier"].concat(args));
-}
-
-function ImportNamespaceSpecifier() {
-  for (var _len63 = arguments.length, args = new Array(_len63), _key63 = 0; _key63 < _len63; _key63++) {
-    args[_key63] = arguments[_key63];
-  }
-
-  return _builder.default.apply(void 0, ["ImportNamespaceSpecifier"].concat(args));
-}
-
-function ImportSpecifier() {
-  for (var _len64 = arguments.length, args = new Array(_len64), _key64 = 0; _key64 < _len64; _key64++) {
-    args[_key64] = arguments[_key64];
-  }
-
-  return _builder.default.apply(void 0, ["ImportSpecifier"].concat(args));
-}
-
-function MetaProperty() {
-  for (var _len65 = arguments.length, args = new Array(_len65), _key65 = 0; _key65 < _len65; _key65++) {
-    args[_key65] = arguments[_key65];
-  }
-
-  return _builder.default.apply(void 0, ["MetaProperty"].concat(args));
-}
-
-function ClassMethod() {
-  for (var _len66 = arguments.length, args = new Array(_len66), _key66 = 0; _key66 < _len66; _key66++) {
-    args[_key66] = arguments[_key66];
-  }
-
-  return _builder.default.apply(void 0, ["ClassMethod"].concat(args));
-}
-
-function ObjectPattern() {
-  for (var _len67 = arguments.length, args = new Array(_len67), _key67 = 0; _key67 < _len67; _key67++) {
-    args[_key67] = arguments[_key67];
-  }
-
-  return _builder.default.apply(void 0, ["ObjectPattern"].concat(args));
-}
-
-function SpreadElement() {
-  for (var _len68 = arguments.length, args = new Array(_len68), _key68 = 0; _key68 < _len68; _key68++) {
-    args[_key68] = arguments[_key68];
-  }
-
-  return _builder.default.apply(void 0, ["SpreadElement"].concat(args));
-}
-
-function Super() {
-  for (var _len69 = arguments.length, args = new Array(_len69), _key69 = 0; _key69 < _len69; _key69++) {
-    args[_key69] = arguments[_key69];
-  }
-
-  return _builder.default.apply(void 0, ["Super"].concat(args));
-}
-
-function TaggedTemplateExpression() {
-  for (var _len70 = arguments.length, args = new Array(_len70), _key70 = 0; _key70 < _len70; _key70++) {
-    args[_key70] = arguments[_key70];
-  }
-
-  return _builder.default.apply(void 0, ["TaggedTemplateExpression"].concat(args));
-}
-
-function TemplateElement() {
-  for (var _len71 = arguments.length, args = new Array(_len71), _key71 = 0; _key71 < _len71; _key71++) {
-    args[_key71] = arguments[_key71];
-  }
-
-  return _builder.default.apply(void 0, ["TemplateElement"].concat(args));
-}
-
-function TemplateLiteral() {
-  for (var _len72 = arguments.length, args = new Array(_len72), _key72 = 0; _key72 < _len72; _key72++) {
-    args[_key72] = arguments[_key72];
-  }
-
-  return _builder.default.apply(void 0, ["TemplateLiteral"].concat(args));
-}
-
-function YieldExpression() {
-  for (var _len73 = arguments.length, args = new Array(_len73), _key73 = 0; _key73 < _len73; _key73++) {
-    args[_key73] = arguments[_key73];
-  }
-
-  return _builder.default.apply(void 0, ["YieldExpression"].concat(args));
-}
-
-function AnyTypeAnnotation() {
-  for (var _len74 = arguments.length, args = new Array(_len74), _key74 = 0; _key74 < _len74; _key74++) {
-    args[_key74] = arguments[_key74];
-  }
-
-  return _builder.default.apply(void 0, ["AnyTypeAnnotation"].concat(args));
-}
-
-function ArrayTypeAnnotation() {
-  for (var _len75 = arguments.length, args = new Array(_len75), _key75 = 0; _key75 < _len75; _key75++) {
-    args[_key75] = arguments[_key75];
-  }
-
-  return _builder.default.apply(void 0, ["ArrayTypeAnnotation"].concat(args));
-}
-
-function BooleanTypeAnnotation() {
-  for (var _len76 = arguments.length, args = new Array(_len76), _key76 = 0; _key76 < _len76; _key76++) {
-    args[_key76] = arguments[_key76];
-  }
-
-  return _builder.default.apply(void 0, ["BooleanTypeAnnotation"].concat(args));
-}
-
-function BooleanLiteralTypeAnnotation() {
-  for (var _len77 = arguments.length, args = new Array(_len77), _key77 = 0; _key77 < _len77; _key77++) {
-    args[_key77] = arguments[_key77];
-  }
-
-  return _builder.default.apply(void 0, ["BooleanLiteralTypeAnnotation"].concat(args));
-}
-
-function NullLiteralTypeAnnotation() {
-  for (var _len78 = arguments.length, args = new Array(_len78), _key78 = 0; _key78 < _len78; _key78++) {
-    args[_key78] = arguments[_key78];
-  }
-
-  return _builder.default.apply(void 0, ["NullLiteralTypeAnnotation"].concat(args));
-}
-
-function ClassImplements() {
-  for (var _len79 = arguments.length, args = new Array(_len79), _key79 = 0; _key79 < _len79; _key79++) {
-    args[_key79] = arguments[_key79];
-  }
-
-  return _builder.default.apply(void 0, ["ClassImplements"].concat(args));
-}
-
-function DeclareClass() {
-  for (var _len80 = arguments.length, args = new Array(_len80), _key80 = 0; _key80 < _len80; _key80++) {
-    args[_key80] = arguments[_key80];
-  }
-
-  return _builder.default.apply(void 0, ["DeclareClass"].concat(args));
-}
-
-function DeclareFunction() {
-  for (var _len81 = arguments.length, args = new Array(_len81), _key81 = 0; _key81 < _len81; _key81++) {
-    args[_key81] = arguments[_key81];
-  }
-
-  return _builder.default.apply(void 0, ["DeclareFunction"].concat(args));
-}
-
-function DeclareInterface() {
-  for (var _len82 = arguments.length, args = new Array(_len82), _key82 = 0; _key82 < _len82; _key82++) {
-    args[_key82] = arguments[_key82];
-  }
-
-  return _builder.default.apply(void 0, ["DeclareInterface"].concat(args));
-}
-
-function DeclareModule() {
-  for (var _len83 = arguments.length, args = new Array(_len83), _key83 = 0; _key83 < _len83; _key83++) {
-    args[_key83] = arguments[_key83];
-  }
-
-  return _builder.default.apply(void 0, ["DeclareModule"].concat(args));
-}
-
-function DeclareModuleExports() {
-  for (var _len84 = arguments.length, args = new Array(_len84), _key84 = 0; _key84 < _len84; _key84++) {
-    args[_key84] = arguments[_key84];
-  }
-
-  return _builder.default.apply(void 0, ["DeclareModuleExports"].concat(args));
-}
-
-function DeclareTypeAlias() {
-  for (var _len85 = arguments.length, args = new Array(_len85), _key85 = 0; _key85 < _len85; _key85++) {
-    args[_key85] = arguments[_key85];
-  }
-
-  return _builder.default.apply(void 0, ["DeclareTypeAlias"].concat(args));
-}
-
-function DeclareOpaqueType() {
-  for (var _len86 = arguments.length, args = new Array(_len86), _key86 = 0; _key86 < _len86; _key86++) {
-    args[_key86] = arguments[_key86];
-  }
-
-  return _builder.default.apply(void 0, ["DeclareOpaqueType"].concat(args));
-}
-
-function DeclareVariable() {
-  for (var _len87 = arguments.length, args = new Array(_len87), _key87 = 0; _key87 < _len87; _key87++) {
-    args[_key87] = arguments[_key87];
-  }
-
-  return _builder.default.apply(void 0, ["DeclareVariable"].concat(args));
-}
-
-function DeclareExportDeclaration() {
-  for (var _len88 = arguments.length, args = new Array(_len88), _key88 = 0; _key88 < _len88; _key88++) {
-    args[_key88] = arguments[_key88];
-  }
-
-  return _builder.default.apply(void 0, ["DeclareExportDeclaration"].concat(args));
-}
-
-function DeclareExportAllDeclaration() {
-  for (var _len89 = arguments.length, args = new Array(_len89), _key89 = 0; _key89 < _len89; _key89++) {
-    args[_key89] = arguments[_key89];
-  }
-
-  return _builder.default.apply(void 0, ["DeclareExportAllDeclaration"].concat(args));
-}
-
-function DeclaredPredicate() {
-  for (var _len90 = arguments.length, args = new Array(_len90), _key90 = 0; _key90 < _len90; _key90++) {
-    args[_key90] = arguments[_key90];
-  }
-
-  return _builder.default.apply(void 0, ["DeclaredPredicate"].concat(args));
-}
-
-function ExistsTypeAnnotation() {
-  for (var _len91 = arguments.length, args = new Array(_len91), _key91 = 0; _key91 < _len91; _key91++) {
-    args[_key91] = arguments[_key91];
-  }
-
-  return _builder.default.apply(void 0, ["ExistsTypeAnnotation"].concat(args));
-}
-
-function FunctionTypeAnnotation() {
-  for (var _len92 = arguments.length, args = new Array(_len92), _key92 = 0; _key92 < _len92; _key92++) {
-    args[_key92] = arguments[_key92];
-  }
-
-  return _builder.default.apply(void 0, ["FunctionTypeAnnotation"].concat(args));
-}
-
-function FunctionTypeParam() {
-  for (var _len93 = arguments.length, args = new Array(_len93), _key93 = 0; _key93 < _len93; _key93++) {
-    args[_key93] = arguments[_key93];
-  }
-
-  return _builder.default.apply(void 0, ["FunctionTypeParam"].concat(args));
-}
-
-function GenericTypeAnnotation() {
-  for (var _len94 = arguments.length, args = new Array(_len94), _key94 = 0; _key94 < _len94; _key94++) {
-    args[_key94] = arguments[_key94];
-  }
-
-  return _builder.default.apply(void 0, ["GenericTypeAnnotation"].concat(args));
-}
-
-function InferredPredicate() {
-  for (var _len95 = arguments.length, args = new Array(_len95), _key95 = 0; _key95 < _len95; _key95++) {
-    args[_key95] = arguments[_key95];
-  }
-
-  return _builder.default.apply(void 0, ["InferredPredicate"].concat(args));
-}
-
-function InterfaceExtends() {
-  for (var _len96 = arguments.length, args = new Array(_len96), _key96 = 0; _key96 < _len96; _key96++) {
-    args[_key96] = arguments[_key96];
-  }
-
-  return _builder.default.apply(void 0, ["InterfaceExtends"].concat(args));
-}
-
-function InterfaceDeclaration() {
-  for (var _len97 = arguments.length, args = new Array(_len97), _key97 = 0; _key97 < _len97; _key97++) {
-    args[_key97] = arguments[_key97];
-  }
-
-  return _builder.default.apply(void 0, ["InterfaceDeclaration"].concat(args));
-}
-
-function IntersectionTypeAnnotation() {
-  for (var _len98 = arguments.length, args = new Array(_len98), _key98 = 0; _key98 < _len98; _key98++) {
-    args[_key98] = arguments[_key98];
-  }
-
-  return _builder.default.apply(void 0, ["IntersectionTypeAnnotation"].concat(args));
-}
-
-function MixedTypeAnnotation() {
-  for (var _len99 = arguments.length, args = new Array(_len99), _key99 = 0; _key99 < _len99; _key99++) {
-    args[_key99] = arguments[_key99];
-  }
-
-  return _builder.default.apply(void 0, ["MixedTypeAnnotation"].concat(args));
-}
-
-function EmptyTypeAnnotation() {
-  for (var _len100 = arguments.length, args = new Array(_len100), _key100 = 0; _key100 < _len100; _key100++) {
-    args[_key100] = arguments[_key100];
-  }
-
-  return _builder.default.apply(void 0, ["EmptyTypeAnnotation"].concat(args));
-}
-
-function NullableTypeAnnotation() {
-  for (var _len101 = arguments.length, args = new Array(_len101), _key101 = 0; _key101 < _len101; _key101++) {
-    args[_key101] = arguments[_key101];
-  }
-
-  return _builder.default.apply(void 0, ["NullableTypeAnnotation"].concat(args));
-}
-
-function NumberLiteralTypeAnnotation() {
-  for (var _len102 = arguments.length, args = new Array(_len102), _key102 = 0; _key102 < _len102; _key102++) {
-    args[_key102] = arguments[_key102];
-  }
-
-  return _builder.default.apply(void 0, ["NumberLiteralTypeAnnotation"].concat(args));
-}
-
-function NumberTypeAnnotation() {
-  for (var _len103 = arguments.length, args = new Array(_len103), _key103 = 0; _key103 < _len103; _key103++) {
-    args[_key103] = arguments[_key103];
-  }
-
-  return _builder.default.apply(void 0, ["NumberTypeAnnotation"].concat(args));
-}
-
-function ObjectTypeAnnotation() {
-  for (var _len104 = arguments.length, args = new Array(_len104), _key104 = 0; _key104 < _len104; _key104++) {
-    args[_key104] = arguments[_key104];
-  }
-
-  return _builder.default.apply(void 0, ["ObjectTypeAnnotation"].concat(args));
-}
-
-function ObjectTypeCallProperty() {
-  for (var _len105 = arguments.length, args = new Array(_len105), _key105 = 0; _key105 < _len105; _key105++) {
-    args[_key105] = arguments[_key105];
-  }
-
-  return _builder.default.apply(void 0, ["ObjectTypeCallProperty"].concat(args));
-}
-
-function ObjectTypeIndexer() {
-  for (var _len106 = arguments.length, args = new Array(_len106), _key106 = 0; _key106 < _len106; _key106++) {
-    args[_key106] = arguments[_key106];
-  }
-
-  return _builder.default.apply(void 0, ["ObjectTypeIndexer"].concat(args));
-}
-
-function ObjectTypeProperty() {
-  for (var _len107 = arguments.length, args = new Array(_len107), _key107 = 0; _key107 < _len107; _key107++) {
-    args[_key107] = arguments[_key107];
-  }
-
-  return _builder.default.apply(void 0, ["ObjectTypeProperty"].concat(args));
-}
-
-function ObjectTypeSpreadProperty() {
-  for (var _len108 = arguments.length, args = new Array(_len108), _key108 = 0; _key108 < _len108; _key108++) {
-    args[_key108] = arguments[_key108];
-  }
-
-  return _builder.default.apply(void 0, ["ObjectTypeSpreadProperty"].concat(args));
-}
-
-function OpaqueType() {
-  for (var _len109 = arguments.length, args = new Array(_len109), _key109 = 0; _key109 < _len109; _key109++) {
-    args[_key109] = arguments[_key109];
-  }
-
-  return _builder.default.apply(void 0, ["OpaqueType"].concat(args));
-}
-
-function QualifiedTypeIdentifier() {
-  for (var _len110 = arguments.length, args = new Array(_len110), _key110 = 0; _key110 < _len110; _key110++) {
-    args[_key110] = arguments[_key110];
-  }
-
-  return _builder.default.apply(void 0, ["QualifiedTypeIdentifier"].concat(args));
-}
-
-function StringLiteralTypeAnnotation() {
-  for (var _len111 = arguments.length, args = new Array(_len111), _key111 = 0; _key111 < _len111; _key111++) {
-    args[_key111] = arguments[_key111];
-  }
-
-  return _builder.default.apply(void 0, ["StringLiteralTypeAnnotation"].concat(args));
-}
-
-function StringTypeAnnotation() {
-  for (var _len112 = arguments.length, args = new Array(_len112), _key112 = 0; _key112 < _len112; _key112++) {
-    args[_key112] = arguments[_key112];
-  }
-
-  return _builder.default.apply(void 0, ["StringTypeAnnotation"].concat(args));
-}
-
-function ThisTypeAnnotation() {
-  for (var _len113 = arguments.length, args = new Array(_len113), _key113 = 0; _key113 < _len113; _key113++) {
-    args[_key113] = arguments[_key113];
-  }
-
-  return _builder.default.apply(void 0, ["ThisTypeAnnotation"].concat(args));
-}
-
-function TupleTypeAnnotation() {
-  for (var _len114 = arguments.length, args = new Array(_len114), _key114 = 0; _key114 < _len114; _key114++) {
-    args[_key114] = arguments[_key114];
-  }
-
-  return _builder.default.apply(void 0, ["TupleTypeAnnotation"].concat(args));
-}
-
-function TypeofTypeAnnotation() {
-  for (var _len115 = arguments.length, args = new Array(_len115), _key115 = 0; _key115 < _len115; _key115++) {
-    args[_key115] = arguments[_key115];
-  }
-
-  return _builder.default.apply(void 0, ["TypeofTypeAnnotation"].concat(args));
-}
-
-function TypeAlias() {
-  for (var _len116 = arguments.length, args = new Array(_len116), _key116 = 0; _key116 < _len116; _key116++) {
-    args[_key116] = arguments[_key116];
-  }
-
-  return _builder.default.apply(void 0, ["TypeAlias"].concat(args));
-}
-
-function TypeAnnotation() {
-  for (var _len117 = arguments.length, args = new Array(_len117), _key117 = 0; _key117 < _len117; _key117++) {
-    args[_key117] = arguments[_key117];
-  }
-
-  return _builder.default.apply(void 0, ["TypeAnnotation"].concat(args));
-}
-
-function TypeCastExpression() {
-  for (var _len118 = arguments.length, args = new Array(_len118), _key118 = 0; _key118 < _len118; _key118++) {
-    args[_key118] = arguments[_key118];
-  }
-
-  return _builder.default.apply(void 0, ["TypeCastExpression"].concat(args));
-}
-
-function TypeParameter() {
-  for (var _len119 = arguments.length, args = new Array(_len119), _key119 = 0; _key119 < _len119; _key119++) {
-    args[_key119] = arguments[_key119];
-  }
-
-  return _builder.default.apply(void 0, ["TypeParameter"].concat(args));
-}
-
-function TypeParameterDeclaration() {
-  for (var _len120 = arguments.length, args = new Array(_len120), _key120 = 0; _key120 < _len120; _key120++) {
-    args[_key120] = arguments[_key120];
-  }
-
-  return _builder.default.apply(void 0, ["TypeParameterDeclaration"].concat(args));
-}
-
-function TypeParameterInstantiation() {
-  for (var _len121 = arguments.length, args = new Array(_len121), _key121 = 0; _key121 < _len121; _key121++) {
-    args[_key121] = arguments[_key121];
-  }
-
-  return _builder.default.apply(void 0, ["TypeParameterInstantiation"].concat(args));
-}
-
-function UnionTypeAnnotation() {
-  for (var _len122 = arguments.length, args = new Array(_len122), _key122 = 0; _key122 < _len122; _key122++) {
-    args[_key122] = arguments[_key122];
-  }
-
-  return _builder.default.apply(void 0, ["UnionTypeAnnotation"].concat(args));
-}
-
-function Variance() {
-  for (var _len123 = arguments.length, args = new Array(_len123), _key123 = 0; _key123 < _len123; _key123++) {
-    args[_key123] = arguments[_key123];
-  }
-
-  return _builder.default.apply(void 0, ["Variance"].concat(args));
-}
-
-function VoidTypeAnnotation() {
-  for (var _len124 = arguments.length, args = new Array(_len124), _key124 = 0; _key124 < _len124; _key124++) {
-    args[_key124] = arguments[_key124];
-  }
-
-  return _builder.default.apply(void 0, ["VoidTypeAnnotation"].concat(args));
-}
-
-function JSXAttribute() {
-  for (var _len125 = arguments.length, args = new Array(_len125), _key125 = 0; _key125 < _len125; _key125++) {
-    args[_key125] = arguments[_key125];
-  }
-
-  return _builder.default.apply(void 0, ["JSXAttribute"].concat(args));
-}
-
-function JSXClosingElement() {
-  for (var _len126 = arguments.length, args = new Array(_len126), _key126 = 0; _key126 < _len126; _key126++) {
-    args[_key126] = arguments[_key126];
-  }
-
-  return _builder.default.apply(void 0, ["JSXClosingElement"].concat(args));
-}
-
-function JSXElement() {
-  for (var _len127 = arguments.length, args = new Array(_len127), _key127 = 0; _key127 < _len127; _key127++) {
-    args[_key127] = arguments[_key127];
-  }
-
-  return _builder.default.apply(void 0, ["JSXElement"].concat(args));
-}
-
-function JSXEmptyExpression() {
-  for (var _len128 = arguments.length, args = new Array(_len128), _key128 = 0; _key128 < _len128; _key128++) {
-    args[_key128] = arguments[_key128];
-  }
-
-  return _builder.default.apply(void 0, ["JSXEmptyExpression"].concat(args));
-}
-
-function JSXExpressionContainer() {
-  for (var _len129 = arguments.length, args = new Array(_len129), _key129 = 0; _key129 < _len129; _key129++) {
-    args[_key129] = arguments[_key129];
-  }
-
-  return _builder.default.apply(void 0, ["JSXExpressionContainer"].concat(args));
-}
-
-function JSXSpreadChild() {
-  for (var _len130 = arguments.length, args = new Array(_len130), _key130 = 0; _key130 < _len130; _key130++) {
-    args[_key130] = arguments[_key130];
-  }
-
-  return _builder.default.apply(void 0, ["JSXSpreadChild"].concat(args));
-}
-
-function JSXIdentifier() {
-  for (var _len131 = arguments.length, args = new Array(_len131), _key131 = 0; _key131 < _len131; _key131++) {
-    args[_key131] = arguments[_key131];
-  }
-
-  return _builder.default.apply(void 0, ["JSXIdentifier"].concat(args));
-}
-
-function JSXMemberExpression() {
-  for (var _len132 = arguments.length, args = new Array(_len132), _key132 = 0; _key132 < _len132; _key132++) {
-    args[_key132] = arguments[_key132];
-  }
-
-  return _builder.default.apply(void 0, ["JSXMemberExpression"].concat(args));
-}
-
-function JSXNamespacedName() {
-  for (var _len133 = arguments.length, args = new Array(_len133), _key133 = 0; _key133 < _len133; _key133++) {
-    args[_key133] = arguments[_key133];
-  }
-
-  return _builder.default.apply(void 0, ["JSXNamespacedName"].concat(args));
-}
-
-function JSXOpeningElement() {
-  for (var _len134 = arguments.length, args = new Array(_len134), _key134 = 0; _key134 < _len134; _key134++) {
-    args[_key134] = arguments[_key134];
-  }
-
-  return _builder.default.apply(void 0, ["JSXOpeningElement"].concat(args));
-}
-
-function JSXSpreadAttribute() {
-  for (var _len135 = arguments.length, args = new Array(_len135), _key135 = 0; _key135 < _len135; _key135++) {
-    args[_key135] = arguments[_key135];
-  }
-
-  return _builder.default.apply(void 0, ["JSXSpreadAttribute"].concat(args));
-}
-
-function JSXText() {
-  for (var _len136 = arguments.length, args = new Array(_len136), _key136 = 0; _key136 < _len136; _key136++) {
-    args[_key136] = arguments[_key136];
-  }
-
-  return _builder.default.apply(void 0, ["JSXText"].concat(args));
-}
-
-function JSXFragment() {
-  for (var _len137 = arguments.length, args = new Array(_len137), _key137 = 0; _key137 < _len137; _key137++) {
-    args[_key137] = arguments[_key137];
-  }
-
-  return _builder.default.apply(void 0, ["JSXFragment"].concat(args));
-}
-
-function JSXOpeningFragment() {
-  for (var _len138 = arguments.length, args = new Array(_len138), _key138 = 0; _key138 < _len138; _key138++) {
-    args[_key138] = arguments[_key138];
-  }
-
-  return _builder.default.apply(void 0, ["JSXOpeningFragment"].concat(args));
-}
-
-function JSXClosingFragment() {
-  for (var _len139 = arguments.length, args = new Array(_len139), _key139 = 0; _key139 < _len139; _key139++) {
-    args[_key139] = arguments[_key139];
-  }
-
-  return _builder.default.apply(void 0, ["JSXClosingFragment"].concat(args));
-}
-
-function Noop() {
-  for (var _len140 = arguments.length, args = new Array(_len140), _key140 = 0; _key140 < _len140; _key140++) {
-    args[_key140] = arguments[_key140];
-  }
-
-  return _builder.default.apply(void 0, ["Noop"].concat(args));
-}
-
-function ParenthesizedExpression() {
-  for (var _len141 = arguments.length, args = new Array(_len141), _key141 = 0; _key141 < _len141; _key141++) {
-    args[_key141] = arguments[_key141];
-  }
-
-  return _builder.default.apply(void 0, ["ParenthesizedExpression"].concat(args));
-}
-
-function AwaitExpression() {
-  for (var _len142 = arguments.length, args = new Array(_len142), _key142 = 0; _key142 < _len142; _key142++) {
-    args[_key142] = arguments[_key142];
-  }
-
-  return _builder.default.apply(void 0, ["AwaitExpression"].concat(args));
-}
-
-function BindExpression() {
-  for (var _len143 = arguments.length, args = new Array(_len143), _key143 = 0; _key143 < _len143; _key143++) {
-    args[_key143] = arguments[_key143];
-  }
-
-  return _builder.default.apply(void 0, ["BindExpression"].concat(args));
-}
-
-function ClassProperty() {
-  for (var _len144 = arguments.length, args = new Array(_len144), _key144 = 0; _key144 < _len144; _key144++) {
-    args[_key144] = arguments[_key144];
-  }
-
-  return _builder.default.apply(void 0, ["ClassProperty"].concat(args));
-}
-
-function OptionalMemberExpression() {
-  for (var _len145 = arguments.length, args = new Array(_len145), _key145 = 0; _key145 < _len145; _key145++) {
-    args[_key145] = arguments[_key145];
-  }
-
-  return _builder.default.apply(void 0, ["OptionalMemberExpression"].concat(args));
-}
-
-function OptionalCallExpression() {
-  for (var _len146 = arguments.length, args = new Array(_len146), _key146 = 0; _key146 < _len146; _key146++) {
-    args[_key146] = arguments[_key146];
-  }
-
-  return _builder.default.apply(void 0, ["OptionalCallExpression"].concat(args));
-}
-
-function ClassPrivateProperty() {
-  for (var _len147 = arguments.length, args = new Array(_len147), _key147 = 0; _key147 < _len147; _key147++) {
-    args[_key147] = arguments[_key147];
-  }
-
-  return _builder.default.apply(void 0, ["ClassPrivateProperty"].concat(args));
-}
-
-function Import() {
-  for (var _len148 = arguments.length, args = new Array(_len148), _key148 = 0; _key148 < _len148; _key148++) {
-    args[_key148] = arguments[_key148];
-  }
-
-  return _builder.default.apply(void 0, ["Import"].concat(args));
-}
-
-function Decorator() {
-  for (var _len149 = arguments.length, args = new Array(_len149), _key149 = 0; _key149 < _len149; _key149++) {
-    args[_key149] = arguments[_key149];
-  }
-
-  return _builder.default.apply(void 0, ["Decorator"].concat(args));
-}
-
-function DoExpression() {
-  for (var _len150 = arguments.length, args = new Array(_len150), _key150 = 0; _key150 < _len150; _key150++) {
-    args[_key150] = arguments[_key150];
-  }
-
-  return _builder.default.apply(void 0, ["DoExpression"].concat(args));
-}
-
-function ExportDefaultSpecifier() {
-  for (var _len151 = arguments.length, args = new Array(_len151), _key151 = 0; _key151 < _len151; _key151++) {
-    args[_key151] = arguments[_key151];
-  }
-
-  return _builder.default.apply(void 0, ["ExportDefaultSpecifier"].concat(args));
-}
-
-function ExportNamespaceSpecifier() {
-  for (var _len152 = arguments.length, args = new Array(_len152), _key152 = 0; _key152 < _len152; _key152++) {
-    args[_key152] = arguments[_key152];
-  }
-
-  return _builder.default.apply(void 0, ["ExportNamespaceSpecifier"].concat(args));
-}
-
-function PrivateName() {
-  for (var _len153 = arguments.length, args = new Array(_len153), _key153 = 0; _key153 < _len153; _key153++) {
-    args[_key153] = arguments[_key153];
-  }
-
-  return _builder.default.apply(void 0, ["PrivateName"].concat(args));
-}
-
-function TSParameterProperty() {
-  for (var _len154 = arguments.length, args = new Array(_len154), _key154 = 0; _key154 < _len154; _key154++) {
-    args[_key154] = arguments[_key154];
-  }
-
-  return _builder.default.apply(void 0, ["TSParameterProperty"].concat(args));
-}
-
-function TSDeclareFunction() {
-  for (var _len155 = arguments.length, args = new Array(_len155), _key155 = 0; _key155 < _len155; _key155++) {
-    args[_key155] = arguments[_key155];
-  }
-
-  return _builder.default.apply(void 0, ["TSDeclareFunction"].concat(args));
-}
-
-function TSDeclareMethod() {
-  for (var _len156 = arguments.length, args = new Array(_len156), _key156 = 0; _key156 < _len156; _key156++) {
-    args[_key156] = arguments[_key156];
-  }
-
-  return _builder.default.apply(void 0, ["TSDeclareMethod"].concat(args));
-}
-
-function TSQualifiedName() {
-  for (var _len157 = arguments.length, args = new Array(_len157), _key157 = 0; _key157 < _len157; _key157++) {
-    args[_key157] = arguments[_key157];
-  }
-
-  return _builder.default.apply(void 0, ["TSQualifiedName"].concat(args));
-}
-
-function TSCallSignatureDeclaration() {
-  for (var _len158 = arguments.length, args = new Array(_len158), _key158 = 0; _key158 < _len158; _key158++) {
-    args[_key158] = arguments[_key158];
-  }
-
-  return _builder.default.apply(void 0, ["TSCallSignatureDeclaration"].concat(args));
-}
-
-function TSConstructSignatureDeclaration() {
-  for (var _len159 = arguments.length, args = new Array(_len159), _key159 = 0; _key159 < _len159; _key159++) {
-    args[_key159] = arguments[_key159];
-  }
-
-  return _builder.default.apply(void 0, ["TSConstructSignatureDeclaration"].concat(args));
-}
-
-function TSPropertySignature() {
-  for (var _len160 = arguments.length, args = new Array(_len160), _key160 = 0; _key160 < _len160; _key160++) {
-    args[_key160] = arguments[_key160];
-  }
-
-  return _builder.default.apply(void 0, ["TSPropertySignature"].concat(args));
-}
-
-function TSMethodSignature() {
-  for (var _len161 = arguments.length, args = new Array(_len161), _key161 = 0; _key161 < _len161; _key161++) {
-    args[_key161] = arguments[_key161];
-  }
-
-  return _builder.default.apply(void 0, ["TSMethodSignature"].concat(args));
-}
-
-function TSIndexSignature() {
-  for (var _len162 = arguments.length, args = new Array(_len162), _key162 = 0; _key162 < _len162; _key162++) {
-    args[_key162] = arguments[_key162];
-  }
-
-  return _builder.default.apply(void 0, ["TSIndexSignature"].concat(args));
-}
-
-function TSAnyKeyword() {
-  for (var _len163 = arguments.length, args = new Array(_len163), _key163 = 0; _key163 < _len163; _key163++) {
-    args[_key163] = arguments[_key163];
-  }
-
-  return _builder.default.apply(void 0, ["TSAnyKeyword"].concat(args));
-}
-
-function TSNumberKeyword() {
-  for (var _len164 = arguments.length, args = new Array(_len164), _key164 = 0; _key164 < _len164; _key164++) {
-    args[_key164] = arguments[_key164];
-  }
-
-  return _builder.default.apply(void 0, ["TSNumberKeyword"].concat(args));
-}
-
-function TSObjectKeyword() {
-  for (var _len165 = arguments.length, args = new Array(_len165), _key165 = 0; _key165 < _len165; _key165++) {
-    args[_key165] = arguments[_key165];
-  }
-
-  return _builder.default.apply(void 0, ["TSObjectKeyword"].concat(args));
-}
-
-function TSBooleanKeyword() {
-  for (var _len166 = arguments.length, args = new Array(_len166), _key166 = 0; _key166 < _len166; _key166++) {
-    args[_key166] = arguments[_key166];
-  }
-
-  return _builder.default.apply(void 0, ["TSBooleanKeyword"].concat(args));
-}
-
-function TSStringKeyword() {
-  for (var _len167 = arguments.length, args = new Array(_len167), _key167 = 0; _key167 < _len167; _key167++) {
-    args[_key167] = arguments[_key167];
-  }
-
-  return _builder.default.apply(void 0, ["TSStringKeyword"].concat(args));
-}
-
-function TSSymbolKeyword() {
-  for (var _len168 = arguments.length, args = new Array(_len168), _key168 = 0; _key168 < _len168; _key168++) {
-    args[_key168] = arguments[_key168];
-  }
-
-  return _builder.default.apply(void 0, ["TSSymbolKeyword"].concat(args));
-}
-
-function TSVoidKeyword() {
-  for (var _len169 = arguments.length, args = new Array(_len169), _key169 = 0; _key169 < _len169; _key169++) {
-    args[_key169] = arguments[_key169];
-  }
-
-  return _builder.default.apply(void 0, ["TSVoidKeyword"].concat(args));
-}
-
-function TSUndefinedKeyword() {
-  for (var _len170 = arguments.length, args = new Array(_len170), _key170 = 0; _key170 < _len170; _key170++) {
-    args[_key170] = arguments[_key170];
-  }
-
-  return _builder.default.apply(void 0, ["TSUndefinedKeyword"].concat(args));
-}
-
-function TSNullKeyword() {
-  for (var _len171 = arguments.length, args = new Array(_len171), _key171 = 0; _key171 < _len171; _key171++) {
-    args[_key171] = arguments[_key171];
-  }
-
-  return _builder.default.apply(void 0, ["TSNullKeyword"].concat(args));
-}
-
-function TSNeverKeyword() {
-  for (var _len172 = arguments.length, args = new Array(_len172), _key172 = 0; _key172 < _len172; _key172++) {
-    args[_key172] = arguments[_key172];
-  }
-
-  return _builder.default.apply(void 0, ["TSNeverKeyword"].concat(args));
-}
-
-function TSThisType() {
-  for (var _len173 = arguments.length, args = new Array(_len173), _key173 = 0; _key173 < _len173; _key173++) {
-    args[_key173] = arguments[_key173];
-  }
-
-  return _builder.default.apply(void 0, ["TSThisType"].concat(args));
-}
-
-function TSFunctionType() {
-  for (var _len174 = arguments.length, args = new Array(_len174), _key174 = 0; _key174 < _len174; _key174++) {
-    args[_key174] = arguments[_key174];
-  }
-
-  return _builder.default.apply(void 0, ["TSFunctionType"].concat(args));
-}
-
-function TSConstructorType() {
-  for (var _len175 = arguments.length, args = new Array(_len175), _key175 = 0; _key175 < _len175; _key175++) {
-    args[_key175] = arguments[_key175];
-  }
-
-  return _builder.default.apply(void 0, ["TSConstructorType"].concat(args));
-}
-
-function TSTypeReference() {
-  for (var _len176 = arguments.length, args = new Array(_len176), _key176 = 0; _key176 < _len176; _key176++) {
-    args[_key176] = arguments[_key176];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypeReference"].concat(args));
-}
-
-function TSTypePredicate() {
-  for (var _len177 = arguments.length, args = new Array(_len177), _key177 = 0; _key177 < _len177; _key177++) {
-    args[_key177] = arguments[_key177];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypePredicate"].concat(args));
-}
-
-function TSTypeQuery() {
-  for (var _len178 = arguments.length, args = new Array(_len178), _key178 = 0; _key178 < _len178; _key178++) {
-    args[_key178] = arguments[_key178];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypeQuery"].concat(args));
-}
-
-function TSTypeLiteral() {
-  for (var _len179 = arguments.length, args = new Array(_len179), _key179 = 0; _key179 < _len179; _key179++) {
-    args[_key179] = arguments[_key179];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypeLiteral"].concat(args));
-}
-
-function TSArrayType() {
-  for (var _len180 = arguments.length, args = new Array(_len180), _key180 = 0; _key180 < _len180; _key180++) {
-    args[_key180] = arguments[_key180];
-  }
-
-  return _builder.default.apply(void 0, ["TSArrayType"].concat(args));
-}
-
-function TSTupleType() {
-  for (var _len181 = arguments.length, args = new Array(_len181), _key181 = 0; _key181 < _len181; _key181++) {
-    args[_key181] = arguments[_key181];
-  }
-
-  return _builder.default.apply(void 0, ["TSTupleType"].concat(args));
-}
-
-function TSUnionType() {
-  for (var _len182 = arguments.length, args = new Array(_len182), _key182 = 0; _key182 < _len182; _key182++) {
-    args[_key182] = arguments[_key182];
-  }
-
-  return _builder.default.apply(void 0, ["TSUnionType"].concat(args));
-}
-
-function TSIntersectionType() {
-  for (var _len183 = arguments.length, args = new Array(_len183), _key183 = 0; _key183 < _len183; _key183++) {
-    args[_key183] = arguments[_key183];
-  }
-
-  return _builder.default.apply(void 0, ["TSIntersectionType"].concat(args));
-}
-
-function TSConditionalType() {
-  for (var _len184 = arguments.length, args = new Array(_len184), _key184 = 0; _key184 < _len184; _key184++) {
-    args[_key184] = arguments[_key184];
-  }
-
-  return _builder.default.apply(void 0, ["TSConditionalType"].concat(args));
-}
-
-function TSInferType() {
-  for (var _len185 = arguments.length, args = new Array(_len185), _key185 = 0; _key185 < _len185; _key185++) {
-    args[_key185] = arguments[_key185];
-  }
-
-  return _builder.default.apply(void 0, ["TSInferType"].concat(args));
-}
-
-function TSParenthesizedType() {
-  for (var _len186 = arguments.length, args = new Array(_len186), _key186 = 0; _key186 < _len186; _key186++) {
-    args[_key186] = arguments[_key186];
-  }
-
-  return _builder.default.apply(void 0, ["TSParenthesizedType"].concat(args));
-}
-
-function TSTypeOperator() {
-  for (var _len187 = arguments.length, args = new Array(_len187), _key187 = 0; _key187 < _len187; _key187++) {
-    args[_key187] = arguments[_key187];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypeOperator"].concat(args));
-}
-
-function TSIndexedAccessType() {
-  for (var _len188 = arguments.length, args = new Array(_len188), _key188 = 0; _key188 < _len188; _key188++) {
-    args[_key188] = arguments[_key188];
-  }
-
-  return _builder.default.apply(void 0, ["TSIndexedAccessType"].concat(args));
-}
-
-function TSMappedType() {
-  for (var _len189 = arguments.length, args = new Array(_len189), _key189 = 0; _key189 < _len189; _key189++) {
-    args[_key189] = arguments[_key189];
-  }
-
-  return _builder.default.apply(void 0, ["TSMappedType"].concat(args));
-}
-
-function TSLiteralType() {
-  for (var _len190 = arguments.length, args = new Array(_len190), _key190 = 0; _key190 < _len190; _key190++) {
-    args[_key190] = arguments[_key190];
-  }
-
-  return _builder.default.apply(void 0, ["TSLiteralType"].concat(args));
-}
-
-function TSExpressionWithTypeArguments() {
-  for (var _len191 = arguments.length, args = new Array(_len191), _key191 = 0; _key191 < _len191; _key191++) {
-    args[_key191] = arguments[_key191];
-  }
-
-  return _builder.default.apply(void 0, ["TSExpressionWithTypeArguments"].concat(args));
-}
-
-function TSInterfaceDeclaration() {
-  for (var _len192 = arguments.length, args = new Array(_len192), _key192 = 0; _key192 < _len192; _key192++) {
-    args[_key192] = arguments[_key192];
-  }
-
-  return _builder.default.apply(void 0, ["TSInterfaceDeclaration"].concat(args));
-}
-
-function TSInterfaceBody() {
-  for (var _len193 = arguments.length, args = new Array(_len193), _key193 = 0; _key193 < _len193; _key193++) {
-    args[_key193] = arguments[_key193];
-  }
-
-  return _builder.default.apply(void 0, ["TSInterfaceBody"].concat(args));
-}
-
-function TSTypeAliasDeclaration() {
-  for (var _len194 = arguments.length, args = new Array(_len194), _key194 = 0; _key194 < _len194; _key194++) {
-    args[_key194] = arguments[_key194];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypeAliasDeclaration"].concat(args));
-}
-
-function TSAsExpression() {
-  for (var _len195 = arguments.length, args = new Array(_len195), _key195 = 0; _key195 < _len195; _key195++) {
-    args[_key195] = arguments[_key195];
-  }
-
-  return _builder.default.apply(void 0, ["TSAsExpression"].concat(args));
-}
-
-function TSTypeAssertion() {
-  for (var _len196 = arguments.length, args = new Array(_len196), _key196 = 0; _key196 < _len196; _key196++) {
-    args[_key196] = arguments[_key196];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypeAssertion"].concat(args));
-}
-
-function TSEnumDeclaration() {
-  for (var _len197 = arguments.length, args = new Array(_len197), _key197 = 0; _key197 < _len197; _key197++) {
-    args[_key197] = arguments[_key197];
-  }
-
-  return _builder.default.apply(void 0, ["TSEnumDeclaration"].concat(args));
-}
-
-function TSEnumMember() {
-  for (var _len198 = arguments.length, args = new Array(_len198), _key198 = 0; _key198 < _len198; _key198++) {
-    args[_key198] = arguments[_key198];
-  }
-
-  return _builder.default.apply(void 0, ["TSEnumMember"].concat(args));
-}
-
-function TSModuleDeclaration() {
-  for (var _len199 = arguments.length, args = new Array(_len199), _key199 = 0; _key199 < _len199; _key199++) {
-    args[_key199] = arguments[_key199];
-  }
-
-  return _builder.default.apply(void 0, ["TSModuleDeclaration"].concat(args));
-}
-
-function TSModuleBlock() {
-  for (var _len200 = arguments.length, args = new Array(_len200), _key200 = 0; _key200 < _len200; _key200++) {
-    args[_key200] = arguments[_key200];
-  }
-
-  return _builder.default.apply(void 0, ["TSModuleBlock"].concat(args));
-}
-
-function TSImportEqualsDeclaration() {
-  for (var _len201 = arguments.length, args = new Array(_len201), _key201 = 0; _key201 < _len201; _key201++) {
-    args[_key201] = arguments[_key201];
-  }
-
-  return _builder.default.apply(void 0, ["TSImportEqualsDeclaration"].concat(args));
-}
-
-function TSExternalModuleReference() {
-  for (var _len202 = arguments.length, args = new Array(_len202), _key202 = 0; _key202 < _len202; _key202++) {
-    args[_key202] = arguments[_key202];
-  }
-
-  return _builder.default.apply(void 0, ["TSExternalModuleReference"].concat(args));
-}
-
-function TSNonNullExpression() {
-  for (var _len203 = arguments.length, args = new Array(_len203), _key203 = 0; _key203 < _len203; _key203++) {
-    args[_key203] = arguments[_key203];
-  }
-
-  return _builder.default.apply(void 0, ["TSNonNullExpression"].concat(args));
-}
-
-function TSExportAssignment() {
-  for (var _len204 = arguments.length, args = new Array(_len204), _key204 = 0; _key204 < _len204; _key204++) {
-    args[_key204] = arguments[_key204];
-  }
-
-  return _builder.default.apply(void 0, ["TSExportAssignment"].concat(args));
-}
-
-function TSNamespaceExportDeclaration() {
-  for (var _len205 = arguments.length, args = new Array(_len205), _key205 = 0; _key205 < _len205; _key205++) {
-    args[_key205] = arguments[_key205];
-  }
-
-  return _builder.default.apply(void 0, ["TSNamespaceExportDeclaration"].concat(args));
-}
-
-function TSTypeAnnotation() {
-  for (var _len206 = arguments.length, args = new Array(_len206), _key206 = 0; _key206 < _len206; _key206++) {
-    args[_key206] = arguments[_key206];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypeAnnotation"].concat(args));
-}
-
-function TSTypeParameterInstantiation() {
-  for (var _len207 = arguments.length, args = new Array(_len207), _key207 = 0; _key207 < _len207; _key207++) {
-    args[_key207] = arguments[_key207];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypeParameterInstantiation"].concat(args));
-}
-
-function TSTypeParameterDeclaration() {
-  for (var _len208 = arguments.length, args = new Array(_len208), _key208 = 0; _key208 < _len208; _key208++) {
-    args[_key208] = arguments[_key208];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypeParameterDeclaration"].concat(args));
-}
-
-function TSTypeParameter() {
-  for (var _len209 = arguments.length, args = new Array(_len209), _key209 = 0; _key209 < _len209; _key209++) {
-    args[_key209] = arguments[_key209];
-  }
-
-  return _builder.default.apply(void 0, ["TSTypeParameter"].concat(args));
-}
-
-function NumberLiteral() {
+function ArrayExpression(...args) {
+  return (0, _builder.default)("ArrayExpression", ...args);
+}
+
+function AssignmentExpression(...args) {
+  return (0, _builder.default)("AssignmentExpression", ...args);
+}
+
+function BinaryExpression(...args) {
+  return (0, _builder.default)("BinaryExpression", ...args);
+}
+
+function InterpreterDirective(...args) {
+  return (0, _builder.default)("InterpreterDirective", ...args);
+}
+
+function Directive(...args) {
+  return (0, _builder.default)("Directive", ...args);
+}
+
+function DirectiveLiteral(...args) {
+  return (0, _builder.default)("DirectiveLiteral", ...args);
+}
+
+function BlockStatement(...args) {
+  return (0, _builder.default)("BlockStatement", ...args);
+}
+
+function BreakStatement(...args) {
+  return (0, _builder.default)("BreakStatement", ...args);
+}
+
+function CallExpression(...args) {
+  return (0, _builder.default)("CallExpression", ...args);
+}
+
+function CatchClause(...args) {
+  return (0, _builder.default)("CatchClause", ...args);
+}
+
+function ConditionalExpression(...args) {
+  return (0, _builder.default)("ConditionalExpression", ...args);
+}
+
+function ContinueStatement(...args) {
+  return (0, _builder.default)("ContinueStatement", ...args);
+}
+
+function DebuggerStatement(...args) {
+  return (0, _builder.default)("DebuggerStatement", ...args);
+}
+
+function DoWhileStatement(...args) {
+  return (0, _builder.default)("DoWhileStatement", ...args);
+}
+
+function EmptyStatement(...args) {
+  return (0, _builder.default)("EmptyStatement", ...args);
+}
+
+function ExpressionStatement(...args) {
+  return (0, _builder.default)("ExpressionStatement", ...args);
+}
+
+function File(...args) {
+  return (0, _builder.default)("File", ...args);
+}
+
+function ForInStatement(...args) {
+  return (0, _builder.default)("ForInStatement", ...args);
+}
+
+function ForStatement(...args) {
+  return (0, _builder.default)("ForStatement", ...args);
+}
+
+function FunctionDeclaration(...args) {
+  return (0, _builder.default)("FunctionDeclaration", ...args);
+}
+
+function FunctionExpression(...args) {
+  return (0, _builder.default)("FunctionExpression", ...args);
+}
+
+function Identifier(...args) {
+  return (0, _builder.default)("Identifier", ...args);
+}
+
+function IfStatement(...args) {
+  return (0, _builder.default)("IfStatement", ...args);
+}
+
+function LabeledStatement(...args) {
+  return (0, _builder.default)("LabeledStatement", ...args);
+}
+
+function StringLiteral(...args) {
+  return (0, _builder.default)("StringLiteral", ...args);
+}
+
+function NumericLiteral(...args) {
+  return (0, _builder.default)("NumericLiteral", ...args);
+}
+
+function NullLiteral(...args) {
+  return (0, _builder.default)("NullLiteral", ...args);
+}
+
+function BooleanLiteral(...args) {
+  return (0, _builder.default)("BooleanLiteral", ...args);
+}
+
+function RegExpLiteral(...args) {
+  return (0, _builder.default)("RegExpLiteral", ...args);
+}
+
+function LogicalExpression(...args) {
+  return (0, _builder.default)("LogicalExpression", ...args);
+}
+
+function MemberExpression(...args) {
+  return (0, _builder.default)("MemberExpression", ...args);
+}
+
+function NewExpression(...args) {
+  return (0, _builder.default)("NewExpression", ...args);
+}
+
+function Program(...args) {
+  return (0, _builder.default)("Program", ...args);
+}
+
+function ObjectExpression(...args) {
+  return (0, _builder.default)("ObjectExpression", ...args);
+}
+
+function ObjectMethod(...args) {
+  return (0, _builder.default)("ObjectMethod", ...args);
+}
+
+function ObjectProperty(...args) {
+  return (0, _builder.default)("ObjectProperty", ...args);
+}
+
+function RestElement(...args) {
+  return (0, _builder.default)("RestElement", ...args);
+}
+
+function ReturnStatement(...args) {
+  return (0, _builder.default)("ReturnStatement", ...args);
+}
+
+function SequenceExpression(...args) {
+  return (0, _builder.default)("SequenceExpression", ...args);
+}
+
+function SwitchCase(...args) {
+  return (0, _builder.default)("SwitchCase", ...args);
+}
+
+function SwitchStatement(...args) {
+  return (0, _builder.default)("SwitchStatement", ...args);
+}
+
+function ThisExpression(...args) {
+  return (0, _builder.default)("ThisExpression", ...args);
+}
+
+function ThrowStatement(...args) {
+  return (0, _builder.default)("ThrowStatement", ...args);
+}
+
+function TryStatement(...args) {
+  return (0, _builder.default)("TryStatement", ...args);
+}
+
+function UnaryExpression(...args) {
+  return (0, _builder.default)("UnaryExpression", ...args);
+}
+
+function UpdateExpression(...args) {
+  return (0, _builder.default)("UpdateExpression", ...args);
+}
+
+function VariableDeclaration(...args) {
+  return (0, _builder.default)("VariableDeclaration", ...args);
+}
+
+function VariableDeclarator(...args) {
+  return (0, _builder.default)("VariableDeclarator", ...args);
+}
+
+function WhileStatement(...args) {
+  return (0, _builder.default)("WhileStatement", ...args);
+}
+
+function WithStatement(...args) {
+  return (0, _builder.default)("WithStatement", ...args);
+}
+
+function AssignmentPattern(...args) {
+  return (0, _builder.default)("AssignmentPattern", ...args);
+}
+
+function ArrayPattern(...args) {
+  return (0, _builder.default)("ArrayPattern", ...args);
+}
+
+function ArrowFunctionExpression(...args) {
+  return (0, _builder.default)("ArrowFunctionExpression", ...args);
+}
+
+function ClassBody(...args) {
+  return (0, _builder.default)("ClassBody", ...args);
+}
+
+function ClassDeclaration(...args) {
+  return (0, _builder.default)("ClassDeclaration", ...args);
+}
+
+function ClassExpression(...args) {
+  return (0, _builder.default)("ClassExpression", ...args);
+}
+
+function ExportAllDeclaration(...args) {
+  return (0, _builder.default)("ExportAllDeclaration", ...args);
+}
+
+function ExportDefaultDeclaration(...args) {
+  return (0, _builder.default)("ExportDefaultDeclaration", ...args);
+}
+
+function ExportNamedDeclaration(...args) {
+  return (0, _builder.default)("ExportNamedDeclaration", ...args);
+}
+
+function ExportSpecifier(...args) {
+  return (0, _builder.default)("ExportSpecifier", ...args);
+}
+
+function ForOfStatement(...args) {
+  return (0, _builder.default)("ForOfStatement", ...args);
+}
+
+function ImportDeclaration(...args) {
+  return (0, _builder.default)("ImportDeclaration", ...args);
+}
+
+function ImportDefaultSpecifier(...args) {
+  return (0, _builder.default)("ImportDefaultSpecifier", ...args);
+}
+
+function ImportNamespaceSpecifier(...args) {
+  return (0, _builder.default)("ImportNamespaceSpecifier", ...args);
+}
+
+function ImportSpecifier(...args) {
+  return (0, _builder.default)("ImportSpecifier", ...args);
+}
+
+function MetaProperty(...args) {
+  return (0, _builder.default)("MetaProperty", ...args);
+}
+
+function ClassMethod(...args) {
+  return (0, _builder.default)("ClassMethod", ...args);
+}
+
+function ObjectPattern(...args) {
+  return (0, _builder.default)("ObjectPattern", ...args);
+}
+
+function SpreadElement(...args) {
+  return (0, _builder.default)("SpreadElement", ...args);
+}
+
+function Super(...args) {
+  return (0, _builder.default)("Super", ...args);
+}
+
+function TaggedTemplateExpression(...args) {
+  return (0, _builder.default)("TaggedTemplateExpression", ...args);
+}
+
+function TemplateElement(...args) {
+  return (0, _builder.default)("TemplateElement", ...args);
+}
+
+function TemplateLiteral(...args) {
+  return (0, _builder.default)("TemplateLiteral", ...args);
+}
+
+function YieldExpression(...args) {
+  return (0, _builder.default)("YieldExpression", ...args);
+}
+
+function AnyTypeAnnotation(...args) {
+  return (0, _builder.default)("AnyTypeAnnotation", ...args);
+}
+
+function ArrayTypeAnnotation(...args) {
+  return (0, _builder.default)("ArrayTypeAnnotation", ...args);
+}
+
+function BooleanTypeAnnotation(...args) {
+  return (0, _builder.default)("BooleanTypeAnnotation", ...args);
+}
+
+function BooleanLiteralTypeAnnotation(...args) {
+  return (0, _builder.default)("BooleanLiteralTypeAnnotation", ...args);
+}
+
+function NullLiteralTypeAnnotation(...args) {
+  return (0, _builder.default)("NullLiteralTypeAnnotation", ...args);
+}
+
+function ClassImplements(...args) {
+  return (0, _builder.default)("ClassImplements", ...args);
+}
+
+function DeclareClass(...args) {
+  return (0, _builder.default)("DeclareClass", ...args);
+}
+
+function DeclareFunction(...args) {
+  return (0, _builder.default)("DeclareFunction", ...args);
+}
+
+function DeclareInterface(...args) {
+  return (0, _builder.default)("DeclareInterface", ...args);
+}
+
+function DeclareModule(...args) {
+  return (0, _builder.default)("DeclareModule", ...args);
+}
+
+function DeclareModuleExports(...args) {
+  return (0, _builder.default)("DeclareModuleExports", ...args);
+}
+
+function DeclareTypeAlias(...args) {
+  return (0, _builder.default)("DeclareTypeAlias", ...args);
+}
+
+function DeclareOpaqueType(...args) {
+  return (0, _builder.default)("DeclareOpaqueType", ...args);
+}
+
+function DeclareVariable(...args) {
+  return (0, _builder.default)("DeclareVariable", ...args);
+}
+
+function DeclareExportDeclaration(...args) {
+  return (0, _builder.default)("DeclareExportDeclaration", ...args);
+}
+
+function DeclareExportAllDeclaration(...args) {
+  return (0, _builder.default)("DeclareExportAllDeclaration", ...args);
+}
+
+function DeclaredPredicate(...args) {
+  return (0, _builder.default)("DeclaredPredicate", ...args);
+}
+
+function ExistsTypeAnnotation(...args) {
+  return (0, _builder.default)("ExistsTypeAnnotation", ...args);
+}
+
+function FunctionTypeAnnotation(...args) {
+  return (0, _builder.default)("FunctionTypeAnnotation", ...args);
+}
+
+function FunctionTypeParam(...args) {
+  return (0, _builder.default)("FunctionTypeParam", ...args);
+}
+
+function GenericTypeAnnotation(...args) {
+  return (0, _builder.default)("GenericTypeAnnotation", ...args);
+}
+
+function InferredPredicate(...args) {
+  return (0, _builder.default)("InferredPredicate", ...args);
+}
+
+function InterfaceExtends(...args) {
+  return (0, _builder.default)("InterfaceExtends", ...args);
+}
+
+function InterfaceDeclaration(...args) {
+  return (0, _builder.default)("InterfaceDeclaration", ...args);
+}
+
+function InterfaceTypeAnnotation(...args) {
+  return (0, _builder.default)("InterfaceTypeAnnotation", ...args);
+}
+
+function IntersectionTypeAnnotation(...args) {
+  return (0, _builder.default)("IntersectionTypeAnnotation", ...args);
+}
+
+function MixedTypeAnnotation(...args) {
+  return (0, _builder.default)("MixedTypeAnnotation", ...args);
+}
+
+function EmptyTypeAnnotation(...args) {
+  return (0, _builder.default)("EmptyTypeAnnotation", ...args);
+}
+
+function NullableTypeAnnotation(...args) {
+  return (0, _builder.default)("NullableTypeAnnotation", ...args);
+}
+
+function NumberLiteralTypeAnnotation(...args) {
+  return (0, _builder.default)("NumberLiteralTypeAnnotation", ...args);
+}
+
+function NumberTypeAnnotation(...args) {
+  return (0, _builder.default)("NumberTypeAnnotation", ...args);
+}
+
+function ObjectTypeAnnotation(...args) {
+  return (0, _builder.default)("ObjectTypeAnnotation", ...args);
+}
+
+function ObjectTypeInternalSlot(...args) {
+  return (0, _builder.default)("ObjectTypeInternalSlot", ...args);
+}
+
+function ObjectTypeCallProperty(...args) {
+  return (0, _builder.default)("ObjectTypeCallProperty", ...args);
+}
+
+function ObjectTypeIndexer(...args) {
+  return (0, _builder.default)("ObjectTypeIndexer", ...args);
+}
+
+function ObjectTypeProperty(...args) {
+  return (0, _builder.default)("ObjectTypeProperty", ...args);
+}
+
+function ObjectTypeSpreadProperty(...args) {
+  return (0, _builder.default)("ObjectTypeSpreadProperty", ...args);
+}
+
+function OpaqueType(...args) {
+  return (0, _builder.default)("OpaqueType", ...args);
+}
+
+function QualifiedTypeIdentifier(...args) {
+  return (0, _builder.default)("QualifiedTypeIdentifier", ...args);
+}
+
+function StringLiteralTypeAnnotation(...args) {
+  return (0, _builder.default)("StringLiteralTypeAnnotation", ...args);
+}
+
+function StringTypeAnnotation(...args) {
+  return (0, _builder.default)("StringTypeAnnotation", ...args);
+}
+
+function ThisTypeAnnotation(...args) {
+  return (0, _builder.default)("ThisTypeAnnotation", ...args);
+}
+
+function TupleTypeAnnotation(...args) {
+  return (0, _builder.default)("TupleTypeAnnotation", ...args);
+}
+
+function TypeofTypeAnnotation(...args) {
+  return (0, _builder.default)("TypeofTypeAnnotation", ...args);
+}
+
+function TypeAlias(...args) {
+  return (0, _builder.default)("TypeAlias", ...args);
+}
+
+function TypeAnnotation(...args) {
+  return (0, _builder.default)("TypeAnnotation", ...args);
+}
+
+function TypeCastExpression(...args) {
+  return (0, _builder.default)("TypeCastExpression", ...args);
+}
+
+function TypeParameter(...args) {
+  return (0, _builder.default)("TypeParameter", ...args);
+}
+
+function TypeParameterDeclaration(...args) {
+  return (0, _builder.default)("TypeParameterDeclaration", ...args);
+}
+
+function TypeParameterInstantiation(...args) {
+  return (0, _builder.default)("TypeParameterInstantiation", ...args);
+}
+
+function UnionTypeAnnotation(...args) {
+  return (0, _builder.default)("UnionTypeAnnotation", ...args);
+}
+
+function Variance(...args) {
+  return (0, _builder.default)("Variance", ...args);
+}
+
+function VoidTypeAnnotation(...args) {
+  return (0, _builder.default)("VoidTypeAnnotation", ...args);
+}
+
+function JSXAttribute(...args) {
+  return (0, _builder.default)("JSXAttribute", ...args);
+}
+
+function JSXClosingElement(...args) {
+  return (0, _builder.default)("JSXClosingElement", ...args);
+}
+
+function JSXElement(...args) {
+  return (0, _builder.default)("JSXElement", ...args);
+}
+
+function JSXEmptyExpression(...args) {
+  return (0, _builder.default)("JSXEmptyExpression", ...args);
+}
+
+function JSXExpressionContainer(...args) {
+  return (0, _builder.default)("JSXExpressionContainer", ...args);
+}
+
+function JSXSpreadChild(...args) {
+  return (0, _builder.default)("JSXSpreadChild", ...args);
+}
+
+function JSXIdentifier(...args) {
+  return (0, _builder.default)("JSXIdentifier", ...args);
+}
+
+function JSXMemberExpression(...args) {
+  return (0, _builder.default)("JSXMemberExpression", ...args);
+}
+
+function JSXNamespacedName(...args) {
+  return (0, _builder.default)("JSXNamespacedName", ...args);
+}
+
+function JSXOpeningElement(...args) {
+  return (0, _builder.default)("JSXOpeningElement", ...args);
+}
+
+function JSXSpreadAttribute(...args) {
+  return (0, _builder.default)("JSXSpreadAttribute", ...args);
+}
+
+function JSXText(...args) {
+  return (0, _builder.default)("JSXText", ...args);
+}
+
+function JSXFragment(...args) {
+  return (0, _builder.default)("JSXFragment", ...args);
+}
+
+function JSXOpeningFragment(...args) {
+  return (0, _builder.default)("JSXOpeningFragment", ...args);
+}
+
+function JSXClosingFragment(...args) {
+  return (0, _builder.default)("JSXClosingFragment", ...args);
+}
+
+function Noop(...args) {
+  return (0, _builder.default)("Noop", ...args);
+}
+
+function ParenthesizedExpression(...args) {
+  return (0, _builder.default)("ParenthesizedExpression", ...args);
+}
+
+function AwaitExpression(...args) {
+  return (0, _builder.default)("AwaitExpression", ...args);
+}
+
+function BindExpression(...args) {
+  return (0, _builder.default)("BindExpression", ...args);
+}
+
+function ClassProperty(...args) {
+  return (0, _builder.default)("ClassProperty", ...args);
+}
+
+function OptionalMemberExpression(...args) {
+  return (0, _builder.default)("OptionalMemberExpression", ...args);
+}
+
+function OptionalCallExpression(...args) {
+  return (0, _builder.default)("OptionalCallExpression", ...args);
+}
+
+function ClassPrivateProperty(...args) {
+  return (0, _builder.default)("ClassPrivateProperty", ...args);
+}
+
+function Import(...args) {
+  return (0, _builder.default)("Import", ...args);
+}
+
+function Decorator(...args) {
+  return (0, _builder.default)("Decorator", ...args);
+}
+
+function DoExpression(...args) {
+  return (0, _builder.default)("DoExpression", ...args);
+}
+
+function ExportDefaultSpecifier(...args) {
+  return (0, _builder.default)("ExportDefaultSpecifier", ...args);
+}
+
+function ExportNamespaceSpecifier(...args) {
+  return (0, _builder.default)("ExportNamespaceSpecifier", ...args);
+}
+
+function PrivateName(...args) {
+  return (0, _builder.default)("PrivateName", ...args);
+}
+
+function BigIntLiteral(...args) {
+  return (0, _builder.default)("BigIntLiteral", ...args);
+}
+
+function TSParameterProperty(...args) {
+  return (0, _builder.default)("TSParameterProperty", ...args);
+}
+
+function TSDeclareFunction(...args) {
+  return (0, _builder.default)("TSDeclareFunction", ...args);
+}
+
+function TSDeclareMethod(...args) {
+  return (0, _builder.default)("TSDeclareMethod", ...args);
+}
+
+function TSQualifiedName(...args) {
+  return (0, _builder.default)("TSQualifiedName", ...args);
+}
+
+function TSCallSignatureDeclaration(...args) {
+  return (0, _builder.default)("TSCallSignatureDeclaration", ...args);
+}
+
+function TSConstructSignatureDeclaration(...args) {
+  return (0, _builder.default)("TSConstructSignatureDeclaration", ...args);
+}
+
+function TSPropertySignature(...args) {
+  return (0, _builder.default)("TSPropertySignature", ...args);
+}
+
+function TSMethodSignature(...args) {
+  return (0, _builder.default)("TSMethodSignature", ...args);
+}
+
+function TSIndexSignature(...args) {
+  return (0, _builder.default)("TSIndexSignature", ...args);
+}
+
+function TSAnyKeyword(...args) {
+  return (0, _builder.default)("TSAnyKeyword", ...args);
+}
+
+function TSNumberKeyword(...args) {
+  return (0, _builder.default)("TSNumberKeyword", ...args);
+}
+
+function TSObjectKeyword(...args) {
+  return (0, _builder.default)("TSObjectKeyword", ...args);
+}
+
+function TSBooleanKeyword(...args) {
+  return (0, _builder.default)("TSBooleanKeyword", ...args);
+}
+
+function TSStringKeyword(...args) {
+  return (0, _builder.default)("TSStringKeyword", ...args);
+}
+
+function TSSymbolKeyword(...args) {
+  return (0, _builder.default)("TSSymbolKeyword", ...args);
+}
+
+function TSVoidKeyword(...args) {
+  return (0, _builder.default)("TSVoidKeyword", ...args);
+}
+
+function TSUndefinedKeyword(...args) {
+  return (0, _builder.default)("TSUndefinedKeyword", ...args);
+}
+
+function TSNullKeyword(...args) {
+  return (0, _builder.default)("TSNullKeyword", ...args);
+}
+
+function TSNeverKeyword(...args) {
+  return (0, _builder.default)("TSNeverKeyword", ...args);
+}
+
+function TSThisType(...args) {
+  return (0, _builder.default)("TSThisType", ...args);
+}
+
+function TSFunctionType(...args) {
+  return (0, _builder.default)("TSFunctionType", ...args);
+}
+
+function TSConstructorType(...args) {
+  return (0, _builder.default)("TSConstructorType", ...args);
+}
+
+function TSTypeReference(...args) {
+  return (0, _builder.default)("TSTypeReference", ...args);
+}
+
+function TSTypePredicate(...args) {
+  return (0, _builder.default)("TSTypePredicate", ...args);
+}
+
+function TSTypeQuery(...args) {
+  return (0, _builder.default)("TSTypeQuery", ...args);
+}
+
+function TSTypeLiteral(...args) {
+  return (0, _builder.default)("TSTypeLiteral", ...args);
+}
+
+function TSArrayType(...args) {
+  return (0, _builder.default)("TSArrayType", ...args);
+}
+
+function TSTupleType(...args) {
+  return (0, _builder.default)("TSTupleType", ...args);
+}
+
+function TSUnionType(...args) {
+  return (0, _builder.default)("TSUnionType", ...args);
+}
+
+function TSIntersectionType(...args) {
+  return (0, _builder.default)("TSIntersectionType", ...args);
+}
+
+function TSConditionalType(...args) {
+  return (0, _builder.default)("TSConditionalType", ...args);
+}
+
+function TSInferType(...args) {
+  return (0, _builder.default)("TSInferType", ...args);
+}
+
+function TSParenthesizedType(...args) {
+  return (0, _builder.default)("TSParenthesizedType", ...args);
+}
+
+function TSTypeOperator(...args) {
+  return (0, _builder.default)("TSTypeOperator", ...args);
+}
+
+function TSIndexedAccessType(...args) {
+  return (0, _builder.default)("TSIndexedAccessType", ...args);
+}
+
+function TSMappedType(...args) {
+  return (0, _builder.default)("TSMappedType", ...args);
+}
+
+function TSLiteralType(...args) {
+  return (0, _builder.default)("TSLiteralType", ...args);
+}
+
+function TSExpressionWithTypeArguments(...args) {
+  return (0, _builder.default)("TSExpressionWithTypeArguments", ...args);
+}
+
+function TSInterfaceDeclaration(...args) {
+  return (0, _builder.default)("TSInterfaceDeclaration", ...args);
+}
+
+function TSInterfaceBody(...args) {
+  return (0, _builder.default)("TSInterfaceBody", ...args);
+}
+
+function TSTypeAliasDeclaration(...args) {
+  return (0, _builder.default)("TSTypeAliasDeclaration", ...args);
+}
+
+function TSAsExpression(...args) {
+  return (0, _builder.default)("TSAsExpression", ...args);
+}
+
+function TSTypeAssertion(...args) {
+  return (0, _builder.default)("TSTypeAssertion", ...args);
+}
+
+function TSEnumDeclaration(...args) {
+  return (0, _builder.default)("TSEnumDeclaration", ...args);
+}
+
+function TSEnumMember(...args) {
+  return (0, _builder.default)("TSEnumMember", ...args);
+}
+
+function TSModuleDeclaration(...args) {
+  return (0, _builder.default)("TSModuleDeclaration", ...args);
+}
+
+function TSModuleBlock(...args) {
+  return (0, _builder.default)("TSModuleBlock", ...args);
+}
+
+function TSImportEqualsDeclaration(...args) {
+  return (0, _builder.default)("TSImportEqualsDeclaration", ...args);
+}
+
+function TSExternalModuleReference(...args) {
+  return (0, _builder.default)("TSExternalModuleReference", ...args);
+}
+
+function TSNonNullExpression(...args) {
+  return (0, _builder.default)("TSNonNullExpression", ...args);
+}
+
+function TSExportAssignment(...args) {
+  return (0, _builder.default)("TSExportAssignment", ...args);
+}
+
+function TSNamespaceExportDeclaration(...args) {
+  return (0, _builder.default)("TSNamespaceExportDeclaration", ...args);
+}
+
+function TSTypeAnnotation(...args) {
+  return (0, _builder.default)("TSTypeAnnotation", ...args);
+}
+
+function TSTypeParameterInstantiation(...args) {
+  return (0, _builder.default)("TSTypeParameterInstantiation", ...args);
+}
+
+function TSTypeParameterDeclaration(...args) {
+  return (0, _builder.default)("TSTypeParameterDeclaration", ...args);
+}
+
+function TSTypeParameter(...args) {
+  return (0, _builder.default)("TSTypeParameter", ...args);
+}
+
+function NumberLiteral(...args) {
   console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
-
-  for (var _len210 = arguments.length, args = new Array(_len210), _key210 = 0; _key210 < _len210; _key210++) {
-    args[_key210] = arguments[_key210];
-  }
-
-  return NumberLiteral.apply(void 0, ["NumberLiteral"].concat(args));
-}
-
-function RegexLiteral() {
+  return NumberLiteral("NumberLiteral", ...args);
+}
+
+function RegexLiteral(...args) {
   console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
-
-  for (var _len211 = arguments.length, args = new Array(_len211), _key211 = 0; _key211 < _len211; _key211++) {
-    args[_key211] = arguments[_key211];
-  }
-
-  return RegexLiteral.apply(void 0, ["RegexLiteral"].concat(args));
-}
-
-function RestProperty() {
+  return RegexLiteral("RegexLiteral", ...args);
+}
+
+function RestProperty(...args) {
   console.trace("The node type RestProperty has been renamed to RestElement");
-
-  for (var _len212 = arguments.length, args = new Array(_len212), _key212 = 0; _key212 < _len212; _key212++) {
-    args[_key212] = arguments[_key212];
-  }
-
-  return RestProperty.apply(void 0, ["RestProperty"].concat(args));
-}
-
-function SpreadProperty() {
+  return RestProperty("RestProperty", ...args);
+}
+
+function SpreadProperty(...args) {
   console.trace("The node type SpreadProperty has been renamed to SpreadElement");
-
-  for (var _len213 = arguments.length, args = new Array(_len213), _key213 = 0; _key213 < _len213; _key213++) {
-    args[_key213] = arguments[_key213];
-  }
-
-  return SpreadProperty.apply(void 0, ["SpreadProperty"].concat(args));
+  return SpreadProperty("SpreadProperty", ...args);
 }
 
 /***/ }),
 
 /***/ 2257:
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "VISITOR_KEYS", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utils.VISITOR_KEYS;
   }
 });
 Object.defineProperty(exports, "ALIAS_KEYS", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utils.ALIAS_KEYS;
   }
 });
 Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utils.FLIPPED_ALIAS_KEYS;
   }
 });
 Object.defineProperty(exports, "NODE_FIELDS", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utils.NODE_FIELDS;
   }
 });
 Object.defineProperty(exports, "BUILDER_KEYS", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utils.BUILDER_KEYS;
   }
 });
 Object.defineProperty(exports, "DEPRECATED_KEYS", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utils.DEPRECATED_KEYS;
   }
 });
 exports.TYPES = void 0;
 
 function _toFastProperties() {
-  var data = _interopRequireDefault(__webpack_require__(541));
-
-  _toFastProperties = function _toFastProperties() {
+  const data = _interopRequireDefault(__webpack_require__(541));
+
+  _toFastProperties = function () {
     return data;
   };
 
   return data;
 }
 
 __webpack_require__(2265);
 
@@ -9241,17 +8469,17 @@ var _utils = __webpack_require__(2258);
 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));
+const TYPES = Object.keys(_utils.VISITOR_KEYS).concat(Object.keys(_utils.FLIPPED_ALIAS_KEYS)).concat(Object.keys(_utils.DEPRECATED_KEYS));
 exports.TYPES = TYPES;
 
 /***/ }),
 
 /***/ 2258:
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -9276,58 +8504,58 @@ exports.assertValueType = assertValueTyp
 exports.chain = chain;
 exports.default = defineType;
 exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = void 0;
 
 var _is = _interopRequireDefault(__webpack_require__(2262));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-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;
 
 function getType(val) {
   if (Array.isArray(val)) {
     return "array";
   } else if (val === null) {
     return "null";
   } else if (val === undefined) {
     return "undefined";
   } else {
     return typeof val;
   }
 }
 
 function validate(validate) {
   return {
-    validate: validate
+    validate
   };
 }
 
 function typeIs(typeName) {
-  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType.apply(void 0, typeName);
+  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
 }
 
 function validateType(typeName) {
   return validate(typeIs(typeName));
 }
 
 function validateOptional(validate) {
   return {
-    validate: validate,
+    validate,
     optional: true
   };
 }
 
 function validateOptionalType(typeName) {
   return {
     validate: typeIs(typeName),
     optional: true
@@ -9345,241 +8573,213 @@ function arrayOfType(typeName) {
 function validateArrayOfType(typeName) {
   return validate(arrayOfType(typeName));
 }
 
 function assertEach(callback) {
   function validator(node, key, val) {
     if (!Array.isArray(val)) return;
 
-    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]);
     }
   }
 
   validator.each = callback;
   return validator;
 }
 
-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)}`);
     }
   }
 
   validate.oneOf = values;
   return validate;
 }
 
-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;
-
-    for (var _i = 0; _i < types.length; _i++) {
-      var type = types[_i];
-
+    let valid = false;
+
+    for (const type of types) {
       if ((0, _is.default)(type, val)) {
         valid = true;
         break;
       }
     }
 
     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)}`);
     }
   }
 
   validate.oneOfNodeTypes = types;
   return validate;
 }
 
-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;
-
-    for (var _i2 = 0; _i2 < types.length; _i2++) {
-      var type = types[_i2];
-
+    let valid = false;
+
+    for (const type of types) {
       if (getType(val) === type || (0, _is.default)(type, val)) {
         valid = true;
         break;
       }
     }
 
     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)}`);
     }
   }
 
   validate.oneOfNodeOrValueTypes = types;
   return validate;
 }
 
 function assertValueType(type) {
   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)}`);
     }
   }
 
   validate.type = type;
   return validate;
 }
 
-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);
     }
   }
 
   validate.chainOf = fns;
   return validate;
 }
 
-function defineType(type, opts) {
-  if (opts === void 0) {
-    opts = {};
-  }
-
-  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 || [];
+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 || [];
 
   if (opts.deprecatedAlias) {
     DEPRECATED_KEYS[opts.deprecatedAlias] = type;
   }
 
-  var _arr = visitor.concat(builder);
-
-  for (var _i4 = 0; _i4 < _arr.length; _i4++) {
-    var _key5 = _arr[_i4];
-    fields[_key5] = fields[_key5] || {};
-  }
-
-  for (var key in fields) {
-    var field = fields[key];
+  for (const key of visitor.concat(builder)) {
+    fields[key] = fields[key] || {};
+  }
+
+  for (const key in fields) {
+    const field = fields[key];
 
     if (builder.indexOf(key) === -1) {
       field.optional = true;
     }
 
     if (field.default === undefined) {
       field.default = null;
     } else if (!field.validate) {
       field.validate = assertValueType(getType(field.default));
     }
   }
 
   VISITOR_KEYS[type] = opts.visitor = visitor;
   BUILDER_KEYS[type] = opts.builder = builder;
   NODE_FIELDS[type] = opts.fields = fields;
   ALIAS_KEYS[type] = opts.aliases = aliases;
-  aliases.forEach(function (alias) {
+  aliases.forEach(alias => {
     FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
     FLIPPED_ALIAS_KEYS[alias].push(type);
   });
   store[type] = opts;
 }
 
-var store = {};
+const store = {};
 
 /***/ }),
 
 /***/ 2259:
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 
 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"],
   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;
 
 /***/ }),
 
 /***/ 2260:
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = isValidIdentifier;
 
 function _esutils() {
-  var data = _interopRequireDefault(__webpack_require__(530));
-
-  _esutils = function _esutils() {
+  const data = _interopRequireDefault(__webpack_require__(530));
+
+  _esutils = function () {
     return data;
   };
 
   return data;
 }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -9603,57 +8803,49 @@ function isValidIdentifier(name) {
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = cloneNode;
 
 var _definitions = __webpack_require__(2257);
 
-var has = Function.call.bind(Object.prototype.hasOwnProperty);
+const has = Function.call.bind(Object.prototype.hasOwnProperty);
 
 function cloneIfNode(obj, deep) {
   if (obj && typeof obj.type === "string" && obj.type !== "CommentLine" && obj.type !== "CommentBlock") {
     return cloneNode(obj, deep);
   }
 
   return obj;
 }
 
 function cloneIfNodeOrArray(obj, deep) {
   if (Array.isArray(obj)) {
-    return obj.map(function (node) {
-      return cloneIfNode(node, deep);
-    });
+    return obj.map(node => cloneIfNode(node, deep));
   }
 
   return cloneIfNode(obj, deep);
 }
 
-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
   };
 
   if (type === "Identifier") {
     newNode.name = node.name;
   } else if (!has(_definitions.NODE_FIELDS, 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];
-
+    throw new Error(`Unknown node type: "${type}"`);
+  } else {
+    for (const field of Object.keys(_definitions.NODE_FIELDS[type])) {
       if (has(node, field)) {
         newNode[field] = deep ? cloneIfNodeOrArray(node[field], true) : node[field];
       }
     }
   }
 
   if (has(node, "loc")) {
     newNode.loc = node.loc;
@@ -9694,17 +8886,17 @@ exports.default = is;
 var _shallowEqual = _interopRequireDefault(__webpack_require__(2271));
 
 var _isType = _interopRequireDefault(__webpack_require__(2264));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function is(type, node, opts) {
   if (!node) return false;
-  var matches = (0, _isType.default)(node.type, type);
+  const matches = (0, _isType.default)(node.type, type);
   if (!matches) return false;
 
   if (typeof opts === "undefined") {
     return true;
   } else {
     return (0, _shallowEqual.default)(node, opts);
   }
 }
@@ -9720,27 +8912,27 @@ function is(type, node, opts) {
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = getBindingIdentifiers;
 
 var _generated = __webpack_require__(2255);
 
 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] || [];
 
         _ids.push(id);
       } else {
         ids[id.name] = id;
       }
 
       continue;
     }
@@ -9760,34 +8952,37 @@ function getBindingIdentifiers(node, dup
       }
 
       if ((0, _generated.isFunctionExpression)(id)) {
         continue;
       }
     }
 
     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];
 
         if (id[key]) {
           search = search.concat(id[key]);
         }
       }
     }
   }
 
   return ids;
 }
 
 getBindingIdentifiers.keys = {
   DeclareClass: ["id"],
   DeclareFunction: ["id"],
   DeclareModule: ["id"],
   DeclareVariable: ["id"],
+  DeclareInterface: ["id"],
+  DeclareTypeAlias: ["id"],
+  DeclareOpaqueType: ["id"],
   InterfaceDeclaration: ["id"],
   TypeAlias: ["id"],
   OpaqueType: ["id"],
   CatchClause: ["param"],
   LabeledStatement: ["label"],
   UnaryExpression: ["argument"],
   AssignmentExpression: ["left"],
   ImportSpecifier: ["local"],
@@ -9829,34 +9024,22 @@ Object.defineProperty(exports, "__esModu
 });
 exports.default = isType;
 
 var _definitions = __webpack_require__(2257);
 
 function isType(nodeType, targetType) {
   if (nodeType === targetType) return true;
   if (_definitions.ALIAS_KEYS[targetType]) return false;
-  var aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType];
+  const aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType];
 
   if (aliases) {
     if (aliases[0] === nodeType) return true;
 
-    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;
+    for (const alias of aliases) {
       if (nodeType === alias) return true;
     }
   }
 
   return false;
 }
 
 /***/ }),
@@ -9877,20 +9060,16 @@ var _isValidIdentifier = _interopRequire
 var _constants = __webpack_require__(2259);
 
 var _utils = _interopRequireWildcard(__webpack_require__(2258));
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 (0, _utils.default)("ArrayExpression", {
   fields: {
     elements: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
       default: []
     }
   },
   visitor: ["elements"],
@@ -9911,28 +9090,36 @@ function _defineProperty(obj, key, value
   builder: ["operator", "left", "right"],
   visitor: ["left", "right"],
   aliases: ["Expression"]
 });
 (0, _utils.default)("BinaryExpression", {
   builder: ["operator", "left", "right"],
   fields: {
     operator: {
-      validate: _utils.assertOneOf.apply(void 0, _constants.BINARY_OPERATORS)
+      validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS)
     },
     left: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
     right: {
       validate: (0, _utils.assertNodeType)("Expression")
     }
   },
   visitor: ["left", "right"],
   aliases: ["Binary", "Expression"]
 });
+(0, _utils.default)("InterpreterDirective", {
+  builder: ["value"],
+  fields: {
+    value: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  }
+});
 (0, _utils.default)("Directive", {
   visitor: ["value"],
   fields: {
     value: {
       validate: (0, _utils.assertNodeType)("DirectiveLiteral")
     }
   }
 });
@@ -9964,32 +9151,36 @@ function _defineProperty(obj, key, value
     label: {
       validate: (0, _utils.assertNodeType)("Identifier"),
       optional: true
     }
   },
   aliases: ["Statement", "Terminatorless", "CompletionStatement"]
 });
 (0, _utils.default)("CallExpression", {
-  visitor: ["callee", "arguments", "typeParameters"],
+  visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
   builder: ["callee", "arguments"],
   aliases: ["Expression"],
   fields: {
     callee: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
     arguments: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName")))
     },
     optional: {
       validate: (0, _utils.assertOneOf)(true, false),
       optional: true
     },
+    typeArguments: {
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
+      optional: true
+    },
     typeParameters: {
-      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
       optional: true
     }
   }
 });
 (0, _utils.default)("CatchClause", {
   visitor: ["param", "body"],
   fields: {
     param: {
@@ -10094,92 +9285,90 @@ function _defineProperty(obj, key, value
       validate: (0, _utils.assertNodeType)("Expression"),
       optional: true
     },
     body: {
       validate: (0, _utils.assertNodeType)("Statement")
     }
   }
 });
-var functionCommon = {
+const functionCommon = {
   params: {
     validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("LVal")))
   },
   generator: {
     default: false,
     validate: (0, _utils.assertValueType)("boolean")
   },
   async: {
     validate: (0, _utils.assertValueType)("boolean"),
     default: false
   }
 };
 exports.functionCommon = functionCommon;
-var functionTypeAnnotationCommon = {
+const functionTypeAnnotationCommon = {
   returnType: {
     validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
     optional: true
   },
   typeParameters: {
     validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
     optional: true
   }
 };
 exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon;
-
-var functionDeclarationCommon = _objectSpread({}, functionCommon, {
+const functionDeclarationCommon = Object.assign({}, functionCommon, {
   declare: {
     validate: (0, _utils.assertValueType)("boolean"),
     optional: true
   },
   id: {
     validate: (0, _utils.assertNodeType)("Identifier"),
     optional: true
   }
 });
-
 exports.functionDeclarationCommon = functionDeclarationCommon;
 (0, _utils.default)("FunctionDeclaration", {
   builder: ["id", "params", "body", "generator", "async"],
   visitor: ["id", "params", "body", "returnType", "typeParameters"],
-  fields: _objectSpread({}, functionDeclarationCommon, functionTypeAnnotationCommon, {
+  fields: Object.assign({}, functionDeclarationCommon, functionTypeAnnotationCommon, {
     body: {
       validate: (0, _utils.assertNodeType)("BlockStatement")
     }
   }),
   aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"]
 });
 (0, _utils.default)("FunctionExpression", {
   inherits: "FunctionDeclaration",
   aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
-  fields: _objectSpread({}, functionCommon, functionTypeAnnotationCommon, {
+  fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
     id: {
       validate: (0, _utils.assertNodeType)("Identifier"),
       optional: true
     },
     body: {
       validate: (0, _utils.assertNodeType)("BlockStatement")
     }
   })
 });
-var patternLikeCommon = {
+const patternLikeCommon = {
   typeAnnotation: {
     validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
     optional: true
   },
   decorators: {
     validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
   }
 };
 exports.patternLikeCommon = patternLikeCommon;
 (0, _utils.default)("Identifier", {
   builder: ["name"],
   visitor: ["typeAnnotation"],
   aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
-  fields: _objectSpread({}, patternLikeCommon, {
+  fields: Object.assign({}, patternLikeCommon, {
     name: {
       validate: (0, _utils.chain)(function (node, key, val) {
         if (!(0, _isValidIdentifier.default)(val)) {}
       }, (0, _utils.assertValueType)("string"))
     },
     optional: {
       validate: (0, _utils.assertValueType)("boolean"),
       optional: true
@@ -10260,17 +9449,17 @@ exports.patternLikeCommon = patternLikeC
   }
 });
 (0, _utils.default)("LogicalExpression", {
   builder: ["operator", "left", "right"],
   visitor: ["left", "right"],
   aliases: ["Binary", "Expression"],
   fields: {
     operator: {
-      validate: _utils.assertOneOf.apply(void 0, _constants.LOGICAL_OPERATORS)
+      validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS)
     },
     left: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
     right: {
       validate: (0, _utils.assertNodeType)("Expression")
     }
   }
@@ -10280,20 +9469,20 @@ exports.patternLikeCommon = patternLikeC
   visitor: ["object", "property"],
   aliases: ["Expression", "LVal"],
   fields: {
     object: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
     property: {
       validate: function () {
-        var normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
-        var computed = (0, _utils.assertNodeType)("Expression");
+        const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
+        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);
         };
       }()
     },
     computed: {
       default: false
     },
     optional: {
@@ -10302,25 +9491,30 @@ exports.patternLikeCommon = patternLikeC
     }
   }
 });
 (0, _utils.default)("NewExpression", {
   inherits: "CallExpression"
 });
 (0, _utils.default)("Program", {
   visitor: ["directives", "body"],
-  builder: ["body", "directives", "sourceType"],
+  builder: ["body", "directives", "sourceType", "interpreter"],
   fields: {
     sourceFile: {
       validate: (0, _utils.assertValueType)("string")
     },
     sourceType: {
       validate: (0, _utils.assertOneOf)("script", "module"),
       default: "script"
     },
+    interpreter: {
+      validate: (0, _utils.assertNodeType)("InterpreterDirective"),
+      default: null,
+      optional: true
+    },
     directives: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
       default: []
     },
     body: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
     }
   },
@@ -10332,31 +9526,31 @@ exports.patternLikeCommon = patternLikeC
   fields: {
     properties: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
     }
   }
 });
 (0, _utils.default)("ObjectMethod", {
   builder: ["kind", "key", "params", "body", "computed"],
-  fields: _objectSpread({}, functionCommon, functionTypeAnnotationCommon, {
+  fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
     kind: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("method", "get", "set")),
       default: "method"
     },
     computed: {
       validate: (0, _utils.assertValueType)("boolean"),
       default: false
     },
     key: {
       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);
         };
       }()
     },
     decorators: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
     },
     body: {
@@ -10370,20 +9564,20 @@ exports.patternLikeCommon = patternLikeC
   builder: ["key", "value", "computed", "shorthand", "decorators"],
   fields: {
     computed: {
       validate: (0, _utils.assertValueType)("boolean"),
       default: false
     },
     key: {
       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);
         };
       }()
     },
     value: {
       validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
     },
     shorthand: {
@@ -10398,17 +9592,17 @@ exports.patternLikeCommon = patternLikeC
   visitor: ["key", "value", "decorators"],
   aliases: ["UserWhitespacable", "Property", "ObjectMember"]
 });
 (0, _utils.default)("RestElement", {
   visitor: ["argument", "typeAnnotation"],
   builder: ["argument"],
   aliases: ["LVal", "PatternLike"],
   deprecatedAlias: "RestProperty",
-  fields: _objectSpread({}, patternLikeCommon, {
+  fields: Object.assign({}, patternLikeCommon, {
     argument: {
       validate: (0, _utils.assertNodeType)("LVal")
     }
   })
 });
 (0, _utils.default)("ReturnStatement", {
   visitor: ["argument"],
   aliases: ["Statement", "Terminatorless", "CompletionStatement"],
@@ -10486,33 +9680,33 @@ exports.patternLikeCommon = patternLikeC
   fields: {
     prefix: {
       default: true
     },
     argument: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
     operator: {
-      validate: _utils.assertOneOf.apply(void 0, _constants.UNARY_OPERATORS)
+      validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS)
     }
   },
   visitor: ["argument"],
   aliases: ["UnaryLike", "Expression"]
 });
 (0, _utils.default)("UpdateExpression", {
   builder: ["operator", "argument", "prefix"],
   fields: {
     prefix: {
       default: false
     },
     argument: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
     operator: {
-      validate: _utils.assertOneOf.apply(void 0, _constants.UPDATE_OPERATORS)
+      validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
     }
   },
   visitor: ["argument"],
   aliases: ["Expression"]
 });
 (0, _utils.default)("VariableDeclaration", {
   builder: ["kind", "declarations"],
   visitor: ["declarations"],
@@ -10585,71 +9779,67 @@ Object.defineProperty(exports, "__esModu
 exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = void 0;
 
 var _utils = _interopRequireWildcard(__webpack_require__(2258));
 
 var _core = __webpack_require__(2265);
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 (0, _utils.default)("AssignmentPattern", {
   visitor: ["left", "right"],
   builder: ["left", "right"],
   aliases: ["Pattern", "PatternLike", "LVal"],
-  fields: _objectSpread({}, _core.patternLikeCommon, {
+  fields: Object.assign({}, _core.patternLikeCommon, {
     left: {
       validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern")
     },
     right: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
     decorators: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
     }
   })
 });
 (0, _utils.default)("ArrayPattern", {
   visitor: ["elements", "typeAnnotation"],
   builder: ["elements"],
   aliases: ["Pattern", "PatternLike", "LVal"],
-  fields: _objectSpread({}, _core.patternLikeCommon, {
+  fields: Object.assign({}, _core.patternLikeCommon, {
     elements: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("PatternLike")))
     },
     decorators: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
     }
   })
 });
 (0, _utils.default)("ArrowFunctionExpression", {
   builder: ["params", "body", "async"],
   visitor: ["params", "body", "returnType", "typeParameters"],
   aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
-  fields: _objectSpread({}, _core.functionCommon, _core.functionTypeAnnotationCommon, {
+  fields: Object.assign({}, _core.functionCommon, _core.functionTypeAnnotationCommon, {
     expression: {
       validate: (0, _utils.assertValueType)("boolean")
     },
     body: {
       validate: (0, _utils.assertNodeType)("BlockStatement", "Expression")
     }
   })
 });
 (0, _utils.default)("ClassBody", {
   visitor: ["body"],
   fields: {
     body: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassProperty", "ClassPrivateProperty", "TSDeclareMethod", "TSIndexSignature")))
     }
   }
 });
-var classCommon = {
+const classCommon = {
   typeParameters: {
     validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
     optional: true
   },
   body: {
     validate: (0, _utils.assertNodeType)("ClassBody")
   },
   superClass: {
@@ -10664,17 +9854,17 @@ var classCommon = {
     validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
     optional: true
   }
 };
 (0, _utils.default)("ClassDeclaration", {
   builder: ["id", "superClass", "body", "decorators"],
   visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
   aliases: ["Scopable", "Class", "Statement", "Declaration", "Pureish"],
-  fields: _objectSpread({}, classCommon, {
+  fields: Object.assign({}, classCommon, {
     declare: {
       validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
     abstract: {
       validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
@@ -10686,17 +9876,17 @@ var classCommon = {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
     }
   })
 });
 (0, _utils.default)("ClassExpression", {
   inherits: "ClassDeclaration",
   aliases: ["Scopable", "Class", "Expression", "Pureish"],
-  fields: _objectSpread({}, classCommon, {
+  fields: Object.assign({}, classCommon, {
     id: {
       optional: true,
       validate: (0, _utils.assertNodeType)("Identifier")
     },
     body: {
       validate: (0, _utils.assertNodeType)("ClassBody")
     },
     superClass: {
@@ -10827,17 +10017,17 @@ var classCommon = {
     meta: {
       validate: (0, _utils.assertNodeType)("Identifier")
     },
     property: {
       validate: (0, _utils.assertNodeType)("Identifier")
     }
   }
 });
-var classMethodOrPropertyCommon = {
+const classMethodOrPropertyCommon = {
   abstract: {
     validate: (0, _utils.assertValueType)("boolean"),
     optional: true
   },
   accessibility: {
     validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
     optional: true
   },
@@ -10850,58 +10040,56 @@ var classMethodOrPropertyCommon = {
     validate: (0, _utils.assertValueType)("boolean")
   },
   optional: {
     validate: (0, _utils.assertValueType)("boolean"),
     optional: true
   },
   key: {
     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);
       };
     }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression"))
   }
 };
 exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
-
-var classMethodOrDeclareMethodCommon = _objectSpread({}, _core.functionCommon, classMethodOrPropertyCommon, {
+const classMethodOrDeclareMethodCommon = Object.assign({}, _core.functionCommon, classMethodOrPropertyCommon, {
   kind: {
     validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("get", "set", "method", "constructor")),
     default: "method"
   },
   access: {
     validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
     optional: true
   },
   decorators: {
     validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
     optional: true
   }
 });
-
 exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
 (0, _utils.default)("ClassMethod", {
   aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
   builder: ["kind", "key", "params", "body", "computed", "static"],
   visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
-  fields: _objectSpread({}, classMethodOrDeclareMethodCommon, _core.functionTypeAnnotationCommon, {
+  fields: Object.assign({}, classMethodOrDeclareMethodCommon, _core.functionTypeAnnotationCommon, {
     body: {
       validate: (0, _utils.assertNodeType)("BlockStatement")
     }
   })
 });
 (0, _utils.default)("ObjectPattern", {
   visitor: ["properties", "typeAnnotation"],
   builder: ["properties"],
   aliases: ["Pattern", "PatternLike", "LVal"],
-  fields: _objectSpread({}, _core.patternLikeCommon, {
+  fields: Object.assign({}, _core.patternLikeCommon, {
     properties: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
     }
   })
 });
 (0, _utils.default)("SpreadElement", {
   visitor: ["argument"],
   aliases: ["UnaryLike"],
@@ -10919,16 +10107,20 @@ exports.classMethodOrDeclareMethodCommon
   visitor: ["tag", "quasi"],
   aliases: ["Expression"],
   fields: {
     tag: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
     quasi: {
       validate: (0, _utils.assertNodeType)("TemplateLiteral")
+    },
+    typeParameters: {
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      optional: true
     }
   }
 });
 (0, _utils.default)("TemplateElement", {
   builder: ["value", "tail"],
   fields: {
     value: {},
     tail: {
@@ -10974,19 +10166,19 @@ exports.classMethodOrDeclareMethodCommon
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = inherit;
 
 function _uniq() {
-  var data = _interopRequireDefault(__webpack_require__(561));
-
-  _uniq = function _uniq() {
+  const data = _interopRequireDefault(__webpack_require__(561));
+
+  _uniq = function () {
     return data;
   };
 
   return data;
 }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -11059,323 +10251,323 @@ var _exportNames = {
   isValidIdentifier: true,
   isVar: true,
   matchesPattern: true,
   validate: true,
   buildMatchMemberExpression: true
 };
 Object.defineProperty(exports, "assertNode", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _assertNode.default;
   }
 });
 Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _createTypeAnnotationBasedOnTypeof.default;
   }
 });
 Object.defineProperty(exports, "createUnionTypeAnnotation", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _createUnionTypeAnnotation.default;
   }
 });
 Object.defineProperty(exports, "cloneNode", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _cloneNode.default;
   }
 });
 Object.defineProperty(exports, "clone", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _clone.default;
   }
 });
 Object.defineProperty(exports, "cloneDeep", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _cloneDeep.default;
   }
 });
 Object.defineProperty(exports, "cloneWithoutLoc", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _cloneWithoutLoc.default;
   }
 });
 Object.defineProperty(exports, "addComment", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _addComment.default;
   }
 });
 Object.defineProperty(exports, "addComments", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _addComments.default;
   }
 });
 Object.defineProperty(exports, "inheritInnerComments", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _inheritInnerComments.default;
   }
 });
 Object.defineProperty(exports, "inheritLeadingComments", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _inheritLeadingComments.default;
   }
 });
 Object.defineProperty(exports, "inheritsComments", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _inheritsComments.default;
   }
 });
 Object.defineProperty(exports, "inheritTrailingComments", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _inheritTrailingComments.default;
   }
 });
 Object.defineProperty(exports, "removeComments", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _removeComments.default;
   }
 });
 Object.defineProperty(exports, "ensureBlock", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _ensureBlock.default;
   }
 });
 Object.defineProperty(exports, "toBindingIdentifierName", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _toBindingIdentifierName.default;
   }
 });
 Object.defineProperty(exports, "toBlock", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _toBlock.default;
   }
 });
 Object.defineProperty(exports, "toComputedKey", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _toComputedKey.default;
   }
 });
 Object.defineProperty(exports, "toExpression", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _toExpression.default;
   }
 });
 Object.defineProperty(exports, "toIdentifier", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _toIdentifier.default;
   }
 });
 Object.defineProperty(exports, "toKeyAlias", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _toKeyAlias.default;
   }
 });
 Object.defineProperty(exports, "toSequenceExpression", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _toSequenceExpression.default;
   }
 });
 Object.defineProperty(exports, "toStatement", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _toStatement.default;
   }
 });
 Object.defineProperty(exports, "valueToNode", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _valueToNode.default;
   }
 });
 Object.defineProperty(exports, "appendToMemberExpression", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _appendToMemberExpression.default;
   }
 });
 Object.defineProperty(exports, "inherits", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _inherits.default;
   }
 });
 Object.defineProperty(exports, "prependToMemberExpression", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _prependToMemberExpression.default;
   }
 });
 Object.defineProperty(exports, "removeProperties", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _removeProperties.default;
   }
 });
 Object.defineProperty(exports, "removePropertiesDeep", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _removePropertiesDeep.default;
   }
 });
 Object.defineProperty(exports, "removeTypeDuplicates", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _removeTypeDuplicates.default;
   }
 });
 Object.defineProperty(exports, "getBindingIdentifiers", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _getBindingIdentifiers.default;
   }
 });
 Object.defineProperty(exports, "getOuterBindingIdentifiers", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _getOuterBindingIdentifiers.default;
   }
 });
 Object.defineProperty(exports, "traverse", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _traverse.default;
   }
 });
 Object.defineProperty(exports, "traverseFast", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _traverseFast.default;
   }
 });
 Object.defineProperty(exports, "shallowEqual", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _shallowEqual.default;
   }
 });
 Object.defineProperty(exports, "is", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _is.default;
   }
 });
 Object.defineProperty(exports, "isBinding", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isBinding.default;
   }
 });
 Object.defineProperty(exports, "isBlockScoped", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isBlockScoped.default;
   }
 });
 Object.defineProperty(exports, "isImmutable", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isImmutable.default;
   }
 });
 Object.defineProperty(exports, "isLet", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isLet.default;
   }
 });
 Object.defineProperty(exports, "isNode", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isNode.default;
   }
 });
 Object.defineProperty(exports, "isNodesEquivalent", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isNodesEquivalent.default;
   }
 });
 Object.defineProperty(exports, "isReferenced", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isReferenced.default;
   }
 });
 Object.defineProperty(exports, "isScope", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isScope.default;
   }
 });
 Object.defineProperty(exports, "isSpecifierDefault", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isSpecifierDefault.default;
   }
 });
 Object.defineProperty(exports, "isType", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isType.default;
   }
 });
 Object.defineProperty(exports, "isValidES3Identifier", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isValidES3Identifier.default;
   }
 });
 Object.defineProperty(exports, "isValidIdentifier", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isValidIdentifier.default;
   }
 });
 Object.defineProperty(exports, "isVar", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _isVar.default;
   }
 });
 Object.defineProperty(exports, "matchesPattern", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _matchesPattern.default;
   }
 });
 Object.defineProperty(exports, "validate", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _validate.default;
   }
 });
 Object.defineProperty(exports, "buildMatchMemberExpression", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _buildMatchMemberExpression.default;
   }
 });
 exports.react = void 0;
 
 var _isReactComponent = _interopRequireDefault(__webpack_require__(2295));
 
 var _isCompatTag = _interopRequireDefault(__webpack_require__(2301));
@@ -11386,34 +10578,34 @@ var _assertNode = _interopRequireDefault
 
 var _generated = __webpack_require__(2306);
 
 Object.keys(_generated).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
-    get: function get() {
+    get: function () {
       return _generated[key];
     }
   });
 });
 
 var _createTypeAnnotationBasedOnTypeof = _interopRequireDefault(__webpack_require__(2307));
 
 var _createUnionTypeAnnotation = _interopRequireDefault(__webpack_require__(2308));
 
 var _generated2 = __webpack_require__(2256);
 
 Object.keys(_generated2).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
-    get: function get() {
+    get: function () {
       return _generated2[key];
     }
   });
 });
 
 var _cloneNode = _interopRequireDefault(__webpack_require__(2261));
 
 var _clone = _interopRequireDefault(__webpack_require__(2275));
@@ -11438,30 +10630,30 @@ var _removeComments = _interopRequireDef
 
 var _generated3 = __webpack_require__(2313);
 
 Object.keys(_generated3).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
-    get: function get() {
+    get: function () {
       return _generated3[key];
     }
   });
 });
 
 var _constants = __webpack_require__(2259);
 
 Object.keys(_constants).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
-    get: function get() {
+    get: function () {
       return _constants[key];
     }
   });
 });
 
 var _ensureBlock = _interopRequireDefault(__webpack_require__(2314));
 
 var _toBindingIdentifierName = _interopRequireDefault(__webpack_require__(2315));
@@ -11484,17 +10676,17 @@ var _valueToNode = _interopRequireDefaul
 
 var _definitions = __webpack_require__(2257);
 
 Object.keys(_definitions).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
-    get: function get() {
+    get: function () {
       return _definitions[key];
     }
   });
 });
 
 var _appendToMemberExpression = _interopRequireDefault(__webpack_require__(2323));
 
 var _inherits = _interopRequireDefault(__webpack_require__(2324));
@@ -11553,25 +10745,25 @@ var _buildMatchMemberExpression = _inter
 
 var _generated4 = __webpack_require__(2255);
 
 Object.keys(_generated4).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
-    get: function get() {
+    get: function () {
       return _generated4[key];
     }
   });
 });
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var react = {
+const react = {
   isReactComponent: _isReactComponent.default,
   isCompatTag: _isCompatTag.default,
   buildChildren: _buildChildren.default
 };
 exports.react = react;
 
 /***/ }),
 
@@ -11586,20 +10778,18 @@ Object.defineProperty(exports, "__esModu
 });
 exports.default = buildMatchMemberExpression;
 
 var _matchesPattern = _interopRequireDefault(__webpack_require__(2270));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 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);
 }
 
 /***/ }),
 
 /***/ 2270:
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -11609,36 +10799,36 @@ Object.defineProperty(exports, "__esModu
   value: true
 });
 exports.default = matchesPattern;
 
 var _generated = __webpack_require__(2255);
 
 function matchesPattern(member, match, allowPartial) {
   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;
 
   for (node = member; (0, _generated.isMemberExpression)(node); node = node.object) {
     nodes.push(node.property);
   }
 
   nodes.push(node);
   if (nodes.length < parts.length) return false;
   if (!allowPartial && nodes.length > parts.length) return false;
 
-  for (var i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {
-    var _node = nodes[j];
-    var value = void 0;
-
-    if ((0, _generated.isIdentifier)(_node)) {
-      value = _node.name;
-    } else if ((0, _generated.isStringLiteral)(_node)) {
-      value = _node.value;
+  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;
     } else {
       return false;
     }
 
     if (parts[i] !== value) return false;
   }
 
   return true;
@@ -11653,22 +10843,19 @@ function matchesPattern(member, match, a
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = shallowEqual;
 
 function shallowEqual(actual, expected) {
-  var keys = Object.keys(expected);
-  var _arr = keys;
-
-  for (var _i = 0; _i < _arr.length; _i++) {
-    var key = _arr[_i];
-
+  const keys = Object.keys(expected);
+
+  for (const key of keys) {
     if (actual[key] !== expected[key]) {
       return false;
     }
   }
 
   return true;
 }
 
@@ -11684,19 +10871,19 @@ Object.defineProperty(exports, "__esModu
   value: true
 });
 exports.default = validate;
 
 var _definitions = __webpack_require__(2257);
 
 function validate(node, key, val) {
   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;
   if (field.optional && val == null) return;
   field.validate(node, key, val);
 }
 
 /***/ }),
 
 /***/ 2273:
@@ -11727,23 +10914,23 @@ function isNode(node) {
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = removeTypeDuplicates;
 
 var _generated = __webpack_require__(2255);
 
 function removeTypeDuplicates(nodes) {
-  var generics = {};
-  var bases = {};
-  var typeGroups = [];
-  var types = [];
-
-  for (var i = 0; i < nodes.length; i++) {
-    var node = nodes[i];
+  const generics = {};
+  const bases = {};
+  const typeGroups = [];
+  const types = [];
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
     if (!node) continue;
 
     if (types.indexOf(node) >= 0) {
       continue;
     }
 
     if ((0, _generated.isAnyTypeAnnotation)(node)) {
       return [node];
@@ -11759,20 +10946,20 @@ function removeTypeDuplicates(nodes) {
         nodes = nodes.concat(node.types);
         typeGroups.push(node.types);
       }
 
       continue;
     }
 
     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];
 
         if (existing.typeParameters) {
           if (node.typeParameters) {
             existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params));
           }
         } else {
           existing = node.typeParameters;
         }
@@ -11781,22 +10968,22 @@ function removeTypeDuplicates(nodes) {
       }
 
       continue;
     }
 
     types.push(node);
   }
 
-  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]);
   }
 
   return types;
 }
 
 /***/ }),
 
 /***/ 2275:
@@ -11828,17 +11015,17 @@ function clone(node) {
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = addComments;
 
 function addComments(node, type, comments) {
   if (!comments || !node) return node;
-  var key = type + "Comments";
+  const key = `${type}Comments`;
 
   if (node[key]) {
     if (type === "leading") {
       node[key] = comments.concat(node[key]);
     } else {
       node[key] = node[key].concat(comments);
     }
   } else {
@@ -11956,17 +11143,17 @@ var _generated = __webpack_require__(225
 
 var _generated2 = __webpack_require__(2256);
 
 function toBlock(node, parent) {
   if ((0, _generated.isBlockStatement)(node)) {
     return node;
   }
 
-  var blockNodes = [];
+  let blockNodes = [];
 
   if ((0, _generated.isEmptyStatement)(node)) {
     blockNodes = [];
   } else {
     if (!(0, _generated.isStatement)(node)) {
       if ((0, _generated.isFunction)(parent)) {
         node = (0, _generated2.returnStatement)(node);
       } else {
@@ -12001,17 +11188,17 @@ function toIdentifier(name) {
   name = name + "";
   name = name.replace(/[^a-zA-Z0-9$_]/g, "-");
   name = name.replace(/^[-0-9]+/, "");
   name = name.replace(/[-\s]+(.)?/g, function (match, c) {
     return c ? c.toUpperCase() : "";
   });
 
   if (!(0, _isValidIdentifier.default)(name)) {
-    name = "_" + name;
+    name = `_${name}`;
   }
 
   return name || "_";
 }
 
 /***/ }),
 
 /***/ 2283:
@@ -12048,51 +11235,27 @@ Object.defineProperty(exports, "__esModu
   value: true
 });
 exports.default = traverseFast;
 
 var _definitions = __webpack_require__(2257);
 
 function traverseFast(node, enter, opts) {
   if (!node) return;
-  var keys = _definitions.VISITOR_KEYS[node.type];
+  const keys = _definitions.VISITOR_KEYS[node.type];
   if (!keys) return;
   opts = opts || {};
   enter(node, opts);
 
-  for (var _iterator = keys, _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 key = _ref;
-    var subNode = node[key];
+  for (const key of keys) {
+    const 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 _node = _ref2;
-        traverseFast(_node, enter, opts);
+      for (const node of subNode) {
+        traverseFast(node, enter, opts);
       }
     } else {
       traverseFast(subNode, enter, opts);
     }
   }
 }
 
 /***/ }),
@@ -12105,62 +11268,34 @@ function traverseFast(node, enter, opts)
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = removeProperties;
 
 var _constants = __webpack_require__(2259);
 
-var CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
-
-var CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
-
-function removeProperties(node, opts) {
-  if (opts === void 0) {
-    opts = {};
-  }
-
-  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 _key = _ref;
-    if (node[_key] != null) node[_key] = undefined;
-  }
-
-  for (var key in node) {
+const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
+
+const CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
+
+function removeProperties(node, opts = {}) {
+  const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
+
+  for (const key of map) {
+    if (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);
-
-  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;
+  const symbols = Object.getOwnPropertySymbols(node);
+
+  for (const sym of symbols) {
     node[sym] = null;
   }
 }
 
 /***/ }),
 
 /***/ 2286:
 /***/ (function(module, exports, __webpack_require__) {
@@ -12311,37 +11446,33 @@ Object.defineProperty(exports, "__esModu
   value: true
 });
 exports.default = void 0;
 
 var _buildMatchMemberExpression = _interopRequireDefault(__webpack_require__(2269));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component");
+const isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component");
 var _default = isReactComponent;
 exports.default = _default;
 
 /***/ }),
 
 /***/ 2296:
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 
 var _utils = _interopRequireWildcard(__webpack_require__(2258));
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
 
-var defineInterfaceishType = function defineInterfaceishType(name, typeParameterType) {
-  if (typeParameterType === void 0) {
-    typeParameterType = "TypeParameterDeclaration";
-  }
-
+const defineInterfaceishType = (name, typeParameterType = "TypeParameterDeclaration") => {
   (0, _utils.default)(name, {
     builder: ["id", "typeParameters", "extends", "body"],
     visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"],
     aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
     fields: {
       id: (0, _utils.validateType)("Identifier"),
       typeParameters: (0, _utils.validateOptionalType)(typeParameterType),
       extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
@@ -12497,16 +11628,24 @@ defineInterfaceishType("DeclareInterface
   visitor: ["id", "typeParameters"],
   aliases: ["Flow"],
   fields: {
     id: (0, _utils.validateType)("Identifier"),
     typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
   }
 });
 defineInterfaceishType("InterfaceDeclaration");
+(0, _utils.default)("InterfaceTypeAnnotation", {
+  visitor: ["extends", "body"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+    body: (0, _utils.validateType)("ObjectTypeAnnotation")
+  }
+});
 (0, _utils.default)("IntersectionTypeAnnotation", {
   visitor: ["types"],
   aliases: ["Flow", "FlowType"],
   fields: {
     types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
   }
 });
 (0, _utils.default)("MixedTypeAnnotation", {
@@ -12528,29 +11667,41 @@ defineInterfaceishType("InterfaceDeclara
   fields: {
     value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
   }
 });
 (0, _utils.default)("NumberTypeAnnotation", {
   aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
 (0, _utils.default)("ObjectTypeAnnotation", {
-  visitor: ["properties", "indexers", "callProperties"],
+  visitor: ["properties", "indexers", "callProperties", "internalSlots"],
   aliases: ["Flow", "FlowType"],
-  builder: ["properties", "indexers", "callProperties", "exact"],
+  builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"],
   fields: {
     properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
     indexers: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeIndexer")),
     callProperties: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeCallProperty")),
+    internalSlots: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeInternalSlot")),
     exact: {
       validate: (0, _utils.assertValueType)("boolean"),
       default: false
     }
   }
 });
+(0, _utils.default)("ObjectTypeInternalSlot", {
+  visitor: ["id", "value", "optional", "static", "method"],
+  aliases: ["Flow", "UserWhitespacable"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    value: (0, _utils.validateType)("FlowType"),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
 (0, _utils.default)("ObjectTypeCallProperty", {
   visitor: ["value"],
   aliases: ["Flow", "UserWhitespacable"],
   fields: {
     value: (0, _utils.validateType)("FlowType"),
     static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
   }
 });
@@ -12568,16 +11719,17 @@ defineInterfaceishType("InterfaceDeclara
 (0, _utils.default)("ObjectTypeProperty", {
   visitor: ["key", "value", "variance"],
   aliases: ["Flow", "UserWhitespacable"],
   fields: {
     key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
     value: (0, _utils.validateType)("FlowType"),
     kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
     static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
     optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
     variance: (0, _utils.validateOptionalType)("Variance")
   }
 });
 (0, _utils.default)("ObjectTypeSpreadProperty", {
   visitor: ["argument"],
   aliases: ["Flow", "UserWhitespacable"],
   fields: {
@@ -12809,16 +11961,20 @@ function _interopRequireWildcard(obj) { 
       validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression")
     },
     selfClosing: {
       default: false,
       validate: (0, _utils.assertValueType)("boolean")
     },
     attributes: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
+    },
+    typeParameters: {
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      optional: true
     }
   }
 });
 (0, _utils.default)("JSXSpreadAttribute", {
   visitor: ["argument"],
   aliases: ["JSX"],
   fields: {
     argument: {
@@ -12892,20 +12048,16 @@ function _interopRequireWildcard(obj) { 
 
 
 var _utils = _interopRequireWildcard(__webpack_require__(2258));
 
 var _es = __webpack_require__(2266);
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 (0, _utils.default)("AwaitExpression", {
   builder: ["argument"],
   visitor: ["argument"],
   aliases: ["Expression", "Terminatorless"],
   fields: {
     argument: {
       validate: (0, _utils.assertNodeType)("Expression")
     }
@@ -12915,17 +12067,17 @@ function _defineProperty(obj, key, value
   visitor: ["object", "callee"],
   aliases: ["Expression"],
   fields: {}
 });
 (0, _utils.default)("ClassProperty", {
   visitor: ["key", "value", "typeAnnotation", "decorators"],
   builder: ["key", "value", "typeAnnotation", "decorators", "computed"],
   aliases: ["Property"],
-  fields: _objectSpread({}, _es.classMethodOrPropertyCommon, {
+  fields: Object.assign({}, _es.classMethodOrPropertyCommon, {
     value: {
       validate: (0, _utils.assertNodeType)("Expression"),
       optional: true
     },
     definite: {
       validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     },
@@ -12948,48 +12100,52 @@ function _defineProperty(obj, key, value
   visitor: ["object", "property"],
   aliases: ["Expression"],
   fields: {
     object: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
     property: {
       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);
         };
       }()
     },
     computed: {
       default: false
     },
     optional: {
       validate: (0, _utils.assertValueType)("boolean")
     }
   }
 });
 (0, _utils.default)("OptionalCallExpression", {
-  visitor: ["callee", "arguments", "typeParameters"],
+  visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
   builder: ["callee", "arguments", "optional"],
   aliases: ["Expression"],
   fields: {
     callee: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
     arguments: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName")))
     },
     optional: {
       validate: (0, _utils.assertValueType)("boolean")
     },
+    typeArguments: {
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
+      optional: true
+    },
     typeParameters: {
-      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
       optional: true
     }
   }
 });
 (0, _utils.default)("ClassPrivateProperty", {
   visitor: ["key", "value"],
   builder: ["key", "value"],
   aliases: ["Property", "Private"],
@@ -13002,24 +12158,20 @@ function _defineProperty(obj, key, value
       optional: true
     }
   }
 });
 (0, _utils.default)("Import", {
   aliases: ["Expression"]
 });
 (0, _utils.default)("Decorator", {
-  visitor: ["callee", "arguments"],
-  fields: {
-    callee: {
+  visitor: ["expression"],
+  fields: {
+    expression: {
       validate: (0, _utils.assertNodeType)("Expression")
-    },
-    arguments: {
-      optional: true,
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement")))
     }
   }
 });
 (0, _utils.default)("DoExpression", {
   visitor: ["body"],
   aliases: ["Expression"],
   fields: {
     body: {
@@ -13049,16 +12201,25 @@ function _defineProperty(obj, key, value
   visitor: ["id"],
   aliases: ["Private"],
   fields: {
     id: {
       validate: (0, _utils.assertNodeType)("Identifier")
     }
   }
 });
+(0, _utils.default)("BigIntLiteral", {
+  builder: ["value"],
+  fields: {
+    value: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  },
+  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
 
 /***/ }),
 
 /***/ 2300:
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
@@ -13066,22 +12227,18 @@ function _defineProperty(obj, key, value
 var _utils = _interopRequireWildcard(__webpack_require__(2258));
 
 var _core = __webpack_require__(2265);
 
 var _es = __webpack_require__(2266);
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var bool = (0, _utils.assertValueType)("boolean");
-var tSFunctionTypeAnnotationCommon = {
+const bool = (0, _utils.assertValueType)("boolean");
+const tSFunctionTypeAnnotationCommon = {
   returnType: {
     validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
     optional: true
   },
   typeParameters: {
     validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
     optional: true
   }
@@ -13101,87 +12258,86 @@ var tSFunctionTypeAnnotationCommon = {
     parameter: {
       validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
     }
   }
 });
 (0, _utils.default)("TSDeclareFunction", {
   aliases: ["Statement", "Declaration"],
   visitor: ["id", "typeParameters", "params", "returnType"],
-  fields: _objectSpread({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
+  fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
 });
 (0, _utils.default)("TSDeclareMethod", {
   visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
-  fields: _objectSpread({}, _es.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
+  fields: Object.assign({}, _es.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
 });
 (0, _utils.default)("TSQualifiedName", {
   aliases: ["TSEntityName"],
   visitor: ["left", "right"],
   fields: {
     left: (0, _utils.validateType)("TSEntityName"),
     right: (0, _utils.validateType)("Identifier")
   }
 });
-var signatureDeclarationCommon = {
+const signatureDeclarationCommon = {
   typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
   parameters: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
   typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
 };
-var callConstructSignatureDeclaration = {
+const callConstructSignatureDeclaration = {
   aliases: ["TSTypeElement"],
   visitor: ["typeParameters", "parameters", "typeAnnotation"],
   fields: signatureDeclarationCommon
 };
 (0, _utils.default)("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
 (0, _utils.default)("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
-var namedTypeElementCommon = {
+const namedTypeElementCommon = {
   key: (0, _utils.validateType)("Expression"),
   computed: (0, _utils.validate)(bool),
   optional: (0, _utils.validateOptional)(bool)
 };
 (0, _utils.default)("TSPropertySignature", {
   aliases: ["TSTypeElement"],
   visitor: ["key", "typeAnnotation", "initializer"],
-  fields: _objectSpread({}, namedTypeElementCommon, {
+  fields: Object.assign({}, namedTypeElementCommon, {
     readonly: (0, _utils.validateOptional)(bool),
     typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
     initializer: (0, _utils.validateOptionalType)("Expression")
   })
 });
 (0, _utils.default)("TSMethodSignature", {
   aliases: ["TSTypeElement"],
   visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
-  fields: _objectSpread({}, signatureDeclarationCommon, namedTypeElementCommon)
+  fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon)
 });
 (0, _utils.default)("TSIndexSignature", {
   aliases: ["TSTypeElement"],
   visitor: ["parameters", "typeAnnotation"],
   fields: {
     readonly: (0, _utils.validateOptional)(bool),
     parameters: (0, _utils.validateArrayOfType)("Identifier"),
     typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
   }
 });
-var tsKeywordTypes = ["TSAnyKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSBooleanKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSVoidKeyword", "TSUndefinedKeyword", "TSNullKeyword", "TSNeverKeyword"];
-
-for (var _i = 0; _i < tsKeywordTypes.length; _i++) {
-  var type = tsKeywordTypes[_i];
+const tsKeywordTypes = ["TSAnyKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSBooleanKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSVoidKeyword", "TSUndefinedKeyword", "TSNullKeyword", "TSNeverKeyword"];
+
+for (const type of tsKeywordTypes) {
   (0, _utils.default)(type, {
     aliases: ["TSType"],
     visitor: [],
     fields: {}
   });
 }
 
 (0, _utils.default)("TSThisType", {
   aliases: ["TSType"],
   visitor: [],
   fields: {}
 });
-var fnOrCtr = {
+const fnOrCtr = {
   aliases: ["TSType"],
   visitor: ["typeParameters", "typeAnnotation"],
   fields: signatureDeclarationCommon
 };
 (0, _utils.default)("TSFunctionType", fnOrCtr);
 (0, _utils.default)("TSConstructorType", fnOrCtr);
 (0, _utils.default)("TSTypeReference", {
   aliases: ["TSType"],
@@ -13222,17 +12378,17 @@ var fnOrCtr = {
 });
 (0, _utils.default)("TSTupleType", {
   aliases: ["TSType"],
   visitor: ["elementTypes"],
   fields: {
     elementTypes: (0, _utils.validateArrayOfType)("TSType")
   }
 });
-var unionOrIntersection = {
+const unionOrIntersection = {
   aliases: ["TSType"],
   visitor: ["types"],
   fields: {
     types: (0, _utils.validateArrayOfType)("TSType")
   }
 };
 (0, _utils.default)("TSUnionType", unionOrIntersection);
 (0, _utils.default)("TSIntersectionType", unionOrIntersection);
@@ -13245,17 +12401,17 @@ var unionOrIntersection = {
     trueType: (0, _utils.validateType)("TSType"),
     falseType: (0, _utils.validateType)("TSType")
   }
 });
 (0, _utils.default)("TSInferType", {
   aliases: ["TSType"],
   visitor: ["typeParameter"],
   fields: {
-    typeParameter: (0, _utils.validateType)("TSType")
+    typeParameter: (0, _utils.validateType)("TSTypeParameter")
   }
 });
 (0, _utils.default)("TSParenthesizedType", {
   aliases: ["TSType"],
   visitor: ["typeAnnotation"],
   fields: {
     typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -13487,20 +12643,20 @@ exports.default = buildChildren;
 
 var _generated = __webpack_require__(2255);
 
 var _cleanJSXElementLiteralChild = _interopRequireDefault(__webpack_require__(2303));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function buildChildren(node) {
-  var elements = [];
-
-  for (var i = 0; i < node.children.length; i++) {
-    var child = node.children[i];
+  const elements = [];
+
+  for (let i = 0; i < node.children.length; i++) {
+    let child = node.children[i];
 
     if ((0, _generated.isJSXText)(child)) {
       (0, _cleanJSXElementLiteralChild.default)(child, elements);
       continue;
     }
 
     if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression;
     if ((0, _generated.isJSXEmptyExpression)(child)) continue;
@@ -13521,33 +12677,33 @@ function buildChildren(node) {
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = cleanJSXElementLiteralChild;
 
 var _generated = __webpack_require__(2256);
 
 function cleanJSXElementLiteralChild(child, args) {
-  var lines = child.value.split(/\r\n|\n|\r/);
-  var lastNonEmptyLine = 0;
-
-  for (var i = 0; i < lines.length; i++) {
+  const lines = child.value.split(/\r\n|\n|\r/);
+  let lastNonEmptyLine = 0;
+
+  for (let i = 0; i < lines.length; i++) {
     if (lines[i].match(/[^ \t]/)) {
       lastNonEmptyLine = i;
     }
   }
 
-  var 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, " ");
+  let str = "";
+
+  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, " ");
 
     if (!isFirstLine) {
       trimmedLine = trimmedLine.replace(/^[ ]+/, "");
     }
 
     if (!isLastLine) {
       trimmedLine = trimmedLine.replace(/[ ]+$/, "");
     }
@@ -13573,57 +12729,53 @@ function cleanJSXElementLiteralChild(chi
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = builder;
 
 function _clone() {
-  var data = _interopRequireDefault(__webpack_require__(542));
-
-  _clone = function _clone() {
+  const data = _interopRequireDefault(__webpack_require__(542));
+
+  _clone = function () {
     return data;
   };
 
   return data;
 }
 
 var _definitions = __webpack_require__(2257);
 
 var _validate = _interopRequireDefault(__webpack_require__(2272));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-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];
-  }
-
-  var keys = _definitions.BUILDER_KEYS[type];
-  var countArgs = args.length;
+function builder(type, ...args) {
+  const keys = _definitions.BUILDER_KEYS[type];
+  const 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);
-  }
-
-  var node = {
-    type: type
-  };
-  var i = 0;
-  keys.forEach(function (key) {
-    var field = _definitions.NODE_FIELDS[type][key];
-    var arg;
+    throw new Error(`${type}: Too many arguments passed. Received ${countArgs} but can receive no more than ${keys.length}`);
+  }
+
+  const node = {
+    type
+  };
+  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);
     node[key] = arg;
     i++;
   });
 
-  for (var key in node) {
+  for (const key in node) {
     (0, _validate.default)(node, key, node[key]);
   }
 
   return node;
 }
 
 /***/ }),
 
@@ -13639,18 +12791,18 @@ Object.defineProperty(exports, "__esModu
 exports.default = assertNode;
 
 var _isNode = _interopRequireDefault(__webpack_require__(2273));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function assertNode(node) {
   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}"`);
   }
 }
 
 /***/ }),
 
 /***/ 2306:
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -13658,16 +12810,17 @@ function assertNode(node) {
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.assertArrayExpression = assertArrayExpression;
 exports.assertAssignmentExpression = assertAssignmentExpression;
 exports.assertBinaryExpression = assertBinaryExpression;
+exports.assertInterpreterDirective = assertInterpreterDirective;
 exports.assertDirective = assertDirective;
 exports.assertDirectiveLiteral = assertDirectiveLiteral;
 exports.assertBlockStatement = assertBlockStatement;
 exports.assertBreakStatement = assertBreakStatement;
 exports.assertCallExpression = assertCallExpression;
 exports.assertCatchClause = assertCatchClause;
 exports.assertConditionalExpression = assertConditionalExpression;
 exports.assertContinueStatement = assertContinueStatement;
@@ -13752,23 +12905,25 @@ exports.assertDeclareExportAllDeclaratio
 exports.assertDeclaredPredicate = assertDeclaredPredicate;
 exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation;
 exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;
 exports.assertFunctionTypeParam = assertFunctionTypeParam;
 exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation;
 exports.assertInferredPredicate = assertInferredPredicate;
 exports.assertInterfaceExtends = assertInterfaceExtends;
 exports.assertInterfaceDeclaration = assertInterfaceDeclaration;
+exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation;
 exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;
 exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation;
 exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;
 exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation;
 exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;
 exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation;
 exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation;
+exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot;
 exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty;
 exports.assertObjectTypeIndexer = assertObjectTypeIndexer;
 exports.assertObjectTypeProperty = assertObjectTypeProperty;
 exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;
 exports.assertOpaqueType = assertOpaqueType;
 exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
 exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
 exports.assertStringTypeAnnotation = assertStringTypeAnnotation;
@@ -13808,16 +12963,17 @@ exports.assertOptionalMemberExpression =
 exports.assertOptionalCallExpression = assertOptionalCallExpression;
 exports.assertClassPrivateProperty = assertClassPrivateProperty;
 exports.assertImport = assertImport;
 exports.assertDecorator = assertDecorator;
 exports.assertDoExpression = assertDoExpression;
 exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
 exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
 exports.assertPrivateName = assertPrivateName;
+exports.assertBigIntLiteral = assertBigIntLiteral;
 exports.assertTSParameterProperty = assertTSParameterProperty;
 exports.assertTSDeclareFunction = assertTSDeclareFunction;
 exports.assertTSDeclareMethod = assertTSDeclareMethod;
 exports.assertTSQualifiedName = assertTSQualifiedName;
 exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;
 exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;
 exports.assertTSPropertySignature = assertTSPropertySignature;
 exports.assertTSMethodSignature = assertTSMethodSignature;
@@ -13917,2025 +13073,1037 @@ exports.assertRestProperty = assertRestP
 exports.assertSpreadProperty = assertSpreadProperty;
 
 var _is = _interopRequireDefault(__webpack_require__(2262));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function assert(type, node, opts) {
   if (!(0, _is.default)(type, node, opts)) {
-    throw new Error("Expected type \"" + type + "\" with option " + JSON.stringify(opts) + ", but instead got \"" + node.type + "\".");
-  }
-}
-
-function assertArrayExpression(node, opts) {
-  if (opts === void 0) {
-    opts = {};
-  }
-
+    throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, but instead got "${node.type}".`);
+  }
+}
+
+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 assertInterpreterDirective(node, opts = {}) {
+  assert("InterpreterDirective", node, 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 assertInterfaceTypeAnnotation(node, opts = {}) {
+  assert("InterfaceTypeAnnotation", node, 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 assertObjectTypeInternalSlot(node, opts = {}) {
+  assert("ObjectTypeInternalSlot", node, 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 assertClassPrivateProperty(node, opts) {
-  if (opts === void 0) {
-    opts = {};
-  }
-
+function assertClassPrivateProperty(node, opts = {}) {
   assert("ClassPrivateProperty", 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 assertPrivateName(node, opts) {
-  if (opts === void 0) {
-    opts = {};
-  }
-
+function assertPrivateName(node, opts = {}) {
   assert("PrivateName", node, opts);</