Merge branch 'New_Structure' of https://gitlab.com/Cholgrrr/m4labplatform into New_Structure

node_modules/@babel/traverse/lib/path/modification.js

@@ -16,22 +16,17 @@ exports.hoist = hoist;
 
 var _cache = require("../cache");
 
-var _hoister = _interopRequireDefault(require("./lib/hoister"));
+var _hoister = require("./lib/hoister");
 
-var _index = _interopRequireDefault(require("./index"));
+var _index = require("./index");
 
-var t = _interopRequireWildcard(require("@babel/types"));
+var t = require("@babel/types");
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function insertBefore(nodes) {
+function insertBefore(nodes_) {
   this._assertUnremoved();
 
-  nodes = this._verifyNodeList(nodes);
+  const nodes = this._verifyNodeList(nodes_);
+
   const {
     parentPath
   } = this;
@@ -44,8 +39,9 @@ function insertBefore(nodes) {
   } else if (Array.isArray(this.container)) {
     return this._containerInsertBefore(nodes);
   } else if (this.isStatementOrBlock()) {
-    const shouldInsertCurrentNode = this.node && (!this.isExpressionStatement() || this.node.expression != null);
-    this.replaceWith(t.blockStatement(shouldInsertCurrentNode ? [this.node] : []));
+    const node = this.node;
+    const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
+    this.replaceWith(t.blockStatement(shouldInsertCurrentNode ? [node] : []));
     return this.unshiftContainer("body", nodes);
   } else {
     throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
@@ -89,10 +85,11 @@ function _containerInsertAfter(nodes) {
   return this._containerInsert(this.key + 1, nodes);
 }
 
-function insertAfter(nodes) {
+function insertAfter(nodes_) {
   this._assertUnremoved();
 
-  nodes = this._verifyNodeList(nodes);
+  const nodes = this._verifyNodeList(nodes_);
+
   const {
     parentPath
   } = this;
@@ -101,21 +98,29 @@ function insertAfter(nodes) {
     return parentPath.insertAfter(nodes.map(node => {
       return t.isExpression(node) ? t.expressionStatement(node) : node;
     }));
-  } else if (this.isNodeType("Expression") && !this.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
+  } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
     if (this.node) {
+      const node = this.node;
       let {
         scope
       } = this;
 
+      if (scope.path.isPattern()) {
+        t.assertExpression(node);
+        this.replaceWith(t.callExpression(t.arrowFunctionExpression([], node), []));
+        this.get("callee.body").insertAfter(nodes);
+        return [this];
+      }
+
       if (parentPath.isMethod({
         computed: true,
-        key: this.node
+        key: node
       })) {
         scope = scope.parent;
       }
 
       const temp = scope.generateDeclaredUidIdentifier();
-      nodes.unshift(t.expressionStatement(t.assignmentExpression("=", t.cloneNode(temp), this.node)));
+      nodes.unshift(t.expressionStatement(t.assignmentExpression("=", t.cloneNode(temp), node)));
       nodes.push(t.expressionStatement(t.cloneNode(temp)));
     }
 
@@ -123,8 +128,9 @@ function insertAfter(nodes) {
   } else if (Array.isArray(this.container)) {
     return this._containerInsertAfter(nodes);
   } else if (this.isStatementOrBlock()) {
-    const shouldInsertCurrentNode = this.node && (!this.isExpressionStatement() || this.node.expression != null);
-    this.replaceWith(t.blockStatement(shouldInsertCurrentNode ? [this.node] : []));
+    const node = this.node;
+    const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
+    this.replaceWith(t.blockStatement(shouldInsertCurrentNode ? [node] : []));
     return this.pushContainer("body", nodes);
   } else {
     throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
@@ -136,9 +142,7 @@ function updateSiblingKeys(fromIndex, incrementBy) {
 
   const paths = _cache.path.get(this.parent);
 
-  for (let i = 0; i < paths.length; i++) {
-    const path = paths[i];
-
+  for (const [, path] of paths) {
     if (path.key >= fromIndex) {
       path.key += incrementBy;
     }
@@ -150,7 +154,7 @@ function _verifyNodeList(nodes) {
     return [];
   }
 
-  if (nodes.constructor !== Array) {
+  if (!Array.isArray(nodes)) {
     nodes = [nodes];
   }
 
@@ -188,7 +192,7 @@ function unshiftContainer(listKey, nodes) {
     container: this.node[listKey],
     listKey,
     key: 0
-  });
+  }).setContext(this.context);
 
   return path._containerInsertBefore(nodes);
 }
@@ -196,7 +200,8 @@ function unshiftContainer(listKey, nodes) {
 function pushContainer(listKey, nodes) {
   this._assertUnremoved();
 
-  nodes = this._verifyNodeList(nodes);
+  const verifiedNodes = this._verifyNodeList(nodes);
+
   const container = this.node[listKey];
 
   const path = _index.default.get({
@@ -205,9 +210,9 @@ function pushContainer(listKey, nodes) {
     container: container,
     listKey,
     key: container.length
-  });
+  }).setContext(this.context);
 
-  return path.replaceWithMultiple(nodes);
+  return path.replaceWithMultiple(verifiedNodes);
 }
 
 function hoist(scope = this.scope) {

node_modules/@babel/traverse/lib/path/removal.js

@@ -12,14 +12,20 @@ exports._assertUnremoved = _assertUnremoved;
 
 var _removalHooks = require("./lib/removal-hooks");
 
+var _cache = require("../cache");
+
 var _index = require("./index");
 
 function remove() {
+  var _this$opts;
+
   this._assertUnremoved();
 
   this.resync();
 
-  this._removeFromScope();
+  if (!((_this$opts = this.opts) != null && _this$opts.noScope)) {
+    this._removeFromScope();
+  }
 
   if (this._callRemovalHooks()) {
     this._markRemoved();
@@ -56,6 +62,7 @@ function _remove() {
 
 function _markRemoved() {
   this._traverseFlags |= _index.SHOULD_SKIP | _index.REMOVED;
+  if (this.parent) _cache.path.get(this.parent).delete(this.node);
   this.node = null;
 }
 

node_modules/@babel/traverse/lib/path/replacement.js

@@ -12,53 +12,26 @@ exports.replaceInline = replaceInline;
 
 var _codeFrame = require("@babel/code-frame");
 
-var _index = _interopRequireDefault(require("../index"));
+var _index = require("../index");
 
-var _index2 = _interopRequireDefault(require("./index"));
+var _index2 = require("./index");
 
-var _parser = require("@babel/parser");
-
-var t = _interopRequireWildcard(require("@babel/types"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const hoistVariablesVisitor = {
-  Function(path) {
-    path.skip();
-  },
-
-  VariableDeclaration(path) {
-    if (path.node.kind !== "var") return;
-    const bindings = path.getBindingIdentifiers();
+var _cache = require("../cache");
 
-    for (const key of Object.keys(bindings)) {
-      path.scope.push({
-        id: bindings[key]
-      });
-    }
-
-    const exprs = [];
-
-    for (const declar of path.node.declarations) {
-      if (declar.init) {
-        exprs.push(t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init)));
-      }
-    }
+var _parser = require("@babel/parser");
 
-    path.replaceWithMultiple(exprs);
-  }
+var t = require("@babel/types");
 
-};
+var _helperHoistVariables = require("@babel/helper-hoist-variables");
 
 function replaceWithMultiple(nodes) {
+  var _pathCache$get;
+
   this.resync();
   nodes = this._verifyNodeList(nodes);
   t.inheritLeadingComments(nodes[0], this.node);
   t.inheritTrailingComments(nodes[nodes.length - 1], this.node);
+  (_pathCache$get = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get.delete(this.node);
   this.node = this.container[this.key] = null;
   const paths = this.insertAfter(nodes);
 
@@ -162,6 +135,8 @@ function replaceWith(replacement) {
 }
 
 function _replaceWith(node) {
+  var _pathCache$get2;
+
   if (!this.container) {
     throw new ReferenceError("Container is falsy");
   }
@@ -172,7 +147,8 @@ function _replaceWith(node) {
     t.validate(this.parent, this.key, node);
   }
 
-  this.debug(`Replace with ${node && node.type}`);
+  this.debug(`Replace with ${node == null ? void 0 : node.type}`);
+  (_pathCache$get2 = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get2.set(node, this).delete(this.node);
   this.node = this.container[this.key] = node;
 }
 
@@ -185,10 +161,16 @@ function replaceExpressionWithStatements(nodes) {
   }
 
   const functionParent = this.getFunctionParent();
-  const isParentAsync = functionParent && functionParent.is("async");
+  const isParentAsync = functionParent == null ? void 0 : functionParent.is("async");
+  const isParentGenerator = functionParent == null ? void 0 : functionParent.is("generator");
   const container = t.arrowFunctionExpression([], t.blockStatement(nodes));
   this.replaceWith(t.callExpression(container, []));
-  this.traverse(hoistVariablesVisitor);
+  const callee = this.get("callee");
+  (0, _helperHoistVariables.default)(callee.get("body"), id => {
+    this.scope.push({
+      id
+    });
+  }, "var");
   const completionRecords = this.get("callee").getCompletionRecords();
 
   for (const path of completionRecords) {
@@ -199,7 +181,6 @@ function replaceExpressionWithStatements(nodes) {
       let uid = loop.getData("expressionReplacementReturnUid");
 
       if (!uid) {
-        const callee = this.get("callee");
         uid = callee.scope.generateDeclaredUidIdentifier("ret");
         callee.get("body").pushContainer("body", t.returnStatement(t.cloneNode(uid)));
         loop.setData("expressionReplacementReturnUid", uid);
@@ -213,15 +194,27 @@ function replaceExpressionWithStatements(nodes) {
     }
   }
 
-  const callee = this.get("callee");
   callee.arrowFunctionToExpression();
+  const newCallee = callee;
+
+  const needToAwaitFunction = isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", t.FUNCTION_TYPES);
+
+  const needToYieldFunction = isParentGenerator && _index.default.hasType(this.get("callee.body").node, "YieldExpression", t.FUNCTION_TYPES);
+
+  if (needToAwaitFunction) {
+    newCallee.set("async", true);
+
+    if (!needToYieldFunction) {
+      this.replaceWith(t.awaitExpression(this.node));
+    }
+  }
 
-  if (isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", t.FUNCTION_TYPES)) {
-    callee.set("async", true);
-    this.replaceWith(t.awaitExpression(this.node));
+  if (needToYieldFunction) {
+    newCallee.set("generator", true);
+    this.replaceWith(t.yieldExpression(this.node, true));
   }
 
-  return callee.get("body.body");
+  return newCallee.get("body.body");
 }
 
 function replaceInline(nodes) {

node_modules/@babel/traverse/lib/scope/binding.js

@@ -12,15 +12,19 @@ class Binding {
     path,
     kind
   }) {
-    this.identifier = identifier;
-    this.scope = scope;
-    this.path = path;
-    this.kind = kind;
+    this.identifier = void 0;
+    this.scope = void 0;
+    this.path = void 0;
+    this.kind = void 0;
     this.constantViolations = [];
     this.constant = true;
     this.referencePaths = [];
     this.referenced = false;
     this.references = 0;
+    this.identifier = identifier;
+    this.scope = scope;
+    this.path = path;
+    this.kind = kind;
     this.clearValue();
   }
 

node_modules/@babel/traverse/lib/scope/index.js

@@ -5,62 +5,156 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _includes = _interopRequireDefault(require("lodash/includes"));
+var _renamer = require("./lib/renamer");
 
-var _repeat = _interopRequireDefault(require("lodash/repeat"));
+var _index = require("../index");
 
-var _renamer = _interopRequireDefault(require("./lib/renamer"));
+var _binding = require("./binding");
 
-var _index = _interopRequireDefault(require("../index"));
+var _globals = require("globals");
 
-var _defaults = _interopRequireDefault(require("lodash/defaults"));
-
-var _binding = _interopRequireDefault(require("./binding"));
-
-var _globals = _interopRequireDefault(require("globals"));
-
-var t = _interopRequireWildcard(require("@babel/types"));
+var t = require("@babel/types");
 
 var _cache = require("../cache");
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function gatherNodeParts(node, parts) {
-  if (t.isModuleDeclaration(node)) {
-    if (node.source) {
-      gatherNodeParts(node.source, parts);
-    } else if (node.specifiers && node.specifiers.length) {
-      for (const specifier of node.specifiers) {
-        gatherNodeParts(specifier, parts);
+  switch (node == null ? void 0 : node.type) {
+    default:
+      if (t.isModuleDeclaration(node)) {
+        if ((t.isExportAllDeclaration(node) || t.isExportNamedDeclaration(node) || t.isImportDeclaration(node)) && node.source) {
+          gatherNodeParts(node.source, parts);
+        } else if ((t.isExportNamedDeclaration(node) || t.isImportDeclaration(node)) && node.specifiers && node.specifiers.length) {
+          for (const e of node.specifiers) gatherNodeParts(e, parts);
+        } else if ((t.isExportDefaultDeclaration(node) || t.isExportNamedDeclaration(node)) && node.declaration) {
+          gatherNodeParts(node.declaration, parts);
+        }
+      } else if (t.isModuleSpecifier(node)) {
+        gatherNodeParts(node.local, parts);
+      } else if (t.isLiteral(node)) {
+        parts.push(node.value);
+      }
+
+      break;
+
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+    case "JSXMemberExpression":
+      gatherNodeParts(node.object, parts);
+      gatherNodeParts(node.property, parts);
+      break;
+
+    case "Identifier":
+    case "JSXIdentifier":
+      parts.push(node.name);
+      break;
+
+    case "CallExpression":
+    case "OptionalCallExpression":
+    case "NewExpression":
+      gatherNodeParts(node.callee, parts);
+      break;
+
+    case "ObjectExpression":
+    case "ObjectPattern":
+      for (const e of node.properties) {
+        gatherNodeParts(e, parts);
       }
-    } else if (node.declaration) {
-      gatherNodeParts(node.declaration, parts);
-    }
-  } else if (t.isModuleSpecifier(node)) {
-    gatherNodeParts(node.local, parts);
-  } else if (t.isMemberExpression(node)) {
-    gatherNodeParts(node.object, parts);
-    gatherNodeParts(node.property, parts);
-  } else if (t.isIdentifier(node)) {
-    parts.push(node.name);
-  } else if (t.isLiteral(node)) {
-    parts.push(node.value);
-  } else if (t.isCallExpression(node)) {
-    gatherNodeParts(node.callee, parts);
-  } else if (t.isObjectExpression(node) || t.isObjectPattern(node)) {
-    for (const prop of node.properties) {
-      gatherNodeParts(prop.key || prop.argument, parts);
-    }
-  } else if (t.isPrivateName(node)) {
-    gatherNodeParts(node.id, parts);
-  } else if (t.isThisExpression(node)) {
-    parts.push("this");
-  } else if (t.isSuper(node)) {
-    parts.push("super");
+
+      break;
+
+    case "SpreadElement":
+    case "RestElement":
+      gatherNodeParts(node.argument, parts);
+      break;
+
+    case "ObjectProperty":
+    case "ObjectMethod":
+    case "ClassProperty":
+    case "ClassMethod":
+    case "ClassPrivateProperty":
+    case "ClassPrivateMethod":
+      gatherNodeParts(node.key, parts);
+      break;
+
+    case "ThisExpression":
+      parts.push("this");
+      break;
+
+    case "Super":
+      parts.push("super");
+      break;
+
+    case "Import":
+      parts.push("import");
+      break;
+
+    case "DoExpression":
+      parts.push("do");
+      break;
+
+    case "YieldExpression":
+      parts.push("yield");
+      gatherNodeParts(node.argument, parts);
+      break;
+
+    case "AwaitExpression":
+      parts.push("await");
+      gatherNodeParts(node.argument, parts);
+      break;
+
+    case "AssignmentExpression":
+      gatherNodeParts(node.left, parts);
+      break;
+
+    case "VariableDeclarator":
+      gatherNodeParts(node.id, parts);
+      break;
+
+    case "FunctionExpression":
+    case "FunctionDeclaration":
+    case "ClassExpression":
+    case "ClassDeclaration":
+      gatherNodeParts(node.id, parts);
+      break;
+
+    case "PrivateName":
+      gatherNodeParts(node.id, parts);
+      break;
+
+    case "ParenthesizedExpression":
+      gatherNodeParts(node.expression, parts);
+      break;
+
+    case "UnaryExpression":
+    case "UpdateExpression":
+      gatherNodeParts(node.argument, parts);
+      break;
+
+    case "MetaProperty":
+      gatherNodeParts(node.meta, parts);
+      gatherNodeParts(node.property, parts);
+      break;
+
+    case "JSXElement":
+      gatherNodeParts(node.openingElement, parts);
+      break;
+
+    case "JSXOpeningElement":
+      parts.push(node.name);
+      break;
+
+    case "JSXFragment":
+      gatherNodeParts(node.openingFragment, parts);
+      break;
+
+    case "JSXOpeningFragment":
+      parts.push("Fragment");
+      break;
+
+    case "JSXNamespacedName":
+      gatherNodeParts(node.namespace, parts);
+      gatherNodeParts(node.name, parts);
+      break;
   }
 }
 
@@ -78,11 +172,7 @@ const collectorVisitor = {
 
   Declaration(path) {
     if (path.isBlockScoped()) return;
-
-    if (path.isExportDeclaration() && path.get("declaration").isDeclaration()) {
-      return;
-    }
-
+    if (path.isExportDeclaration()) return;
     const parent = path.scope.getFunctionParent() || path.scope.getProgramParent();
     parent.registerDeclaration(path);
   },
@@ -105,6 +195,7 @@ const collectorVisitor = {
         node,
         scope
       } = path;
+      if (t.isExportAllDeclaration(node)) return;
       const declar = node.declaration;
 
       if (t.isClassDeclaration(declar) || t.isFunctionDeclaration(declar)) {
@@ -125,7 +216,6 @@ const collectorVisitor = {
   },
 
   LabeledStatement(path) {
-    path.scope.getProgramParent().addGlobal(path.node);
     path.scope.getBlockParent().registerDeclaration(path);
   },
 
@@ -146,23 +236,35 @@ const collectorVisitor = {
   BlockScoped(path) {
     let scope = path.scope;
     if (scope.path === path) scope = scope.parent;
-    scope.getBlockParent().registerDeclaration(path);
+    const parent = scope.getBlockParent();
+    parent.registerDeclaration(path);
+
+    if (path.isClassDeclaration() && path.node.id) {
+      const id = path.node.id;
+      const name = id.name;
+      path.scope.bindings[name] = path.scope.parent.getBinding(name);
+    }
   },
 
-  ClassDeclaration(path) {
-    const id = path.node.id;
-    if (!id) return;
-    const name = id.name;
-    path.scope.bindings[name] = path.scope.getBinding(name);
+  CatchClause(path) {
+    path.scope.registerBinding("let", path);
   },
 
-  Block(path) {
-    const paths = path.get("body");
+  Function(path) {
+    if (path.isFunctionExpression() && path.has("id") && !path.get("id").node[t.NOT_LOCAL_BINDING]) {
+      path.scope.registerBinding("local", path.get("id"), path);
+    }
 
-    for (const bodyPath of paths) {
-      if (bodyPath.isFunctionDeclaration()) {
-        path.scope.getBlockParent().registerDeclaration(bodyPath);
-      }
+    const params = path.get("params");
+
+    for (const param of params) {
+      path.scope.registerBinding("param", param);
+    }
+  },
+
+  ClassExpression(path) {
+    if (path.has("id") && !path.get("id").node[t.NOT_LOCAL_BINDING]) {
+      path.scope.registerBinding("local", path);
     }
   }
 
@@ -171,13 +273,24 @@ let uid = 0;
 
 class Scope {
   constructor(path) {
+    this.uid = void 0;
+    this.path = void 0;
+    this.block = void 0;
+    this.labels = void 0;
+    this.inited = void 0;
+    this.bindings = void 0;
+    this.references = void 0;
+    this.globals = void 0;
+    this.uids = void 0;
+    this.data = void 0;
+    this.crawling = void 0;
     const {
       node
     } = path;
 
     const cached = _cache.scope.get(node);
 
-    if (cached && cached.path === path) {
+    if ((cached == null ? void 0 : cached.path) === path) {
       return cached;
     }
 
@@ -187,11 +300,23 @@ class Scope {
     this.block = node;
     this.path = path;
     this.labels = new Map();
+    this.inited = false;
   }
 
   get parent() {
-    const parent = this.path.findParent(p => p.isScope());
-    return parent && parent.scope;
+    var _parent;
+
+    let parent,
+        path = this.path;
+
+    do {
+      const isKey = path.key === "key";
+      path = path.parentPath;
+      if (isKey && path.isMethod()) path = path.parentPath;
+      if (path && path.isScope()) parent = path;
+    } while (path && !parent);
+
+    return (_parent = parent) == null ? void 0 : _parent.scope;
   }
 
   get parentBlock() {
@@ -221,7 +346,7 @@ class Scope {
   generateUid(name = "temp") {
     name = t.toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
     let uid;
-    let i = 0;
+    let i = 1;
 
     do {
       uid = this._generateUid(name, i);
@@ -240,17 +365,7 @@ class Scope {
     return `_${id}`;
   }
 
-  generateUidBasedOnNode(parent, defaultName) {
-    let node = parent;
-
-    if (t.isAssignmentExpression(parent)) {
-      node = parent.left;
-    } else if (t.isVariableDeclarator(parent)) {
-      node = parent.id;
-    } else if (t.isObjectProperty(node) || t.isObjectMethod(node)) {
-      node = node.key;
-    }
-
+  generateUidBasedOnNode(node, defaultName) {
     const parts = [];
     gatherNodeParts(node, parts);
     let id = parts.join("$");
@@ -258,8 +373,8 @@ class Scope {
     return this.generateUid(id.slice(0, 20));
   }
 
-  generateUidIdentifierBasedOnNode(parent, defaultName) {
-    return t.identifier(this.generateUidBasedOnNode(parent, defaultName));
+  generateUidIdentifierBasedOnNode(node, defaultName) {
+    return t.identifier(this.generateUidBasedOnNode(node, defaultName));
   }
 
   isStatic(node) {
@@ -324,7 +439,7 @@ class Scope {
   }
 
   dump() {
-    const sep = (0, _repeat.default)("-", 60);
+    const sep = "-".repeat(60);
     console.log(sep);
     let scope = this;
 
@@ -345,11 +460,11 @@ class Scope {
     console.log(sep);
   }
 
-  toArray(node, i) {
+  toArray(node, i, arrayLikeIsIterable) {
     if (t.isIdentifier(node)) {
       const binding = this.getBinding(node.name);
 
-      if (binding && binding.constant && binding.path.isGenericType("Array")) {
+      if (binding != null && binding.constant && binding.path.isGenericType("Array")) {
         return node;
       }
     }
@@ -376,6 +491,11 @@ class Scope {
       helperName = "toArray";
     }
 
+    if (arrayLikeIsIterable) {
+      args.unshift(this.hub.addHelper(helperName));
+      helperName = "maybeArrayLike";
+    }
+
     return t.callExpression(this.hub.addHelper(helperName), args);
   }
 
@@ -451,6 +571,8 @@ class Scope {
     const ids = path.getOuterBindingIdentifiers(true);
 
     for (const name of Object.keys(ids)) {
+      parent.references[name] = true;
+
       for (const id of ids[name]) {
         const local = this.getOwnBinding(name);
 
@@ -459,8 +581,6 @@ class Scope {
           this.checkBlockScopedCollisions(local, kind, name, id);
         }
 
-        parent.references[name] = true;
-
         if (local) {
           this.registerConstantViolation(bindingPath);
         } else {
@@ -500,13 +620,7 @@ class Scope {
   }
 
   hasReference(name) {
-    let scope = this;
-
-    do {
-      if (scope.references[name]) return true;
-    } while (scope = scope.parent);
-
-    return false;
+    return !!this.getProgramParent().references[name];
   }
 
   isPure(node, constantsOnly) {
@@ -541,7 +655,7 @@ class Scope {
       }
 
       return true;
-    } else if (t.isClassMethod(node)) {
+    } else if (t.isMethod(node)) {
       if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
       if (node.kind === "get" || node.kind === "set") return false;
       return true;
@@ -586,7 +700,10 @@ class Scope {
   }
 
   init() {
-    if (!this.references) this.crawl();
+    if (!this.inited) {
+      this.inited = true;
+      this.crawl();
+    }
   }
 
   crawl() {
@@ -596,56 +713,37 @@ class Scope {
     this.globals = Object.create(null);
     this.uids = Object.create(null);
     this.data = Object.create(null);
+    const programParent = this.getProgramParent();
+    if (programParent.crawling) return;
+    const state = {
+      references: [],
+      constantViolations: [],
+      assignments: []
+    };
+    this.crawling = true;
 
-    if (path.isLoop()) {
-      for (const key of t.FOR_INIT_KEYS) {
-        const node = path.get(key);
-        if (node.isBlockScoped()) this.registerBinding(node.node.kind, node);
-      }
-    }
-
-    if (path.isFunctionExpression() && path.has("id")) {
-      if (!path.get("id").node[t.NOT_LOCAL_BINDING]) {
-        this.registerBinding("local", path.get("id"), path);
-      }
-    }
-
-    if (path.isClassExpression() && path.has("id")) {
-      if (!path.get("id").node[t.NOT_LOCAL_BINDING]) {
-        this.registerBinding("local", path);
+    if (path.type !== "Program" && collectorVisitor._exploded) {
+      for (const visit of collectorVisitor.enter) {
+        visit(path, state);
       }
-    }
 
-    if (path.isFunction()) {
-      const params = path.get("params");
+      const typeVisitors = collectorVisitor[path.type];
 
-      for (const param of params) {
-        this.registerBinding("param", param);
+      if (typeVisitors) {
+        for (const visit of typeVisitors.enter) {
+          visit(path, state);
+        }
       }
     }
 
-    if (path.isCatchClause()) {
-      this.registerBinding("let", path);
-    }
-
-    const parent = this.getProgramParent();
-    if (parent.crawling) return;
-    const state = {
-      references: [],
-      constantViolations: [],
-      assignments: []
-    };
-    this.crawling = true;
     path.traverse(collectorVisitor, state);
     this.crawling = false;
 
     for (const path of state.assignments) {
       const ids = path.getBindingIdentifiers();
-      let programParent;
 
       for (const name of Object.keys(ids)) {
         if (path.scope.getBinding(name)) continue;
-        programParent = programParent || path.scope.getProgramParent();
         programParent.addGlobal(ids[name]);
       }
 
@@ -658,7 +756,7 @@ class Scope {
       if (binding) {
         binding.reference(ref);
       } else {
-        ref.scope.getProgramParent().addGlobal(ref.node);
+        programParent.addGlobal(ref.node);
       }
     }
 
@@ -742,17 +840,22 @@ class Scope {
     let scope = this;
 
     do {
-      (0, _defaults.default)(ids, scope.bindings);
+      for (const key of Object.keys(scope.bindings)) {
+        if (key in ids === false) {
+          ids[key] = scope.bindings[key];
+        }
+      }
+
       scope = scope.parent;
     } while (scope);
 
     return ids;
   }
 
-  getAllBindingsOfKind() {
+  getAllBindingsOfKind(...kinds) {
     const ids = Object.create(null);
 
-    for (const kind of arguments) {
+    for (const kind of kinds) {
       let scope = this;
 
       do {
@@ -774,10 +877,20 @@ class Scope {
 
   getBinding(name) {
     let scope = this;
+    let previousPath;
 
     do {
       const binding = scope.getOwnBinding(name);
-      if (binding) return binding;
+
+      if (binding) {
+        var _previousPath;
+
+        if ((_previousPath = previousPath) != null && _previousPath.isPattern() && binding.kind !== "param") {} else {
+          return binding;
+        }
+      }
+
+      previousPath = scope.path;
     } while (scope = scope.parent);
   }
 
@@ -786,13 +899,14 @@ class Scope {
   }
 
   getBindingIdentifier(name) {
-    const info = this.getBinding(name);
-    return info && info.identifier;
+    var _this$getBinding;
+
+    return (_this$getBinding = this.getBinding(name)) == null ? void 0 : _this$getBinding.identifier;
   }
 
   getOwnBindingIdentifier(name) {
     const binding = this.bindings[name];
-    return binding && binding.identifier;
+    return binding == null ? void 0 : binding.identifier;
   }
 
   hasOwnBinding(name) {
@@ -804,13 +918,15 @@ class Scope {
     if (this.hasOwnBinding(name)) return true;
     if (this.parentHasBinding(name, noGlobals)) return true;
     if (this.hasUid(name)) return true;
-    if (!noGlobals && (0, _includes.default)(Scope.globals, name)) return true;
-    if (!noGlobals && (0, _includes.default)(Scope.contextVariables, name)) return true;
+    if (!noGlobals && Scope.globals.includes(name)) return true;
+    if (!noGlobals && Scope.contextVariables.includes(name)) return true;
     return false;
   }
 
   parentHasBinding(name, noGlobals) {
-    return this.parent && this.parent.hasBinding(name, noGlobals);
+    var _this$parent;
+
+    return (_this$parent = this.parent) == null ? void 0 : _this$parent.hasBinding(name, noGlobals);
   }
 
   moveBindingTo(name, scope) {
@@ -828,12 +944,9 @@ class Scope {
   }
 
   removeBinding(name) {
-    const info = this.getBinding(name);
-
-    if (info) {
-      info.scope.removeOwnBinding(name);
-    }
+    var _this$getBinding2;
 
+    (_this$getBinding2 = this.getBinding(name)) == null ? void 0 : _this$getBinding2.scope.removeOwnBinding(name);
     let scope = this;
 
     do {
@@ -846,5 +959,5 @@ class Scope {
 }
 
 exports.default = Scope;
-Scope.globals = Object.keys(_globals.default.builtin);
+Scope.globals = Object.keys(_globals.builtin);
 Scope.contextVariables = ["arguments", "undefined", "Infinity", "NaN"];
\ No newline at end of file

node_modules/@babel/traverse/lib/scope/lib/renamer.js

@@ -5,17 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _binding = _interopRequireDefault(require("../binding"));
+var _binding = require("../binding");
 
-var _helperSplitExportDeclaration = _interopRequireDefault(require("@babel/helper-split-export-declaration"));
+var _helperSplitExportDeclaration = require("@babel/helper-split-export-declaration");
 
-var t = _interopRequireWildcard(require("@babel/types"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var t = require("@babel/types");
 
 const renameVisitor = {
   ReferencedIdentifier({
@@ -28,11 +22,12 @@ const renameVisitor = {
 
   Scope(path, state) {
     if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
-      path.skip();
+      skipAllButComputedMethodKey(path);
     }
   },
 
-  "AssignmentExpression|Declaration"(path, state) {
+  "AssignmentExpression|Declaration|VariableDeclarator"(path, state) {
+    if (path.isVariableDeclaration()) return;
     const ids = path.getOuterBindingIdentifiers();
 
     for (const name in ids) {
@@ -103,7 +98,15 @@ class Renamer {
       }
     }
 
-    scope.traverse(block || scope.block, renameVisitor, this);
+    const blockToTraverse = block || scope.block;
+
+    if ((blockToTraverse == null ? void 0 : blockToTraverse.type) === "SwitchStatement") {
+      blockToTraverse.cases.forEach(c => {
+        scope.traverse(c, renameVisitor, this);
+      });
+    } else {
+      scope.traverse(blockToTraverse, renameVisitor, this);
+    }
 
     if (!block) {
       scope.removeOwnBinding(oldName);
@@ -111,8 +114,6 @@ class Renamer {
       this.binding.identifier.name = newName;
     }
 
-    if (binding.type === "hoisted") {}
-
     if (parentDeclar) {
       this.maybeConvertFromClassFunctionDeclaration(parentDeclar);
       this.maybeConvertFromClassFunctionExpression(parentDeclar);
@@ -121,4 +122,17 @@ class Renamer {
 
 }
 
-exports.default = Renamer;
+exports.default = Renamer;
\ No newline at end of file
+
+function skipAllButComputedMethodKey(path) {
+  if (!path.isMethod() || !path.node.computed) {
+    path.skip();
+    return;
+  }
+
+  const keys = t.VISITOR_KEYS[path.type];
+
+  for (const key of keys) {
+    if (key !== "key") path.skipKey(key);
+  }
+}
\ No newline at end of file

node_modules/@babel/traverse/lib/visitors.js

@@ -7,17 +7,9 @@ exports.explode = explode;
 exports.verify = verify;
 exports.merge = merge;
 
-var virtualTypes = _interopRequireWildcard(require("./path/lib/virtual-types"));
+var virtualTypes = require("./path/lib/virtual-types");
 
-var t = _interopRequireWildcard(require("@babel/types"));
-
-var _clone = _interopRequireDefault(require("lodash/clone"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var t = require("@babel/types");
 
 function explode(visitor) {
   if (visitor._exploded) return visitor;
@@ -69,11 +61,11 @@ function explode(visitor) {
     if (shouldIgnoreKey(nodeType)) continue;
     const fns = visitor[nodeType];
     let aliases = t.FLIPPED_ALIAS_KEYS[nodeType];
-    const deprecratedKey = t.DEPRECATED_KEYS[nodeType];
+    const deprecatedKey = t.DEPRECATED_KEYS[nodeType];
 
-    if (deprecratedKey) {
-      console.trace(`Visitor defined for ${nodeType} but it has been renamed to ${deprecratedKey}`);
-      aliases = [deprecratedKey];
+    if (deprecatedKey) {
+      console.trace(`Visitor defined for ${nodeType} but it has been renamed to ${deprecatedKey}`);
+      aliases = [deprecatedKey];
     }
 
     if (!aliases) continue;
@@ -85,7 +77,7 @@ function explode(visitor) {
       if (existing) {
         mergePair(existing, fns);
       } else {
-        visitor[alias] = (0, _clone.default)(fns);
+        visitor[alias] = Object.assign({}, fns);
       }
     }
   }
@@ -184,6 +176,10 @@ function wrapWithStateOrWrapper(oldVisitor, state, wrapper) {
         newFn = wrapper(state.key, key, newFn);
       }
 
+      if (newFn !== fn) {
+        newFn.toString = () => fn.toString();
+      }
+
       return newFn;
     });
     newVisitor[key] = fns;
@@ -226,7 +222,7 @@ function shouldIgnoreKey(key) {
   if (key[0] === "_") return true;
   if (key === "enter" || key === "exit" || key === "shouldSkip") return true;
 
-  if (key === "blacklist" || key === "noScope" || key === "skipKeys") {
+  if (key === "denylist" || key === "noScope" || key === "skipKeys" || key === "blacklist") {
     return true;
   }
 

node_modules/@babel/traverse/package.json

 {
-  "_from": "@babel/traverse@^7.7.2",
-  "_id": "@babel/traverse@7.7.2",
-  "_inBundle": false,
-  "_integrity": "sha512-TM01cXib2+rgIZrGJOLaHV/iZUAxf4A0dt5auY6KNZ+cm6aschuJGqKJM3ROTt3raPUdIDk9siAufIFEleRwtw==",
-  "_location": "/@babel/traverse",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "@babel/traverse@^7.7.2",
-    "name": "@babel/traverse",
-    "escapedName": "@babel%2ftraverse",
-    "scope": "@babel",
-    "rawSpec": "^7.7.2",
-    "saveSpec": null,
-    "fetchSpec": "^7.7.2"
-  },
-  "_requiredBy": [
-    "/@babel/core",
-    "/@babel/helper-call-delegate",
-    "/@babel/helper-explode-assignable-expression",
-    "/@babel/helper-remap-async-to-generator",
-    "/@babel/helper-replace-supers",
-    "/@babel/helper-wrap-function",
-    "/@babel/helpers"
-  ],
-  "_resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.7.2.tgz",
-  "_shasum": "ef0a65e07a2f3c550967366b3d9b62a2dcbeae09",
-  "_spec": "@babel/traverse@^7.7.2",
-  "_where": "C:\\Work\\OneDrive - bwstaff\\M4_Lab\\TV3\\NewVersion01\\LAFJLBmf939XYm5gj\\dev\\node_modules\\@babel\\core",
-  "author": {
-    "name": "Sebastian McKenzie",
-    "email": "sebmck@gmail.com"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "@babel/code-frame": "^7.5.5",
-    "@babel/generator": "^7.7.2",
-    "@babel/helper-function-name": "^7.7.0",
-    "@babel/helper-split-export-declaration": "^7.7.0",
-    "@babel/parser": "^7.7.2",
-    "@babel/types": "^7.7.2",
-    "debug": "^4.1.0",
-    "globals": "^11.1.0",
-    "lodash": "^4.17.13"
-  },
-  "deprecated": false,
+  "name": "@babel/traverse",
+  "version": "7.14.5",
   "description": "The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes",
-  "devDependencies": {
-    "@babel/helper-plugin-test-runner": "^7.0.0"
-  },
-  "gitHead": "35f4d1276310bac6fede4a6f86a5c76f951e179e",
-  "homepage": "https://babeljs.io/",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-traverse",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20traverse%22+is%3Aopen",
   "license": "MIT",
-  "main": "lib/index.js",
-  "name": "@babel/traverse",
   "publishConfig": {
     "access": "public"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/babel/babel/tree/master/packages/babel-traverse"
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-traverse"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/code-frame": "^7.14.5",
+    "@babel/generator": "^7.14.5",
+    "@babel/helper-function-name": "^7.14.5",
+    "@babel/helper-hoist-variables": "^7.14.5",
+    "@babel/helper-split-export-declaration": "^7.14.5",
+    "@babel/parser": "^7.14.5",
+    "@babel/types": "^7.14.5",
+    "debug": "^4.1.0",
+    "globals": "^11.1.0"
+  },
+  "devDependencies": {
+    "@babel/helper-plugin-test-runner": "7.14.5"
   },
-  "version": "7.7.2"
-}
+  "engines": {
+    "node": ">=6.9.0"
+  }
+}
\ No newline at end of file

node_modules/@babel/types/README.md

@@ -2,7 +2,7 @@
 
 > Babel Types is a Lodash-esque utility library for AST nodes
 
-See our website [@babel/types](https://babeljs.io/docs/en/next/babel-types.html) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen) associated with this package.
+See our website [@babel/types](https://babeljs.io/docs/en/babel-types) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen) associated with this package.
 
 ## Install
 

node_modules/@babel/types/lib/asserts/assertNode.js

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = assertNode;
 
-var _isNode = _interopRequireDefault(require("../validators/isNode"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _isNode = require("../validators/isNode");
 
 function assertNode(node) {
   if (!(0, _isNode.default)(node)) {
-    const type = node && node.type || JSON.stringify(node);
+    var _node$type;
+
+    const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);
     throw new TypeError(`Not a valid node of type "${type}"`);
   }
 }
\ No newline at end of file

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

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

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

@@ -5,13 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = builder;
 
-var _clone = _interopRequireDefault(require("lodash/clone"));
-
 var _definitions = require("../definitions");
 
-var _validate = _interopRequireDefault(require("../validators/validate"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _validate = require("../validators/validate");
 
 function builder(type, ...args) {
   const keys = _definitions.BUILDER_KEYS[type];
@@ -29,7 +25,11 @@ function builder(type, ...args) {
     const field = _definitions.NODE_FIELDS[type][key];
     let arg;
     if (i < countArgs) arg = args[i];
-    if (arg === undefined) arg = (0, _clone.default)(field.default);
+
+    if (arg === undefined) {
+      arg = Array.isArray(field.default) ? [] : field.default;
+    }
+
     node[key] = arg;
     i++;
   });

node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js

@@ -22,7 +22,9 @@ function createTypeAnnotationBasedOnTypeof(type) {
     return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object"));
   } else if (type === "symbol") {
     return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol"));
+  } else if (type === "bigint") {
+    return (0, _generated.anyTypeAnnotation)();
   } else {
-    throw new Error("Invalid typeof value");
+    throw new Error("Invalid typeof value: " + type);
   }
 }
\ No newline at end of file

node_modules/@babel/types/lib/builders/flow/createUnionTypeAnnotation.js

-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = createUnionTypeAnnotation;
-
-var _generated = require("../generated");
-
-var _removeTypeDuplicates = _interopRequireDefault(require("../../modifications/flow/removeTypeDuplicates"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function createUnionTypeAnnotation(types) {
-  const flattened = (0, _removeTypeDuplicates.default)(types);
-
-  if (flattened.length === 1) {
-    return flattened[0];
-  } else {
-    return (0, _generated.unionTypeAnnotation)(flattened);
-  }
-}
\ No newline at end of file

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

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

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

@@ -7,9 +7,7 @@ exports.default = buildChildren;
 
 var _generated = require("../../validators/generated");
 
-var _cleanJSXElementLiteralChild = _interopRequireDefault(require("../../utils/react/cleanJSXElementLiteralChild"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild");
 
 function buildChildren(node) {
   const elements = [];

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

@@ -5,9 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = clone;
 
-var _cloneNode = _interopRequireDefault(require("./cloneNode"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _cloneNode = require("./cloneNode");
 
 function clone(node) {
   return (0, _cloneNode.default)(node, false);

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

@@ -5,9 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = cloneDeep;
 
-var _cloneNode = _interopRequireDefault(require("./cloneNode"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _cloneNode = require("./cloneNode");
 
 function cloneDeep(node) {
   return (0, _cloneNode.default)(node);

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

@@ -7,34 +7,36 @@ exports.default = cloneNode;
 
 var _definitions = require("../definitions");
 
+var _generated = require("../validators/generated");
+
 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);
+function cloneIfNode(obj, deep, withoutLoc) {
+  if (obj && typeof obj.type === "string") {
+    return cloneNode(obj, deep, withoutLoc);
   }
 
   return obj;
 }
 
-function cloneIfNodeOrArray(obj, deep) {
+function cloneIfNodeOrArray(obj, deep, withoutLoc) {
   if (Array.isArray(obj)) {
-    return obj.map(node => cloneIfNode(node, deep));
+    return obj.map(node => cloneIfNode(node, deep, withoutLoc));
   }
 
-  return cloneIfNode(obj, deep);
+  return cloneIfNode(obj, deep, withoutLoc);
 }
 
-function cloneNode(node, deep = true) {
+function cloneNode(node, deep = true, withoutLoc = false) {
   if (!node) return node;
   const {
     type
   } = node;
   const newNode = {
-    type
+    type: node.type
   };
 
-  if (type === "Identifier") {
+  if ((0, _generated.isIdentifier)(node)) {
     newNode.name = node.name;
 
     if (has(node, "optional") && typeof node.optional === "boolean") {
@@ -42,32 +44,40 @@ function cloneNode(node, deep = true) {
     }
 
     if (has(node, "typeAnnotation")) {
-      newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true) : node.typeAnnotation;
+      newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc) : node.typeAnnotation;
     }
   } else if (!has(_definitions.NODE_FIELDS, type)) {
     throw new Error(`Unknown node type: "${type}"`);
   } else {
     for (const field of Object.keys(_definitions.NODE_FIELDS[type])) {
       if (has(node, field)) {
-        newNode[field] = deep ? cloneIfNodeOrArray(node[field], true) : node[field];
+        if (deep) {
+          newNode[field] = (0, _generated.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc) : cloneIfNodeOrArray(node[field], true, withoutLoc);
+        } else {
+          newNode[field] = node[field];
+        }
       }
     }
   }
 
   if (has(node, "loc")) {
-    newNode.loc = node.loc;
+    if (withoutLoc) {
+      newNode.loc = null;
+    } else {
+      newNode.loc = node.loc;
+    }
   }
 
   if (has(node, "leadingComments")) {
-    newNode.leadingComments = node.leadingComments;
+    newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc);
   }
 
   if (has(node, "innerComments")) {
-    newNode.innerComments = node.innerComments;
+    newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc);
   }
 
   if (has(node, "trailingComments")) {
-    newNode.trailingComments = node.trailingComments;
+    newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc);
   }
 
   if (has(node, "extra")) {
@@ -75,4 +85,30 @@ function cloneNode(node, deep = true) {
   }
 
   return newNode;
+}
+
+function maybeCloneComments(comments, deep, withoutLoc) {
+  if (!comments || !deep) {
+    return comments;
+  }
+
+  return comments.map(({
+    type,
+    value,
+    loc
+  }) => {
+    if (withoutLoc) {
+      return {
+        type,
+        value,
+        loc: null
+      };
+    }
+
+    return {
+      type,
+      value,
+      loc
+    };
+  });
 }
\ No newline at end of file

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

@@ -5,12 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = cloneWithoutLoc;
 
-var _clone = _interopRequireDefault(require("./clone"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _cloneNode = require("./cloneNode");
 
 function cloneWithoutLoc(node) {
-  const newNode = (0, _clone.default)(node);
-  newNode.loc = null;
-  return newNode;
+  return (0, _cloneNode.default)(node, false, true);
 }
\ No newline at end of file