@babel/traverse 8.0.0-alpha.9 → 8.0.0-beta.1

package/lib/index.js

@@ -1,13 +1,10 @@
-import * as _t from '@babel/types';
 import buildDebug from 'debug';
-import splitExportDeclaration from '@babel/helper-split-export-declaration';
-import environmentVisitor, { requeueComputedKeyAndDecorators } from '@babel/helper-environment-visitor';
-import globals from 'globals';
-import generator from '@babel/generator';
 import { codeFrameColumns } from '@babel/code-frame';
+import * as _t from '@babel/types';
 import { parse } from '@babel/parser';
-import hoistVariables from '@babel/helper-hoist-variables';
-import nameFunction from '@babel/helper-function-name';
+import { createRequire } from 'module';
+import generator from '@babel/generator';
+import template from '@babel/template';
 
 const ReferencedIdentifier = ["Identifier", "JSXIdentifier"];
 const ReferencedMemberExpression = ["MemberExpression"];
@@ -70,12 +67,12 @@ const {
   isStatement: nodeIsStatement,
   isVar: nodeIsVar,
   isVariableDeclaration: isVariableDeclaration$2,
-  react: react$1,
+  react,
   isForOfStatement
 } = _t;
 const {
   isCompatTag
-} = react$1;
+} = react;
 function isReferencedIdentifier(opts) {
   const {
     node,
@@ -291,8 +288,8 @@ function verify$1(visitor) {
       validateVisitorMethods(nodeType, visitor[nodeType]);
     }
     if (shouldIgnoreKey(nodeType)) continue;
-    if (TYPES.indexOf(nodeType) < 0) {
-      throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type`);
+    if (!TYPES.includes(nodeType)) {
+      throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type in @babel/traverse ${"8.0.0-beta.1"}`);
     }
     const visitors = visitor[nodeType];
     if (typeof visitors === "object") {
@@ -316,7 +313,10 @@ function validateVisitorMethods(path, val) {
   }
 }
 function merge(visitors, states = [], wrapper) {
-  const mergedVisitor = {};
+  const mergedVisitor = {
+    _verified: true,
+    _exploded: true
+  };
   for (let i = 0; i < visitors.length; i++) {
     const visitor = explode$1(visitors[i]);
     const state = states[i];
@@ -335,12 +335,7 @@ function merge(visitors, states = [], wrapper) {
       mergePair(nodeVisitor, typeVisitor);
     }
   }
-  {
-    return Object.assign({}, mergedVisitor, {
-      _exploded: true,
-      _verified: true
-    });
-  }
+  return mergedVisitor;
 }
 function wrapWithStateOrWrapper(oldVisitor, state, wrapper) {
   const newVisitor = {};
@@ -406,50 +401,40 @@ function mergePair(dest, src) {
     dest[phase] = [].concat(dest[phase] || [], src[phase]);
   }
 }
+const _environmentVisitor = {
+  FunctionParent(path) {
+    if (path.isArrowFunctionExpression()) return;
+    path.skip();
+    if (path.isMethod()) {
+      {
+        path.requeueComputedKeyAndDecorators();
+      }
+    }
+  },
+  Property(path) {
+    if (path.isObjectProperty()) return;
+    path.skip();
+    {
+      path.requeueComputedKeyAndDecorators();
+    }
+  }
+};
+function environmentVisitor(visitor) {
+  return merge([_environmentVisitor, visitor]);
+}
 
 var visitors = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  environmentVisitor: environmentVisitor,
   explode: explode$1,
   isExplodedVisitor: isExplodedVisitor,
   merge: merge,
   verify: verify$1
 });
 
-let pathsCache = new WeakMap();
-let scope = new WeakMap();
-function clear() {
-  clearPath();
-  clearScope();
-}
-function clearPath() {
-  pathsCache = new WeakMap();
-}
-function clearScope() {
-  scope = new WeakMap();
-}
-const nullHub = Object.freeze({});
-function getCachedPaths(hub, parent) {
-  return pathsCache.get(hub ?? nullHub)?.get(parent);
-}
-function getOrCreateCachedPaths(hub, parent) {
-  let parents = pathsCache.get(hub ?? nullHub);
-  if (!parents) pathsCache.set(hub ?? nullHub, parents = new WeakMap());
-  let paths = parents.get(parent);
-  if (!paths) parents.set(parent, paths = new Map());
-  return paths;
-}
-
-var cache = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  clear: clear,
-  clearPath: clearPath,
-  clearScope: clearScope,
-  getCachedPaths: getCachedPaths,
-  getOrCreateCachedPaths: getOrCreateCachedPaths,
-  get path () { return pathsCache; },
-  get scope () { return scope; }
-});
-
+const {
+  getAssignmentIdentifiers: getAssignmentIdentifiers$1
+} = _t;
 const renameVisitor = {
   ReferencedIdentifier({
     node
@@ -462,7 +447,9 @@ const renameVisitor = {
     if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
       path.skip();
       if (path.isMethod()) {
-        requeueComputedKeyAndDecorators(path);
+        {
+          path.requeueComputedKeyAndDecorators();
+        }
       }
     }
   },
@@ -479,7 +466,7 @@ const renameVisitor = {
   },
   "AssignmentExpression|Declaration|VariableDeclarator"(path, state) {
     if (path.isVariableDeclaration()) return;
-    const ids = path.getOuterBindingIdentifiers();
+    const ids = path.isAssignmentExpression() ? getAssignmentIdentifiers$1(path.node) : path.getOuterBindingIdentifiers();
     for (const name in ids) {
       if (name === state.oldName) ids[name].name = state.newName;
     }
@@ -507,7 +494,7 @@ class Renamer {
     if (maybeExportDeclar.isExportAllDeclaration()) {
       return;
     }
-    splitExportDeclaration(maybeExportDeclar);
+    maybeExportDeclar.splitExportDeclaration();
   }
   maybeConvertFromClassFunctionDeclaration(path) {
     return path;
@@ -533,9 +520,18 @@ class Renamer {
       }
     }
     const blockToTraverse = scope.block;
-    traverseNode(blockToTraverse, explode$1(renameVisitor), scope, this, scope.path, {
+    const skipKeys = {
       discriminant: true
-    });
+    };
+    if (_t.isMethod(blockToTraverse)) {
+      if (blockToTraverse.computed) {
+        skipKeys.key = true;
+      }
+      if (!_t.isObjectMethod(blockToTraverse)) {
+        skipKeys.decorators = true;
+      }
+    }
+    traverseNode(blockToTraverse, explode$1(renameVisitor), scope, this, scope.path, skipKeys);
     {
       scope.removeOwnBinding(oldName);
       scope.bindings[newName] = binding;
@@ -563,7 +559,7 @@ class Binding {
     this.scope = scope;
     this.path = path;
     this.kind = kind;
-    if ((kind === "var" || kind === "hoisted") && isDeclaredInLoop(path)) {
+    if ((kind === "var" || kind === "hoisted") && isInitInLoop(path)) {
       this.reassign(path);
     }
     this.clearValue();
@@ -589,13 +585,13 @@ class Binding {
   }
   reassign(path) {
     this.constant = false;
-    if (this.constantViolations.indexOf(path) !== -1) {
+    if (this.constantViolations.includes(path)) {
       return;
     }
     this.constantViolations.push(path);
   }
   reference(path) {
-    if (this.referencePaths.indexOf(path) !== -1) {
+    if (this.referencePaths.includes(path)) {
       return;
     }
     this.referenced = true;
@@ -607,24 +603,66 @@ class Binding {
     this.referenced = !!this.references;
   }
 }
-function isDeclaredInLoop(path) {
+function isInitInLoop(path) {
+  const isFunctionDeclarationOrHasInit = !path.isVariableDeclarator() || path.node.init;
   for (let {
     parentPath,
     key
-  } = path; parentPath; ({
+  } = path; parentPath; {
     parentPath,
     key
-  } = parentPath)) {
+  } = parentPath) {
     if (parentPath.isFunctionParent()) return false;
-    if (parentPath.isWhile() || parentPath.isForXStatement() || parentPath.isForStatement() && key === "body") {
+    if (key === "left" && parentPath.isForXStatement() || isFunctionDeclarationOrHasInit && key === "body" && parentPath.isLoop()) {
       return true;
     }
   }
   return false;
 }
 
+let pathsCache = new WeakMap();
+let scope = new WeakMap();
+function clear() {
+  clearPath();
+  clearScope();
+}
+function clearPath() {
+  pathsCache = new WeakMap();
+}
+function clearScope() {
+  scope = new WeakMap();
+}
+function getCachedPaths(path) {
+  const {
+    parent,
+    parentPath
+  } = path;
+  return parentPath ? parentPath._store : pathsCache.get(parent);
+}
+function getOrCreateCachedPaths(node, parentPath) {
+  if (parentPath) {
+    return parentPath._store ||= new Map();
+  }
+  let paths = pathsCache.get(node);
+  if (!paths) pathsCache.set(node, paths = new Map());
+  return paths;
+}
+
+var cache = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  clear: clear,
+  clearPath: clearPath,
+  clearScope: clearScope,
+  getCachedPaths: getCachedPaths,
+  getOrCreateCachedPaths: getOrCreateCachedPaths,
+  get path () { return pathsCache; },
+  get scope () { return scope; }
+});
+
+const globalsBuiltinLower = createRequire(import.meta.url)("@babel/helper-globals/data/builtin-lower.json"),
+  globalsBuiltinUpper = createRequire(import.meta.url)("@babel/helper-globals/data/builtin-upper.json");
 const {
-  NOT_LOCAL_BINDING,
+  assignmentExpression: assignmentExpression$3,
   callExpression: callExpression$3,
   cloneNode: cloneNode$3,
   getBindingIdentifiers: getBindingIdentifiers$3,
@@ -656,6 +694,7 @@ const {
   isThisExpression,
   isUnaryExpression,
   isVariableDeclaration: isVariableDeclaration$1,
+  expressionStatement: expressionStatement$3,
   matchesPattern: matchesPattern$1,
   memberExpression: memberExpression$1,
   numericLiteral: numericLiteral$2,
@@ -669,7 +708,8 @@ const {
   isMetaProperty,
   isPrivateName,
   isExportDeclaration,
-  buildUndefinedNode: buildUndefinedNode$1
+  buildUndefinedNode: buildUndefinedNode$1,
+  sequenceExpression: sequenceExpression$2
 } = _t;
 function gatherNodeParts(node, parts) {
   switch (node?.type) {
@@ -728,6 +768,7 @@ function gatherNodeParts(node, parts) {
       parts.push("super");
       break;
     case "Import":
+    case "ImportExpression":
       parts.push("import");
       break;
     case "DoExpression":
@@ -785,6 +826,14 @@ function gatherNodeParts(node, parts) {
       break;
   }
 }
+function resetScope(scope) {
+  if (scope.path.type === "Program") {
+    scope.referencesSet = new Set();
+    scope.uidsSet = new Set();
+  }
+  scope.bindings = Object.create(null);
+  scope.globals = Object.create(null);
+}
 const collectorVisitor = {
   ForStatement(path) {
     const declar = path.get("init");
@@ -807,7 +856,15 @@ const collectorVisitor = {
     const parent = path.scope.getBlockParent();
     parent.registerDeclaration(path);
   },
+  TSImportEqualsDeclaration(path) {
+    const parent = path.scope.getBlockParent();
+    parent.registerDeclaration(path);
+  },
   ReferencedIdentifier(path, state) {
+    if (_t.isTSQualifiedName(path.parent) && path.parent.right === path.node) {
+      return;
+    }
+    if (path.parentPath.isTSImportEqualsDeclaration()) return;
     state.references.push(path);
   },
   ForXStatement(path, state) {
@@ -878,30 +935,31 @@ const collectorVisitor = {
     for (const param of params) {
       path.scope.registerBinding("param", param);
     }
-    if (path.isFunctionExpression() && path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
+    if (path.isFunctionExpression() && path.node.id) {
       path.scope.registerBinding("local", path.get("id"), path);
     }
   },
   ClassExpression(path) {
-    if (path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
-      path.scope.registerBinding("local", path);
+    if (path.node.id) {
+      path.scope.registerBinding("local", path.get("id"), path);
     }
   },
   TSTypeAnnotation(path) {
     path.skip();
   }
 };
+let scopeVisitor;
 let uid = 0;
 class Scope {
   uid;
   path;
   block;
-  labels;
   inited;
+  labels;
   bindings;
-  references;
+  referencesSet;
   globals;
-  uids;
+  uidsSet;
   data;
   crawling;
   constructor(path) {
@@ -919,7 +977,7 @@ class Scope {
     this.labels = new Map();
     this.inited = false;
   }
-  static globals = Object.keys(globals.builtin);
+  static globals = [...globalsBuiltinLower, ...globalsBuiltinUpper];
   static contextVariables = ["arguments", "undefined", "Infinity", "NaN"];
   get parent() {
     let parent,
@@ -932,14 +990,11 @@ class Scope {
     } while (path && !parent);
     return parent?.scope;
   }
-  get parentBlock() {
-    return this.path.parent;
-  }
-  get hub() {
-    return this.path.hub;
+  get references() {
+    throw new Error("Scope#references is not available in Babel 8. Use Scope#referencesSet instead.");
   }
-  traverse(node, opts, state) {
-    traverse(node, opts, this, state, this.path);
+  get uids() {
+    throw new Error("Scope#uids is not available in Babel 8. Use Scope#uidsSet instead.");
   }
   generateDeclaredUidIdentifier(name) {
     const id = this.generateUidIdentifier(name);
@@ -952,23 +1007,21 @@ class Scope {
     return identifier$3(this.generateUid(name));
   }
   generateUid(name = "temp") {
-    name = toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
+    name = toIdentifier(name).replace(/^_+/, "").replace(/\d+$/g, "");
     let uid;
-    let i = 1;
+    let i = 0;
     do {
-      uid = this._generateUid(name, i);
+      uid = `_${name}`;
+      if (i >= 11) uid += i - 1;else if (i >= 9) uid += i - 9;else if (i >= 1) uid += i + 1;
       i++;
     } while (this.hasLabel(uid) || this.hasBinding(uid) || this.hasGlobal(uid) || this.hasReference(uid));
     const program = this.getProgramParent();
-    program.references[uid] = true;
-    program.uids[uid] = true;
+    {
+      program.referencesSet.add(uid);
+      program.uidsSet.add(uid);
+    }
     return uid;
   }
-  _generateUid(name, i) {
-    let id = name;
-    if (i > 1) id += i;
-    return `_${id}`;
-  }
   generateUidBasedOnNode(node, defaultName) {
     const parts = [];
     gatherNodeParts(node, parts);
@@ -1012,7 +1065,7 @@ class Scope {
     if (local.kind === "local") return;
     const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && kind === "const";
     if (duplicate) {
-      throw this.hub.buildError(id, `Duplicate declaration "${name}"`, TypeError);
+      throw this.path.hub.buildError(id, `Duplicate declaration "${name}"`, TypeError);
     }
   }
   rename(oldName, newName) {
@@ -1025,12 +1078,6 @@ class Scope {
       }
     }
   }
-  _renameFromMap(map, oldName, newName, value) {
-    if (map[oldName]) {
-      map[newName] = value;
-      map[oldName] = null;
-    }
-  }
   dump() {
     const sep = "-".repeat(60);
     console.log(sep);
@@ -1049,37 +1096,6 @@ class Scope {
     } while (scope = scope.parent);
     console.log(sep);
   }
-  toArray(node, i, arrayLikeIsIterable) {
-    if (isIdentifier$5(node)) {
-      const binding = this.getBinding(node.name);
-      if (binding?.constant && binding.path.isGenericType("Array")) {
-        return node;
-      }
-    }
-    if (isArrayExpression(node)) {
-      return node;
-    }
-    if (isIdentifier$5(node, {
-      name: "arguments"
-    })) {
-      return callExpression$3(memberExpression$1(memberExpression$1(memberExpression$1(identifier$3("Array"), identifier$3("prototype")), identifier$3("slice")), identifier$3("call")), [node]);
-    }
-    let helperName;
-    const args = [node];
-    if (i === true) {
-      helperName = "toConsumableArray";
-    } else if (typeof i === "number") {
-      args.push(numericLiteral$2(i));
-      helperName = "slicedToArray";
-    } else {
-      helperName = "toArray";
-    }
-    if (arrayLikeIsIterable) {
-      args.unshift(this.hub.addHelper(helperName));
-      helperName = "maybeArrayLike";
-    }
-    return callExpression$3(this.hub.addHelper(helperName), args);
-  }
   hasLabel(name) {
     return !!this.getLabel(name);
   }
@@ -1125,7 +1141,7 @@ class Scope {
     return buildUndefinedNode$1();
   }
   registerConstantViolation(path) {
-    const ids = path.getBindingIdentifiers();
+    const ids = path.getAssignmentIdentifiers();
     for (const name of Object.keys(ids)) {
       this.getBinding(name)?.reassign(path);
     }
@@ -1142,7 +1158,9 @@ class Scope {
     const parent = this.getProgramParent();
     const ids = path.getOuterBindingIdentifiers(true);
     for (const name of Object.keys(ids)) {
-      parent.references[name] = true;
+      {
+        parent.referencesSet.add(name);
+      }
       for (const id of ids[name]) {
         const local = this.getOwnBinding(name);
         if (local) {
@@ -1150,7 +1168,7 @@ class Scope {
           this.checkBlockScopedCollisions(local, kind, name, id);
         }
         if (local) {
-          this.registerConstantViolation(bindingPath);
+          local.reassign(bindingPath);
         } else {
           this.bindings[name] = new Binding({
             identifier: id,
@@ -1166,11 +1184,9 @@ class Scope {
     this.globals[node.name] = node;
   }
   hasUid(name) {
-    let scope = this;
-    do {
-      if (scope.uids[name]) return true;
-    } while (scope = scope.parent);
-    return false;
+    {
+      return this.getProgramParent().uidsSet.has(name);
+    }
   }
   hasGlobal(name) {
     let scope = this;
@@ -1180,7 +1196,9 @@ class Scope {
     return false;
   }
   hasReference(name) {
-    return !!this.getProgramParent().references[name];
+    {
+      return this.getProgramParent().referencesSet.has(name);
+    }
   }
   isPure(node, constantsOnly) {
     if (isIdentifier$5(node)) {
@@ -1280,34 +1298,42 @@ class Scope {
   }
   crawl() {
     const path = this.path;
-    this.references = Object.create(null);
-    this.bindings = Object.create(null);
-    this.globals = Object.create(null);
-    this.uids = Object.create(null);
+    resetScope(this);
     this.data = Object.create(null);
-    const programParent = this.getProgramParent();
-    if (programParent.crawling) return;
+    let scope = this;
+    do {
+      if (scope.crawling) return;
+      if (scope.path.isProgram()) {
+        break;
+      }
+    } while (scope = scope.parent);
+    const programParent = scope;
     const state = {
       references: [],
       constantViolations: [],
       assignments: []
     };
     this.crawling = true;
-    if (path.type !== "Program" && isExplodedVisitor(collectorVisitor)) {
-      for (const visit of collectorVisitor.enter) {
+    scopeVisitor ||= traverse.visitors.merge([{
+      Scope(path) {
+        resetScope(path.scope);
+      }
+    }, collectorVisitor]);
+    if (path.type !== "Program") {
+      for (const visit of scopeVisitor.enter) {
         visit.call(state, path, state);
       }
-      const typeVisitors = collectorVisitor[path.type];
+      const typeVisitors = scopeVisitor[path.type];
       if (typeVisitors) {
         for (const visit of typeVisitors.enter) {
           visit.call(state, path, state);
         }
       }
     }
-    path.traverse(collectorVisitor, state);
+    path.traverse(scopeVisitor, state);
     this.crawling = false;
     for (const path of state.assignments) {
-      const ids = path.getBindingIdentifiers();
+      const ids = path.getAssignmentIdentifiers();
       for (const name of Object.keys(ids)) {
         if (path.scope.getBinding(name)) continue;
         programParent.addGlobal(ids[name]);
@@ -1415,20 +1441,6 @@ class Scope {
     } while (scope);
     return ids;
   }
-  getAllBindingsOfKind(...kinds) {
-    const ids = Object.create(null);
-    for (const kind of kinds) {
-      let scope = this;
-      do {
-        for (const name of Object.keys(scope.bindings)) {
-          const binding = scope.bindings[name];
-          if (binding.kind === kind) ids[name] = binding;
-        }
-        scope = scope.parent;
-      } while (scope);
-    }
-    return ids;
-  }
   bindingIdentifierEquals(name, node) {
     return this.getBindingIdentifier(name) === node;
   }
@@ -1462,16 +1474,28 @@ class Scope {
   }
   hasBinding(name, opts) {
     if (!name) return false;
-    if (this.hasOwnBinding(name)) return true;
-    {
-      if (typeof opts === "boolean") opts = {
-        noGlobals: opts
-      };
+    let noGlobals;
+    let noUids;
+    let upToScope;
+    if (typeof opts === "object") {
+      noGlobals = opts.noGlobals;
+      noUids = opts.noUids;
+      upToScope = opts.upToScope;
+    } else if (typeof opts === "boolean") {
+      noGlobals = opts;
     }
-    if (this.parentHasBinding(name, opts)) return true;
-    if (!opts?.noUids && this.hasUid(name)) return true;
-    if (!opts?.noGlobals && Scope.globals.includes(name)) return true;
-    if (!opts?.noGlobals && Scope.contextVariables.includes(name)) return true;
+    let scope = this;
+    do {
+      if (upToScope === scope) {
+        break;
+      }
+      if (scope.hasOwnBinding(name)) {
+        return true;
+      }
+    } while (scope = scope.parent);
+    if (!noUids && this.hasUid(name)) return true;
+    if (!noGlobals && Scope.globals.includes(name)) return true;
+    if (!noGlobals && Scope.contextVariables.includes(name)) return true;
     return false;
   }
   parentHasBinding(name, opts) {
@@ -1490,12 +1514,57 @@ class Scope {
   }
   removeBinding(name) {
     this.getBinding(name)?.scope.removeOwnBinding(name);
-    let scope = this;
-    do {
-      if (scope.uids[name]) {
-        scope.uids[name] = false;
+    {
+      this.getProgramParent().uidsSet.delete(name);
+    }
+  }
+  hoistVariables(emit = id => this.push({
+    id
+  })) {
+    this.crawl();
+    const seen = new Set();
+    for (const name of Object.keys(this.bindings)) {
+      const binding = this.bindings[name];
+      if (!binding) continue;
+      const {
+        path
+      } = binding;
+      if (!path.isVariableDeclarator()) continue;
+      const {
+        parent,
+        parentPath
+      } = path;
+      if (parent.kind !== "var" || seen.has(parent)) continue;
+      seen.add(path.parent);
+      let firstId;
+      const init = [];
+      for (const decl of parent.declarations) {
+        firstId ??= decl.id;
+        if (decl.init) {
+          init.push(assignmentExpression$3("=", decl.id, decl.init));
+        }
+        const ids = Object.keys(getBindingIdentifiers$3(decl, false, true, true));
+        for (const name of ids) {
+          emit(identifier$3(name), decl.init != null);
+        }
       }
-    } while (scope = scope.parent);
+      if (parentPath.parentPath.isFor({
+        left: parent
+      })) {
+        parentPath.replaceWith(firstId);
+      } else if (init.length === 0) {
+        parentPath.remove();
+      } else {
+        const expr = init.length === 1 ? init[0] : sequenceExpression$2(init);
+        if (parentPath.parentPath.isForStatement({
+          init: parent
+        })) {
+          parentPath.replaceWith(expr);
+        } else {
+          parentPath.replaceWith(expressionStatement$3(expr));
+        }
+      }
+    }
   }
 }
 
@@ -1615,9 +1684,7 @@ function isDescendant(maybeAncestor) {
 function inType(...candidateTypes) {
   let path = this;
   while (path) {
-    for (const type of candidateTypes) {
-      if (path.node.type === type) return true;
-    }
+    if (candidateTypes.includes(path.node.type)) return true;
     path = path.parentPath;
   }
   return false;
@@ -1670,7 +1737,7 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
   const testType = getConditionalAnnotation(binding, path, name);
   if (testType) {
     const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
-    constantViolations = constantViolations.filter(path => testConstantViolations.indexOf(path) < 0);
+    constantViolations = constantViolations.filter(path => !testConstantViolations.includes(path));
     types.push(testType.typeAnnotation);
   }
   if (constantViolations.length) {
@@ -1712,7 +1779,7 @@ function inferAnnotationFromBinaryExpression(name, path) {
     if (operator === "===") {
       return target.getTypeAnnotation();
     }
-    if (BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    if (BOOLEAN_NUMBER_BINARY_OPERATORS.includes(operator)) {
       return numberTypeAnnotation$1();
     }
     return;
@@ -1830,19 +1897,19 @@ function UnaryExpression(node) {
   const operator = node.operator;
   if (operator === "void") {
     return voidTypeAnnotation$1();
-  } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
+  } else if (NUMBER_UNARY_OPERATORS.includes(operator)) {
     return numberTypeAnnotation();
-  } else if (STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
+  } else if (STRING_UNARY_OPERATORS.includes(operator)) {
     return stringTypeAnnotation$1();
-  } else if (BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
+  } else if (BOOLEAN_UNARY_OPERATORS.includes(operator)) {
     return booleanTypeAnnotation();
   }
 }
 function BinaryExpression(node) {
   const operator = node.operator;
-  if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+  if (NUMBER_BINARY_OPERATORS.includes(operator)) {
     return numberTypeAnnotation();
-  } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
+  } else if (BOOLEAN_BINARY_OPERATORS.includes(operator)) {
     return booleanTypeAnnotation();
   } else if (operator === "+") {
     const right = this.get("right");
@@ -2011,7 +2078,7 @@ function getTypeAnnotation() {
   if (type != null) {
     return type;
   }
-  type = this._getTypeAnnotation() || anyTypeAnnotation();
+  type = _getTypeAnnotation.call(this) || anyTypeAnnotation();
   if (isTypeAnnotation(type) || isTSTypeAnnotation(type)) {
     type = type.typeAnnotation;
   }
@@ -2118,42 +2185,323 @@ function isGenericType(genericName) {
   });
 }
 
+const hooks = [function (self, parent) {
+  const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
+  if (removeParent) {
+    parent.remove();
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
+    parent.replaceWith(parent.node.expressions[0]);
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isBinary()) {
+    if (self.key === "left") {
+      parent.replaceWith(parent.node.right);
+    } else {
+      parent.replaceWith(parent.node.left);
+    }
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isIfStatement() && self.key === "consequent" || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
+    self.replaceWith({
+      type: "BlockStatement",
+      body: []
+    });
+    return true;
+  }
+}];
+
+const {
+  getBindingIdentifiers: getBindingIdentifiers$2
+} = _t;
+function remove() {
+  _assertUnremoved.call(this);
+  resync.call(this);
+  if (_callRemovalHooks.call(this)) {
+    _markRemoved.call(this);
+    return;
+  }
+  if (!this.opts?.noScope) {
+    _removeFromScope.call(this);
+  }
+  this.shareCommentsWithSiblings();
+  _remove.call(this);
+  _markRemoved.call(this);
+}
+function _removeFromScope() {
+  const bindings = getBindingIdentifiers$2(this.node, false, false, true);
+  Object.keys(bindings).forEach(name => this.scope.removeBinding(name));
+}
+function _callRemovalHooks() {
+  if (this.parentPath) {
+    for (const fn of hooks) {
+      if (fn(this, this.parentPath)) return true;
+    }
+  }
+}
+function _remove() {
+  if (Array.isArray(this.container)) {
+    this.container.splice(this.key, 1);
+    updateSiblingKeys.call(this, this.key, -1);
+  } else {
+    _replaceWith.call(this, null);
+  }
+}
+function _markRemoved() {
+  this._traverseFlags |= SHOULD_SKIP | REMOVED;
+  if (this.parent) {
+    getCachedPaths(this)?.delete(this.node);
+  }
+  this.node = null;
+}
+function _assertUnremoved() {
+  if (this.removed) {
+    throw this.buildCodeFrameError("NodePath has been removed so is read-only.");
+  }
+}
+
 const {
-  FUNCTION_TYPES,
   arrowFunctionExpression: arrowFunctionExpression$2,
+  assertExpression,
   assignmentExpression: assignmentExpression$2,
-  awaitExpression,
   blockStatement: blockStatement$2,
-  buildUndefinedNode,
   callExpression: callExpression$2,
   cloneNode: cloneNode$2,
-  conditionalExpression: conditionalExpression$1,
   expressionStatement: expressionStatement$2,
-  getBindingIdentifiers: getBindingIdentifiers$2,
-  identifier: identifier$1,
-  inheritLeadingComments,
-  inheritTrailingComments,
-  inheritsComments,
-  isBlockStatement: isBlockStatement$1,
-  isEmptyStatement,
+  isAssignmentExpression,
+  isCallExpression,
+  isExportNamedDeclaration,
   isExpression: isExpression$2,
-  isExpressionStatement,
-  isIfStatement,
-  isProgram,
-  isStatement,
-  isVariableDeclaration,
-  removeComments,
-  returnStatement: returnStatement$1,
-  sequenceExpression: sequenceExpression$1,
-  validate: validate$1,
-  yieldExpression
-} = _t;
+  isIdentifier: isIdentifier$2,
+  isSequenceExpression,
+  isSuper,
+  thisExpression: thisExpression$1
+} = _t;
+function insertBefore(nodes_) {
+  _assertUnremoved.call(this);
+  const nodes = _verifyNodeList.call(this, nodes_);
+  const {
+    parentPath,
+    parent
+  } = this;
+  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
+    return parentPath.insertBefore(nodes);
+  } else if (this.isNodeType("Expression") && !this.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
+    if (this.node) nodes.push(this.node);
+    return this.replaceExpressionWithStatements(nodes);
+  } else if (Array.isArray(this.container)) {
+    return _containerInsertBefore.call(this, nodes);
+  } else if (this.isStatementOrBlock()) {
+    const node = this.node;
+    const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
+    this.replaceWith(blockStatement$2(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?");
+  }
+}
+function _containerInsert(from, nodes) {
+  updateSiblingKeys.call(this, from, nodes.length);
+  const paths = [];
+  this.container.splice(from, 0, ...nodes);
+  for (let i = 0; i < nodes.length; i++) {
+    const to = from + i;
+    const path = this.getSibling(to);
+    paths.push(path);
+    if (this.context?.queue) {
+      pushContext.call(path, this.context);
+    }
+  }
+  const contexts = _getQueueContexts.call(this);
+  for (const path of paths) {
+    setScope.call(path);
+    path.debug("Inserted.");
+    for (const context of contexts) {
+      context.maybeQueue(path, true);
+    }
+  }
+  return paths;
+}
+function _containerInsertBefore(nodes) {
+  return _containerInsert.call(this, this.key, nodes);
+}
+function _containerInsertAfter(nodes) {
+  return _containerInsert.call(this, this.key + 1, nodes);
+}
+const last = arr => arr[arr.length - 1];
+function isHiddenInSequenceExpression(path) {
+  return isSequenceExpression(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath));
+}
+function isAlmostConstantAssignment(node, scope) {
+  if (!isAssignmentExpression(node) || !isIdentifier$2(node.left)) {
+    return false;
+  }
+  const blockScope = scope.getBlockParent();
+  return blockScope.hasOwnBinding(node.left.name) && blockScope.getOwnBinding(node.left.name).constantViolations.length <= 1;
+}
+function insertAfter(nodes_) {
+  _assertUnremoved.call(this);
+  if (this.isSequenceExpression()) {
+    return last(this.get("expressions")).insertAfter(nodes_);
+  }
+  const nodes = _verifyNodeList.call(this, nodes_);
+  const {
+    parentPath,
+    parent
+  } = this;
+  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
+    return parentPath.insertAfter(nodes.map(node => {
+      return isExpression$2(node) ? expressionStatement$2(node) : node;
+    }));
+  } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
+    const self = this;
+    if (self.node) {
+      const node = self.node;
+      let {
+        scope
+      } = this;
+      if (scope.path.isPattern()) {
+        assertExpression(node);
+        self.replaceWith(callExpression$2(arrowFunctionExpression$2([], node), []));
+        self.get("callee.body").insertAfter(nodes);
+        return [self];
+      }
+      if (isHiddenInSequenceExpression(self)) {
+        nodes.unshift(node);
+      } else if (isCallExpression(node) && isSuper(node.callee)) {
+        nodes.unshift(node);
+        nodes.push(thisExpression$1());
+      } else if (isAlmostConstantAssignment(node, scope)) {
+        nodes.unshift(node);
+        nodes.push(cloneNode$2(node.left));
+      } else if (scope.isPure(node, true)) {
+        nodes.push(node);
+      } else {
+        if (parentPath.isMethod({
+          computed: true,
+          key: node
+        })) {
+          scope = scope.parent;
+        }
+        const temp = scope.generateDeclaredUidIdentifier();
+        nodes.unshift(expressionStatement$2(assignmentExpression$2("=", cloneNode$2(temp), node)));
+        nodes.push(expressionStatement$2(cloneNode$2(temp)));
+      }
+    }
+    return this.replaceExpressionWithStatements(nodes);
+  } else if (Array.isArray(this.container)) {
+    return _containerInsertAfter.call(this, nodes);
+  } else if (this.isStatementOrBlock()) {
+    const node = this.node;
+    const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
+    this.replaceWith(blockStatement$2(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?");
+  }
+}
+function updateSiblingKeys(fromIndex, incrementBy) {
+  if (!this.parent) return;
+  const paths = getCachedPaths(this);
+  if (!paths) return;
+  for (const [, path] of paths) {
+    if (typeof path.key === "number" && path.container === this.container && path.key >= fromIndex) {
+      path.key += incrementBy;
+    }
+  }
+}
+function _verifyNodeList(nodes) {
+  if (!nodes) {
+    return [];
+  }
+  if (!Array.isArray(nodes)) {
+    nodes = [nodes];
+  }
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    let msg;
+    if (!node) {
+      msg = "has falsy node";
+    } else if (typeof node !== "object") {
+      msg = "contains a non-object node";
+    } else if (!node.type) {
+      msg = "without a type";
+    } else if (node instanceof NodePath_Final) {
+      msg = "has a NodePath when it expected a raw object";
+    }
+    if (msg) {
+      const type = Array.isArray(node) ? "array" : typeof node;
+      throw new Error(`Node list ${msg} with the index of ${i} and type of ${type}`);
+    }
+  }
+  return nodes;
+}
+function unshiftContainer(listKey, nodes) {
+  _assertUnremoved.call(this);
+  nodes = _verifyNodeList.call(this, nodes);
+  const path = NodePath_Final.get({
+    parentPath: this,
+    parent: this.node,
+    container: this.node[listKey],
+    listKey,
+    key: 0
+  }).setContext(this.context);
+  return _containerInsertBefore.call(path, nodes);
+}
+function pushContainer(listKey, nodes) {
+  _assertUnremoved.call(this);
+  const verifiedNodes = _verifyNodeList.call(this, nodes);
+  const container = this.node[listKey];
+  const path = NodePath_Final.get({
+    parentPath: this,
+    parent: this.node,
+    container: container,
+    listKey,
+    key: container.length
+  }).setContext(this.context);
+  return path.replaceWithMultiple(verifiedNodes);
+}
+
+const {
+  FUNCTION_TYPES,
+  arrowFunctionExpression: arrowFunctionExpression$1,
+  assignmentExpression: assignmentExpression$1,
+  awaitExpression,
+  blockStatement: blockStatement$1,
+  buildUndefinedNode,
+  callExpression: callExpression$1,
+  cloneNode: cloneNode$1,
+  conditionalExpression: conditionalExpression$1,
+  expressionStatement: expressionStatement$1,
+  getBindingIdentifiers: getBindingIdentifiers$1,
+  identifier: identifier$1,
+  inheritLeadingComments,
+  inheritTrailingComments,
+  inheritsComments,
+  isBlockStatement: isBlockStatement$1,
+  isEmptyStatement,
+  isExpression: isExpression$1,
+  isExpressionStatement,
+  isIfStatement,
+  isProgram,
+  isStatement,
+  isVariableDeclaration,
+  removeComments,
+  returnStatement: returnStatement$1,
+  sequenceExpression: sequenceExpression$1,
+  validate: validate$1,
+  yieldExpression
+} = _t;
 function replaceWithMultiple(nodes) {
-  this.resync();
-  nodes = this._verifyNodeList(nodes);
+  resync.call(this);
+  nodes = _verifyNodeList.call(this, nodes);
   inheritLeadingComments(nodes[0], this.node);
   inheritTrailingComments(nodes[nodes.length - 1], this.node);
-  getCachedPaths(this.hub, this.parent)?.delete(this.node);
+  getCachedPaths(this)?.delete(this.node);
   this.node = this.container[this.key] = null;
   const paths = this.insertAfter(nodes);
   if (this.node) {
@@ -2164,7 +2512,7 @@ function replaceWithMultiple(nodes) {
   return paths;
 }
 function replaceWithSourceString(replacement) {
-  this.resync();
+  resync.call(this);
   let ast;
   try {
     replacement = `(${replacement})`;
@@ -2187,7 +2535,7 @@ function replaceWithSourceString(replacement) {
   return this.replaceWith(expressionAST);
 }
 function replaceWith(replacementPath) {
-  this.resync();
+  resync.call(this);
   if (this.removed) {
     throw new Error("You can't replace this node, we've already removed it");
   }
@@ -2208,9 +2556,9 @@ function replaceWith(replacementPath) {
     throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
   }
   let nodePath = "";
-  if (this.isNodeType("Statement") && isExpression$2(replacement)) {
+  if (this.isNodeType("Statement") && isExpression$1(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
-      replacement = expressionStatement$2(replacement);
+      replacement = expressionStatement$1(replacement);
       nodePath = "expression";
     }
   }
@@ -2224,9 +2572,9 @@ function replaceWith(replacementPath) {
     inheritsComments(replacement, oldNode);
     removeComments(oldNode);
   }
-  this._replaceWith(replacement);
+  _replaceWith.call(this, replacement);
   this.type = replacement.type;
-  this.setScope();
+  setScope.call(this);
   this.requeue();
   return [nodePath ? this.get(nodePath) : this];
 }
@@ -2240,11 +2588,11 @@ function _replaceWith(node) {
     validate$1(this.parent, this.key, node);
   }
   this.debug(`Replace with ${node?.type}`);
-  getCachedPaths(this.hub, this.parent)?.set(node, this).delete(this.node);
+  getCachedPaths(this)?.set(node, this).delete(this.node);
   this.node = this.container[this.key] = node;
 }
 function replaceExpressionWithStatements(nodes) {
-  this.resync();
+  resync.call(this);
   const declars = [];
   const nodesAsSingleExpression = gatherSequenceExpressions(nodes, declars);
   if (nodesAsSingleExpression) {
@@ -2254,17 +2602,15 @@ function replaceExpressionWithStatements(nodes) {
     return this.replaceWith(nodesAsSingleExpression)[0].get("expressions");
   }
   const functionParent = this.getFunctionParent();
-  const isParentAsync = functionParent?.is("async");
-  const isParentGenerator = functionParent?.is("generator");
-  const container = arrowFunctionExpression$2([], blockStatement$2(nodes));
-  this.replaceWith(callExpression$2(container, []));
+  const isParentAsync = functionParent?.node.async;
+  const isParentGenerator = functionParent?.node.generator;
+  const container = arrowFunctionExpression$1([], blockStatement$1(nodes));
+  this.replaceWith(callExpression$1(container, []));
   const callee = this.get("callee");
-  hoistVariables(callee.get("body"), id => {
-    this.scope.push({
-      id
-    });
-  }, "var");
-  const completionRecords = this.get("callee").getCompletionRecords();
+  callee.get("body").scope.hoistVariables(id => this.scope.push({
+    id
+  }));
+  const completionRecords = callee.getCompletionRecords();
   for (const path of completionRecords) {
     if (!path.isExpressionStatement()) continue;
     const loop = path.findParent(path => path.isLoop());
@@ -2272,12 +2618,12 @@ function replaceExpressionWithStatements(nodes) {
       let uid = loop.getData("expressionReplacementReturnUid");
       if (!uid) {
         uid = callee.scope.generateDeclaredUidIdentifier("ret");
-        callee.get("body").pushContainer("body", returnStatement$1(cloneNode$2(uid)));
+        callee.get("body").pushContainer("body", returnStatement$1(cloneNode$1(uid)));
         loop.setData("expressionReplacementReturnUid", uid);
       } else {
         uid = identifier$1(uid.name);
       }
-      path.get("expression").replaceWith(assignmentExpression$2("=", cloneNode$2(uid), path.node.expression));
+      path.get("expression").replaceWith(assignmentExpression$1("=", cloneNode$1(uid), path.node.expression));
     } else {
       path.replaceWith(returnStatement$1(path.node.expression));
     }
@@ -2305,19 +2651,19 @@ function gatherSequenceExpressions(nodes, declars) {
     if (!isEmptyStatement(node)) {
       ensureLastUndefined = false;
     }
-    if (isExpression$2(node)) {
+    if (isExpression$1(node)) {
       exprs.push(node);
     } else if (isExpressionStatement(node)) {
       exprs.push(node.expression);
     } else if (isVariableDeclaration(node)) {
       if (node.kind !== "var") return;
       for (const declar of node.declarations) {
-        const bindings = getBindingIdentifiers$2(declar);
+        const bindings = getBindingIdentifiers$1(declar);
         for (const key of Object.keys(bindings)) {
-          declars.push(cloneNode$2(bindings[key]));
+          declars.push(cloneNode$1(bindings[key]));
         }
         if (declar.init) {
-          exprs.push(assignmentExpression$2("=", declar.id, declar.init));
+          exprs.push(assignmentExpression$1("=", declar.id, declar.init));
         }
       }
       ensureLastUndefined = true;
@@ -2346,11 +2692,11 @@ function gatherSequenceExpressions(nodes, declars) {
   }
 }
 function replaceInline(nodes) {
-  this.resync();
+  resync.call(this);
   if (Array.isArray(nodes)) {
     if (Array.isArray(this.container)) {
-      nodes = this._verifyNodeList(nodes);
-      const paths = this._containerInsertAfter(nodes);
+      nodes = _verifyNodeList.call(this, nodes);
+      const paths = _containerInsertAfter.call(this, nodes);
       this.remove();
       return paths;
     } else {
@@ -2477,6 +2823,22 @@ function _evaluate(path, state) {
         deopt(binding.path, state);
         return;
       }
+      const bindingPathScope = binding.path.scope;
+      if (binding.kind === "var" && bindingPathScope !== binding.scope) {
+        let hasUnsafeBlock = !bindingPathScope.path.parentPath.isBlockStatement();
+        for (let scope = bindingPathScope.parent; scope; scope = scope.parent) {
+          if (scope === path.scope) {
+            if (hasUnsafeBlock) {
+              deopt(binding.path, state);
+              return;
+            }
+            break;
+          }
+          if (scope.path.parentPath?.isBlockStatement()) {
+            hasUnsafeBlock = true;
+          }
+        }
+      }
       if (binding.hasValue) {
         return binding.value;
       }
@@ -2493,9 +2855,13 @@ function _evaluate(path, state) {
     if (resolved === path) {
       deopt(path, state);
       return;
-    } else {
-      return evaluateCached(resolved, state);
     }
+    const value = evaluateCached(resolved, state);
+    if (typeof value === "object" && value !== null && binding.references > 1) {
+      deopt(resolved, state);
+      return;
+    }
+    return value;
   }
   if (path.isUnaryExpression({
     prefix: true
@@ -2701,15 +3067,15 @@ function evaluate() {
 }
 
 const {
-  arrowFunctionExpression: arrowFunctionExpression$1,
-  assignmentExpression: assignmentExpression$1,
+  arrowFunctionExpression,
+  assignmentExpression,
   binaryExpression,
-  blockStatement: blockStatement$1,
-  callExpression: callExpression$1,
+  blockStatement,
+  callExpression,
   conditionalExpression,
-  expressionStatement: expressionStatement$1,
+  expressionStatement,
   identifier,
-  isIdentifier: isIdentifier$2,
+  isIdentifier: isIdentifier$1,
   jsxIdentifier,
   logicalExpression,
   LOGICAL_OPERATORS,
@@ -2723,9 +3089,20 @@ const {
   spreadElement,
   stringLiteral,
   super: _super,
-  thisExpression: thisExpression$1,
+  thisExpression,
   toExpression,
-  unaryExpression: unaryExpression$1
+  unaryExpression: unaryExpression$1,
+  toBindingIdentifierName,
+  isFunction,
+  isAssignmentPattern,
+  isRestElement,
+  getFunctionName,
+  cloneNode,
+  variableDeclaration,
+  variableDeclarator,
+  exportNamedDeclaration,
+  exportSpecifier,
+  inherits
 } = _t;
 function toComputedKey() {
   let key;
@@ -2737,7 +3114,7 @@ function toComputedKey() {
     throw new ReferenceError("todo");
   }
   if (!this.node.computed) {
-    if (isIdentifier$2(key)) key = stringLiteral(key.name);
+    if (isIdentifier$1(key)) key = stringLiteral(key.name);
   }
   return key;
 }
@@ -2768,12 +3145,12 @@ function ensureBlock() {
       statements.push(returnStatement(body.node));
     } else {
       key = "expression";
-      statements.push(expressionStatement$1(body.node));
+      statements.push(expressionStatement(body.node));
     }
   }
-  this.node.body = blockStatement$1(statements);
+  this.node.body = blockStatement(statements);
   const parentPath = this.get(stringPath);
-  body.setup(parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
+  setup.call(body, parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
   return this.node;
 }
 function unwrapFunctionEnvironment() {
@@ -2793,10 +3170,14 @@ function arrowFunctionToExpression({
   if (!this.isArrowFunctionExpression()) {
     throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
   }
+  let self = this;
+  if (!noNewArrows) {
+    self = self.ensureFunctionName(false) ?? self;
+  }
   const {
     thisBinding,
     fnPath: fn
-  } = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow, allowInsertArrowWithRest);
+  } = hoistFunctionEnvironment(self, noNewArrows, allowInsertArrow, allowInsertArrowWithRest);
   fn.ensureBlock();
   setType(fn, "FunctionExpression");
   if (!noNewArrows) {
@@ -2807,20 +3188,20 @@ function arrowFunctionToExpression({
         init: objectExpression([])
       });
     }
-    fn.get("body").unshiftContainer("body", expressionStatement$1(callExpression$1(this.hub.addHelper("newArrowCheck"), [thisExpression$1(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)])));
-    fn.replaceWith(callExpression$1(memberExpression(nameFunction(this, true) || fn.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression$1()]));
+    fn.get("body").unshiftContainer("body", expressionStatement(callExpression(this.hub.addHelper("newArrowCheck"), [thisExpression(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)])));
+    fn.replaceWith(callExpression(memberExpression(fn.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression()]));
     return fn.get("callee.object");
   }
   return fn;
 }
-const getSuperCallsVisitor = merge([{
+const getSuperCallsVisitor = environmentVisitor({
   CallExpression(child, {
     allSuperCalls
   }) {
     if (!child.get("callee").isSuper()) return;
     allSuperCalls.push(child);
   }
-}, environmentVisitor]);
+});
 function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow = true, allowInsertArrowWithRest = true) {
   let arrowParent;
   let thisEnvFn = fnPath.findParent(p => {
@@ -2841,7 +3222,7 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
     if (arrowParent) {
       thisEnvFn = arrowParent;
     } else if (allowInsertArrow) {
-      fnPath.replaceWith(callExpression$1(arrowFunctionExpression$1([], toExpression(fnPath.node)), []));
+      fnPath.replaceWith(callExpression(arrowFunctionExpression([], toExpression(fnPath.node)), []));
       thisEnvFn = fnPath.get("callee");
       fnPath = thisEnvFn.get("body");
     } else {
@@ -2922,15 +3303,15 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
         const value = superParentPath.node.right;
         args.push(value);
       }
-      const call = callExpression$1(identifier(superBinding), args);
+      const call = callExpression(identifier(superBinding), args);
       if (isCall) {
-        superParentPath.unshiftContainer("arguments", thisExpression$1());
+        superParentPath.unshiftContainer("arguments", thisExpression());
         superProp.replaceWith(memberExpression(call, identifier("call")));
         thisPaths.push(superParentPath.get("arguments.0"));
       } else if (isAssignment) {
         superParentPath.replaceWith(call);
       } else if (isTaggedTemplate) {
-        superProp.replaceWith(callExpression$1(memberExpression(call, identifier("bind"), false), [thisExpression$1()]));
+        superProp.replaceWith(callExpression(memberExpression(call, identifier("bind"), false), [thisExpression()]));
         thisPaths.push(superProp.get("arguments.0"));
       } else {
         superProp.replaceWith(call);
@@ -2967,7 +3348,7 @@ function standardizeSuperProperty(superProp) {
       const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
       const object = superProp.node.object;
       const property = superProp.node.property;
-      assignmentPath.get("left").replaceWith(memberExpression(object, assignmentExpression$1("=", tmp, property), true));
+      assignmentPath.get("left").replaceWith(memberExpression(object, assignmentExpression("=", tmp, property), true));
       assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(tmp.name), true), value));
     } else {
       const object = superProp.node.object;
@@ -2985,7 +3366,7 @@ function standardizeSuperProperty(superProp) {
     const updateExpr = superProp.parentPath;
     const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
     const computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
-    const parts = [assignmentExpression$1("=", tmp, memberExpression(superProp.node.object, computedKey ? assignmentExpression$1("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression$1("=", memberExpression(superProp.node.object, computedKey ? identifier(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression(superProp.parentPath.node.operator[0], identifier(tmp.name), numericLiteral$1(1)))];
+    const parts = [assignmentExpression("=", tmp, memberExpression(superProp.node.object, computedKey ? assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression("=", memberExpression(superProp.node.object, computedKey ? identifier(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression(superProp.parentPath.node.operator[0], identifier(tmp.name), numericLiteral$1(1)))];
     if (!superProp.parentPath.node.prefix) {
       parts.push(identifier(tmp.name));
     }
@@ -2997,7 +3378,7 @@ function standardizeSuperProperty(superProp) {
   return [superProp];
   function rightExpression(op, left, right) {
     if (op === "=") {
-      return assignmentExpression$1("=", left, right);
+      return assignmentExpression("=", left, right);
     } else {
       return binaryExpression(op, left, right);
     }
@@ -3006,7 +3387,7 @@ function standardizeSuperProperty(superProp) {
 function hasSuperClass(thisEnvFn) {
   return thisEnvFn.isClassMethod() && !!thisEnvFn.parentPath.parentPath.node.superClass;
 }
-const assignSuperThisVisitor = merge([{
+const assignSuperThisVisitor = environmentVisitor({
   CallExpression(child, {
     supers,
     thisBinding
@@ -3014,12 +3395,12 @@ const assignSuperThisVisitor = merge([{
     if (!child.get("callee").isSuper()) return;
     if (supers.has(child.node)) return;
     supers.add(child.node);
-    child.replaceWithMultiple([child.node, assignmentExpression$1("=", identifier(thisBinding), identifier("this"))]);
+    child.replaceWithMultiple([child.node, assignmentExpression("=", identifier(thisBinding), identifier("this"))]);
   }
-}, environmentVisitor]);
+});
 function getThisBinding(thisEnvFn, inConstructor) {
   return getBinding(thisEnvFn, "this", thisBinding => {
-    if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression$1();
+    if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();
     thisEnvFn.traverse(assignSuperThisVisitor, {
       supers: new WeakSet(),
       thisBinding
@@ -3029,7 +3410,7 @@ function getThisBinding(thisEnvFn, inConstructor) {
 function getSuperBinding(thisEnvFn) {
   return getBinding(thisEnvFn, "supercall", () => {
     const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
-    return arrowFunctionExpression$1([restElement(argsBinding)], callExpression$1(_super(), [spreadElement(identifier(argsBinding.name))]));
+    return arrowFunctionExpression([restElement(argsBinding)], callExpression(_super(), [spreadElement(identifier(argsBinding.name))]));
   });
 }
 function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
@@ -3047,9 +3428,9 @@ function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
     if (isAssignment) {
       const valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
       argsList.push(valueIdent);
-      fnBody = assignmentExpression$1("=", fnBody, identifier(valueIdent.name));
+      fnBody = assignmentExpression("=", fnBody, identifier(valueIdent.name));
     }
-    return arrowFunctionExpression$1(argsList, fnBody);
+    return arrowFunctionExpression(argsList, fnBody);
   });
 }
 function getBinding(thisEnvFn, key, init) {
@@ -3066,7 +3447,7 @@ function getBinding(thisEnvFn, key, init) {
   }
   return data;
 }
-const getScopeInformationVisitor = merge([{
+const getScopeInformationVisitor = environmentVisitor({
   ThisExpression(child, {
     thisPaths
   }) {
@@ -3124,7 +3505,7 @@ const getScopeInformationVisitor = merge([{
     })) return;
     newTargetPaths.push(child);
   }
-}, environmentVisitor]);
+});
 function getScopeInformation(fnPath) {
   const thisPaths = [];
   const argumentsPaths = [];
@@ -3146,53 +3527,165 @@ function getScopeInformation(fnPath) {
     superCalls
   };
 }
-
-const {
-  STATEMENT_OR_BLOCK_KEYS,
-  VISITOR_KEYS: VISITOR_KEYS$3,
-  isBlockStatement,
-  isExpression: isExpression$1,
-  isIdentifier: isIdentifier$1,
-  isLiteral,
-  isStringLiteral,
-  isType,
-  matchesPattern: _matchesPattern
-} = _t;
-function matchesPattern(pattern, allowPartial) {
-  return _matchesPattern(this.node, pattern, allowPartial);
-}
-function has(key) {
-  const val = this.node?.[key];
-  if (val && Array.isArray(val)) {
-    return !!val.length;
-  } else {
-    return !!val;
+function splitExportDeclaration() {
+  if (!this.isExportDeclaration() || this.isExportAllDeclaration()) {
+    throw new Error("Only default and named export declarations can be split.");
+  }
+  if (this.isExportNamedDeclaration() && this.get("specifiers").length > 0) {
+    throw new Error("It doesn't make sense to split exported specifiers.");
+  }
+  const declaration = this.get("declaration");
+  if (this.isExportDefaultDeclaration()) {
+    const standaloneDeclaration = declaration.isFunctionDeclaration() || declaration.isClassDeclaration();
+    const exportExpr = declaration.isFunctionExpression() || declaration.isClassExpression();
+    const scope = declaration.isScope() ? declaration.scope.parent : declaration.scope;
+    let id = declaration.node.id;
+    let needBindingRegistration = false;
+    if (!id) {
+      needBindingRegistration = true;
+      id = scope.generateUidIdentifier("default");
+      if (standaloneDeclaration || exportExpr) {
+        declaration.node.id = cloneNode(id);
+      }
+    } else if (exportExpr && scope.hasBinding(id.name)) {
+      needBindingRegistration = true;
+      id = scope.generateUidIdentifier(id.name);
+    }
+    const updatedDeclaration = standaloneDeclaration ? declaration.node : variableDeclaration("var", [variableDeclarator(cloneNode(id), declaration.node)]);
+    const updatedExportDeclaration = exportNamedDeclaration(null, [exportSpecifier(cloneNode(id), identifier("default"))]);
+    this.insertAfter(updatedExportDeclaration);
+    this.replaceWith(updatedDeclaration);
+    if (needBindingRegistration) {
+      scope.registerDeclaration(this);
+    }
+    return this;
+  } else if (this.get("specifiers").length > 0) {
+    throw new Error("It doesn't make sense to split exported specifiers.");
   }
+  const bindingIdentifiers = declaration.getOuterBindingIdentifiers();
+  const specifiers = Object.keys(bindingIdentifiers).map(name => {
+    return exportSpecifier(identifier(name), identifier(name));
+  });
+  const aliasDeclar = exportNamedDeclaration(null, specifiers);
+  this.insertAfter(aliasDeclar);
+  this.replaceWith(declaration.node);
+  return this;
 }
-function isStatic() {
-  return this.scope.isStatic(this.node);
-}
-const is = has;
-function isnt(key) {
-  return !this.has(key);
-}
-function equals(key, value) {
-  return this.node[key] === value;
-}
-function isNodeType(type) {
-  return isType(this.type, type);
-}
-function canHaveVariableDeclarationOrExpression() {
-  return (this.key === "init" || this.key === "left") && this.parentPath.isFor();
-}
-function canSwapBetweenExpressionAndStatement(replacement) {
-  if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) {
-    return false;
-  }
-  if (this.isExpression()) {
+const refersOuterBindingVisitor = {
+  "ReferencedIdentifier|BindingIdentifier"(path, state) {
+    if (path.node.name !== state.name) return;
+    state.needsRename = true;
+    path.stop();
+  },
+  Scope(path, state) {
+    if (path.scope.hasOwnBinding(state.name)) {
+      path.skip();
+    }
+  }
+};
+function ensureFunctionName(supportUnicodeId) {
+  if (this.node.id) return this;
+  const res = getFunctionName(this.node, this.parent);
+  if (res == null) return this;
+  let {
+    name
+  } = res;
+  if (!supportUnicodeId && /[\uD800-\uDFFF]/.test(name)) {
+    return null;
+  }
+  if (name.startsWith("get ") || name.startsWith("set ")) {
+    return null;
+  }
+  name = toBindingIdentifierName(name.replace(/[/ ]/g, "_"));
+  const id = identifier(name);
+  inherits(id, res.originalNode);
+  const state = {
+    needsRename: false,
+    name
+  };
+  const {
+    scope
+  } = this;
+  const binding = scope.getOwnBinding(name);
+  if (binding) {
+    if (binding.kind === "param") {
+      state.needsRename = true;
+    }
+  } else if (scope.parent.hasBinding(name) || scope.hasGlobal(name)) {
+    this.traverse(refersOuterBindingVisitor, state);
+  }
+  if (!state.needsRename) {
+    this.node.id = id;
+    {
+      scope.getProgramParent().referencesSet.add(id.name);
+    }
+    return this;
+  }
+  if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
+    scope.rename(id.name);
+    this.node.id = id;
+    {
+      scope.getProgramParent().referencesSet.add(id.name);
+    }
+    return this;
+  }
+  if (!isFunction(this.node)) return null;
+  const key = scope.generateUidIdentifier(id.name);
+  const params = [];
+  for (let i = 0, len = getFunctionArity(this.node); i < len; i++) {
+    params.push(scope.generateUidIdentifier("x"));
+  }
+  const call = template.expression.ast`
+    (function (${key}) {
+      function ${id}(${params}) {
+        return ${cloneNode(key)}.apply(this, arguments);
+      }
+
+      ${cloneNode(id)}.toString = function () {
+        return ${cloneNode(key)}.toString();
+      }
+
+      return ${cloneNode(id)};
+    })(${toExpression(this.node)})
+  `;
+  return this.replaceWith(call)[0].get("arguments.0");
+}
+function getFunctionArity(node) {
+  const count = node.params.findIndex(param => isAssignmentPattern(param) || isRestElement(param));
+  return count === -1 ? node.params.length : count;
+}
+
+const {
+  STATEMENT_OR_BLOCK_KEYS,
+  VISITOR_KEYS: VISITOR_KEYS$3,
+  isBlockStatement,
+  isExpression,
+  isIdentifier,
+  isLiteral,
+  isStringLiteral,
+  isType,
+  matchesPattern: _matchesPattern
+} = _t;
+function matchesPattern(pattern, allowPartial) {
+  return _matchesPattern(this.node, pattern, allowPartial);
+}
+function isStatic() {
+  return this.scope.isStatic(this.node);
+}
+function isNodeType(type) {
+  return isType(this.type, type);
+}
+function canHaveVariableDeclarationOrExpression() {
+  return (this.key === "init" || this.key === "left") && this.parentPath.isFor();
+}
+function canSwapBetweenExpressionAndStatement(replacement) {
+  if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) {
+    return false;
+  }
+  if (this.isExpression()) {
     return isBlockStatement(replacement);
   } else if (this.isBlockStatement()) {
-    return isExpression$1(replacement);
+    return isExpression(replacement);
   }
   return false;
 }
@@ -3247,7 +3740,7 @@ function referencesImport(moduleSource, importName) {
   if (path.isImportNamespaceSpecifier() && importName === "*") {
     return true;
   }
-  if (path.isImportSpecifier() && isIdentifier$1(path.node.imported, {
+  if (path.isImportSpecifier() && isIdentifier(path.node.imported, {
     name: importName
   })) {
     return true;
@@ -3321,8 +3814,8 @@ function _guessExecutionStatusRelativeToCached(base, target, cache) {
     target: target.getAncestry(),
     this: base.getAncestry()
   };
-  if (paths.target.indexOf(base) >= 0) return "after";
-  if (paths.this.indexOf(target) >= 0) return "before";
+  if (paths.target.includes(base)) return "after";
+  if (paths.this.includes(target)) return "before";
   let commonPath;
   const commonIndex = {
     target: 0,
@@ -3402,10 +3895,10 @@ function _guessExecutionStatusRelativeToDifferentFunctionsCached(base, target, c
   return result;
 }
 function resolve(dangerous, resolved) {
-  return this._resolve(dangerous, resolved) || this;
+  return _resolve.call(this, dangerous, resolved) || this;
 }
 function _resolve(dangerous, resolved) {
-  if (resolved && resolved.indexOf(this) >= 0) return;
+  if (resolved?.includes(this)) return;
   resolved = resolved || [];
   resolved.push(this);
   if (this.isVariableDeclarator()) {
@@ -3508,651 +4001,17 @@ function isInStrictMode() {
     } else {
       return false;
     }
-    for (const directive of body.directives) {
-      if (directive.value.value === "use strict") {
-        return true;
-      }
-    }
-  });
-  return !!strictParent;
-}
-
-function call(key) {
-  const opts = this.opts;
-  this.debug(key);
-  if (this.node) {
-    if (this._call(opts[key])) return true;
-  }
-  if (this.node) {
-    return this._call(opts[this.node.type]?.[key]);
-  }
-  return false;
-}
-function _call(fns) {
-  if (!fns) return false;
-  for (const fn of fns) {
-    if (!fn) continue;
-    const node = this.node;
-    if (!node) return true;
-    const ret = fn.call(this.state, this, this.state);
-    if (ret && typeof ret === "object" && typeof ret.then === "function") {
-      throw new Error(`You appear to be using a plugin with an async traversal visitor, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
-    }
-    if (ret) {
-      throw new Error(`Unexpected return value from visitor method ${fn}`);
-    }
-    if (this.node !== node) return true;
-    if (this._traverseFlags > 0) return true;
-  }
-  return false;
-}
-function isDenylisted() {
-  const denylist = this.opts.denylist ?? this.opts.blacklist;
-  return denylist && denylist.indexOf(this.node.type) > -1;
-}
-function restoreContext(path, context) {
-  if (path.context !== context) {
-    path.context = context;
-    path.state = context.state;
-    path.opts = context.opts;
-  }
-}
-function visit() {
-  if (!this.node) {
-    return false;
-  }
-  if (this.isDenylisted()) {
-    return false;
-  }
-  if (this.opts.shouldSkip?.(this)) {
-    return false;
-  }
-  const currentContext = this.context;
-  if (this.shouldSkip || this.call("enter")) {
-    this.debug("Skip...");
-    return this.shouldStop;
-  }
-  restoreContext(this, currentContext);
-  this.debug("Recursing into...");
-  this.shouldStop = traverseNode(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
-  restoreContext(this, currentContext);
-  this.call("exit");
-  return this.shouldStop;
-}
-function skip() {
-  this.shouldSkip = true;
-}
-function skipKey(key) {
-  if (this.skipKeys == null) {
-    this.skipKeys = {};
-  }
-  this.skipKeys[key] = true;
-}
-function stop() {
-  this._traverseFlags |= SHOULD_SKIP | SHOULD_STOP;
-}
-function setScope() {
-  if (this.opts?.noScope) return;
-  let path = this.parentPath;
-  if ((this.key === "key" || this.listKey === "decorators") && path.isMethod() || this.key === "discriminant" && path.isSwitchStatement()) {
-    path = path.parentPath;
-  }
-  let target;
-  while (path && !target) {
-    if (path.opts?.noScope) return;
-    target = path.scope;
-    path = path.parentPath;
-  }
-  this.scope = this.getScope(target);
-  this.scope?.init();
-}
-function setContext(context) {
-  if (this.skipKeys != null) {
-    this.skipKeys = {};
-  }
-  this._traverseFlags = 0;
-  if (context) {
-    this.context = context;
-    this.state = context.state;
-    this.opts = context.opts;
-  }
-  this.setScope();
-  return this;
-}
-function resync() {
-  if (this.removed) return;
-  this._resyncParent();
-  this._resyncList();
-  this._resyncKey();
-}
-function _resyncParent() {
-  if (this.parentPath) {
-    this.parent = this.parentPath.node;
-  }
-}
-function _resyncKey() {
-  if (!this.container) return;
-  if (this.node === this.container[this.key]) {
-    return;
-  }
-  if (Array.isArray(this.container)) {
-    for (let i = 0; i < this.container.length; i++) {
-      if (this.container[i] === this.node) {
-        this.setKey(i);
-        return;
-      }
-    }
-  } else {
-    for (const key of Object.keys(this.container)) {
-      if (this.container[key] === this.node) {
-        this.setKey(key);
-        return;
-      }
-    }
-  }
-  this.key = null;
-}
-function _resyncList() {
-  if (!this.parent || !this.inList) return;
-  const newContainer = this.parent[this.listKey];
-  if (this.container === newContainer) return;
-  this.container = newContainer || null;
-}
-function _resyncRemoved() {
-  if (this.key == null || !this.container || this.container[this.key] !== this.node) {
-    this._markRemoved();
-  }
-}
-function popContext() {
-  this.contexts.pop();
-  if (this.contexts.length > 0) {
-    this.setContext(this.contexts[this.contexts.length - 1]);
-  } else {
-    this.setContext(undefined);
-  }
-}
-function pushContext(context) {
-  this.contexts.push(context);
-  this.setContext(context);
-}
-function setup(parentPath, container, listKey, key) {
-  this.listKey = listKey;
-  this.container = container;
-  this.parentPath = parentPath || this.parentPath;
-  this.setKey(key);
-}
-function setKey(key) {
-  this.key = key;
-  this.node = this.container[this.key];
-  this.type = this.node?.type;
-}
-function requeue(pathToQueue = this) {
-  if (pathToQueue.removed) return;
-  {
-    pathToQueue.shouldSkip = false;
-  }
-  const contexts = this.contexts;
-  for (const context of contexts) {
-    context.maybeQueue(pathToQueue);
-  }
-}
-function _getQueueContexts() {
-  let path = this;
-  let contexts = this.contexts;
-  while (!contexts.length) {
-    path = path.parentPath;
-    if (!path) break;
-    contexts = path.contexts;
-  }
-  return contexts;
-}
-
-const hooks = [function (self, parent) {
-  const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
-  if (removeParent) {
-    parent.remove();
-    return true;
-  }
-}, function (self, parent) {
-  if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
-    parent.replaceWith(parent.node.expressions[0]);
-    return true;
-  }
-}, function (self, parent) {
-  if (parent.isBinary()) {
-    if (self.key === "left") {
-      parent.replaceWith(parent.node.right);
-    } else {
-      parent.replaceWith(parent.node.left);
-    }
-    return true;
-  }
-}, function (self, parent) {
-  if (parent.isIfStatement() && self.key === "consequent" || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
-    self.replaceWith({
-      type: "BlockStatement",
-      body: []
-    });
-    return true;
-  }
-}];
-
-const {
-  getBindingIdentifiers: getBindingIdentifiers$1
-} = _t;
-function remove() {
-  this._assertUnremoved();
-  this.resync();
-  if (!this.opts?.noScope) {
-    this._removeFromScope();
-  }
-  if (this._callRemovalHooks()) {
-    this._markRemoved();
-    return;
-  }
-  this.shareCommentsWithSiblings();
-  this._remove();
-  this._markRemoved();
-}
-function _removeFromScope() {
-  const bindings = getBindingIdentifiers$1(this.node, false, false, true);
-  Object.keys(bindings).forEach(name => this.scope.removeBinding(name));
-}
-function _callRemovalHooks() {
-  if (this.parentPath) {
-    for (const fn of hooks) {
-      if (fn(this, this.parentPath)) return true;
-    }
-  }
-}
-function _remove() {
-  if (Array.isArray(this.container)) {
-    this.container.splice(this.key, 1);
-    this.updateSiblingKeys(this.key, -1);
-  } else {
-    this._replaceWith(null);
-  }
-}
-function _markRemoved() {
-  this._traverseFlags |= SHOULD_SKIP | REMOVED;
-  if (this.parent) {
-    getCachedPaths(this.hub, this.parent).delete(this.node);
-  }
-  this.node = null;
-}
-function _assertUnremoved() {
-  if (this.removed) {
-    throw this.buildCodeFrameError("NodePath has been removed so is read-only.");
-  }
-}
-
-const {
-  react
-} = _t;
-const {
-  cloneNode: cloneNode$1,
-  jsxExpressionContainer,
-  variableDeclaration,
-  variableDeclarator
-} = _t;
-const referenceVisitor = {
-  ReferencedIdentifier(path, state) {
-    if (path.isJSXIdentifier() && react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
-      return;
-    }
-    if (path.node.name === "this") {
-      let scope = path.scope;
-      do {
-        if (scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
-          break;
-        }
-      } while (scope = scope.parent);
-      if (scope) state.breakOnScopePaths.push(scope.path);
-    }
-    const binding = path.scope.getBinding(path.node.name);
-    if (!binding) return;
-    for (const violation of binding.constantViolations) {
-      if (violation.scope !== binding.path.scope) {
-        state.mutableBinding = true;
-        path.stop();
-        return;
-      }
-    }
-    if (binding !== state.scope.getBinding(path.node.name)) return;
-    state.bindings[path.node.name] = binding;
-  }
-};
-class PathHoister {
-  breakOnScopePaths;
-  bindings;
-  mutableBinding;
-  scopes;
-  scope;
-  path;
-  attachAfter;
-  constructor(path, scope) {
-    this.breakOnScopePaths = [];
-    this.bindings = {};
-    this.mutableBinding = false;
-    this.scopes = [];
-    this.scope = scope;
-    this.path = path;
-    this.attachAfter = false;
-  }
-  isCompatibleScope(scope) {
-    for (const key of Object.keys(this.bindings)) {
-      const binding = this.bindings[key];
-      if (!scope.bindingIdentifierEquals(key, binding.identifier)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  getCompatibleScopes() {
-    let scope = this.path.scope;
-    do {
-      if (this.isCompatibleScope(scope)) {
-        this.scopes.push(scope);
-      } else {
-        break;
-      }
-      if (this.breakOnScopePaths.indexOf(scope.path) >= 0) {
-        break;
-      }
-    } while (scope = scope.parent);
-  }
-  getAttachmentPath() {
-    let path = this._getAttachmentPath();
-    if (!path) return;
-    let targetScope = path.scope;
-    if (targetScope.path === path) {
-      targetScope = path.scope.parent;
-    }
-    if (targetScope.path.isProgram() || targetScope.path.isFunction()) {
-      for (const name of Object.keys(this.bindings)) {
-        if (!targetScope.hasOwnBinding(name)) continue;
-        const binding = this.bindings[name];
-        if (binding.kind === "param" || binding.path.parentKey === "params") {
-          continue;
-        }
-        const bindingParentPath = this.getAttachmentParentForPath(binding.path);
-        if (bindingParentPath.key >= path.key) {
-          this.attachAfter = true;
-          path = binding.path;
-          for (const violationPath of binding.constantViolations) {
-            if (this.getAttachmentParentForPath(violationPath).key > path.key) {
-              path = violationPath;
-            }
-          }
-        }
-      }
-    }
-    return path;
-  }
-  _getAttachmentPath() {
-    const scopes = this.scopes;
-    const scope = scopes.pop();
-    if (!scope) return;
-    if (scope.path.isFunction()) {
-      if (this.hasOwnParamBindings(scope)) {
-        if (this.scope === scope) return;
-        const bodies = scope.path.get("body").get("body");
-        for (let i = 0; i < bodies.length; i++) {
-          if (bodies[i].node._blockHoist) continue;
-          return bodies[i];
-        }
-      } else {
-        return this.getNextScopeAttachmentParent();
-      }
-    } else if (scope.path.isProgram()) {
-      return this.getNextScopeAttachmentParent();
-    }
-  }
-  getNextScopeAttachmentParent() {
-    const scope = this.scopes.pop();
-    if (scope) return this.getAttachmentParentForPath(scope.path);
-  }
-  getAttachmentParentForPath(path) {
-    do {
-      if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
-        return path;
-      }
-    } while (path = path.parentPath);
-  }
-  hasOwnParamBindings(scope) {
-    for (const name of Object.keys(this.bindings)) {
-      if (!scope.hasOwnBinding(name)) continue;
-      const binding = this.bindings[name];
-      if (binding.kind === "param" && binding.constant) return true;
-    }
-    return false;
-  }
-  run() {
-    this.path.traverse(referenceVisitor, this);
-    if (this.mutableBinding) return;
-    this.getCompatibleScopes();
-    const attachTo = this.getAttachmentPath();
-    if (!attachTo) return;
-    if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;
-    let uid = attachTo.scope.generateUidIdentifier("ref");
-    const declarator = variableDeclarator(uid, this.path.node);
-    const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
-    const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : variableDeclaration("var", [declarator])]);
-    const parent = this.path.parentPath;
-    if (parent.isJSXElement() && this.path.container === parent.node.children) {
-      uid = jsxExpressionContainer(uid);
-    }
-    this.path.replaceWith(cloneNode$1(uid));
-    return attachTo.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init");
-  }
-}
-
-const {
-  arrowFunctionExpression,
-  assertExpression,
-  assignmentExpression,
-  blockStatement,
-  callExpression,
-  cloneNode,
-  expressionStatement,
-  isAssignmentExpression,
-  isCallExpression,
-  isExportNamedDeclaration,
-  isExpression,
-  isIdentifier,
-  isSequenceExpression,
-  isSuper,
-  thisExpression
-} = _t;
-function insertBefore(nodes_) {
-  this._assertUnremoved();
-  const nodes = this._verifyNodeList(nodes_);
-  const {
-    parentPath,
-    parent
-  } = this;
-  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
-    return parentPath.insertBefore(nodes);
-  } else if (this.isNodeType("Expression") && !this.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
-    if (this.node) nodes.push(this.node);
-    return this.replaceExpressionWithStatements(nodes);
-  } else if (Array.isArray(this.container)) {
-    return this._containerInsertBefore(nodes);
-  } else if (this.isStatementOrBlock()) {
-    const node = this.node;
-    const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
-    this.replaceWith(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?");
-  }
-}
-function _containerInsert(from, nodes) {
-  this.updateSiblingKeys(from, nodes.length);
-  const paths = [];
-  this.container.splice(from, 0, ...nodes);
-  for (let i = 0; i < nodes.length; i++) {
-    const to = from + i;
-    const path = this.getSibling(to);
-    paths.push(path);
-    if (this.context?.queue) {
-      path.pushContext(this.context);
-    }
-  }
-  const contexts = this._getQueueContexts();
-  for (const path of paths) {
-    path.setScope();
-    path.debug("Inserted.");
-    for (const context of contexts) {
-      context.maybeQueue(path, true);
-    }
-  }
-  return paths;
-}
-function _containerInsertBefore(nodes) {
-  return this._containerInsert(this.key, nodes);
-}
-function _containerInsertAfter(nodes) {
-  return this._containerInsert(this.key + 1, nodes);
-}
-const last = arr => arr[arr.length - 1];
-function isHiddenInSequenceExpression(path) {
-  return isSequenceExpression(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath));
-}
-function isAlmostConstantAssignment(node, scope) {
-  if (!isAssignmentExpression(node) || !isIdentifier(node.left)) {
-    return false;
-  }
-  const blockScope = scope.getBlockParent();
-  return blockScope.hasOwnBinding(node.left.name) && blockScope.getOwnBinding(node.left.name).constantViolations.length <= 1;
-}
-function insertAfter(nodes_) {
-  this._assertUnremoved();
-  if (this.isSequenceExpression()) {
-    return last(this.get("expressions")).insertAfter(nodes_);
-  }
-  const nodes = this._verifyNodeList(nodes_);
-  const {
-    parentPath,
-    parent
-  } = this;
-  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
-    return parentPath.insertAfter(nodes.map(node => {
-      return isExpression(node) ? expressionStatement(node) : node;
-    }));
-  } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
-    const self = this;
-    if (self.node) {
-      const node = self.node;
-      let {
-        scope
-      } = this;
-      if (scope.path.isPattern()) {
-        assertExpression(node);
-        self.replaceWith(callExpression(arrowFunctionExpression([], node), []));
-        self.get("callee.body").insertAfter(nodes);
-        return [self];
-      }
-      if (isHiddenInSequenceExpression(self)) {
-        nodes.unshift(node);
-      } else if (isCallExpression(node) && isSuper(node.callee)) {
-        nodes.unshift(node);
-        nodes.push(thisExpression());
-      } else if (isAlmostConstantAssignment(node, scope)) {
-        nodes.unshift(node);
-        nodes.push(cloneNode(node.left));
-      } else if (scope.isPure(node, true)) {
-        nodes.push(node);
-      } else {
-        if (parentPath.isMethod({
-          computed: true,
-          key: node
-        })) {
-          scope = scope.parent;
-        }
-        const temp = scope.generateDeclaredUidIdentifier();
-        nodes.unshift(expressionStatement(assignmentExpression("=", cloneNode(temp), node)));
-        nodes.push(expressionStatement(cloneNode(temp)));
-      }
-    }
-    return this.replaceExpressionWithStatements(nodes);
-  } else if (Array.isArray(this.container)) {
-    return this._containerInsertAfter(nodes);
-  } else if (this.isStatementOrBlock()) {
-    const node = this.node;
-    const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
-    this.replaceWith(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?");
-  }
-}
-function updateSiblingKeys(fromIndex, incrementBy) {
-  if (!this.parent) return;
-  const paths = getCachedPaths(this.hub, this.parent) || [];
-  for (const [, path] of paths) {
-    if (typeof path.key === "number" && path.key >= fromIndex) {
-      path.key += incrementBy;
-    }
-  }
-}
-function _verifyNodeList(nodes) {
-  if (!nodes) {
-    return [];
-  }
-  if (!Array.isArray(nodes)) {
-    nodes = [nodes];
-  }
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    let msg;
-    if (!node) {
-      msg = "has falsy node";
-    } else if (typeof node !== "object") {
-      msg = "contains a non-object node";
-    } else if (!node.type) {
-      msg = "without a type";
-    } else if (node instanceof NodePath_Final) {
-      msg = "has a NodePath when it expected a raw object";
-    }
-    if (msg) {
-      const type = Array.isArray(node) ? "array" : typeof node;
-      throw new Error(`Node list ${msg} with the index of ${i} and type of ${type}`);
+    for (const directive of body.directives) {
+      if (directive.value.value === "use strict") {
+        return true;
+      }
     }
-  }
-  return nodes;
-}
-function unshiftContainer(listKey, nodes) {
-  this._assertUnremoved();
-  nodes = this._verifyNodeList(nodes);
-  const path = NodePath_Final.get({
-    parentPath: this,
-    parent: this.node,
-    container: this.node[listKey],
-    listKey,
-    key: 0
-  }).setContext(this.context);
-  return path._containerInsertBefore(nodes);
-}
-function pushContainer(listKey, nodes) {
-  this._assertUnremoved();
-  const verifiedNodes = this._verifyNodeList(nodes);
-  const container = this.node[listKey];
-  const path = NodePath_Final.get({
-    parentPath: this,
-    parent: this.node,
-    container: container,
-    listKey,
-    key: container.length
-  }).setContext(this.context);
-  return path.replaceWithMultiple(verifiedNodes);
-}
-function hoist(scope = this.scope) {
-  const hoister = new PathHoister(this, scope);
-  return hoister.run();
+  });
+  return !!strictParent;
 }
 
 const {
+  getAssignmentIdentifiers: _getAssignmentIdentifiers,
   getBindingIdentifiers: _getBindingIdentifiers,
   getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
   numericLiteral,
@@ -4250,12 +4109,16 @@ function getStatementListCompletion(paths, context) {
           completions.push(...lastNormalCompletions);
           if (lastNormalCompletions.some(c => c.path.isDeclaration())) {
             completions.push(...statementCompletions);
-            replaceBreakStatementInBreakCompletion(statementCompletions, true);
+            if (!context.shouldPreserveBreak) {
+              replaceBreakStatementInBreakCompletion(statementCompletions, true);
+            }
+          }
+          if (!context.shouldPreserveBreak) {
+            replaceBreakStatementInBreakCompletion(statementCompletions, false);
           }
-          replaceBreakStatementInBreakCompletion(statementCompletions, false);
         } else {
           completions.push(...statementCompletions);
-          if (!context.shouldPopulateBreak) {
+          if (!context.shouldPopulateBreak && !context.shouldPreserveBreak) {
             replaceBreakStatementInBreakCompletion(statementCompletions, true);
           }
         }
@@ -4279,7 +4142,7 @@ function getStatementListCompletion(paths, context) {
   } else if (paths.length) {
     for (let i = paths.length - 1; i >= 0; i--) {
       const pathCompletions = _getCompletionRecords(paths[i], context);
-      if (pathCompletions.length > 1 || pathCompletions.length === 1 && !pathCompletions[0].path.isVariableDeclaration()) {
+      if (pathCompletions.length > 1 || pathCompletions.length === 1 && !pathCompletions[0].path.isVariableDeclaration() && !pathCompletions[0].path.isEmptyStatement()) {
         completions.push(...pathCompletions);
         break;
       }
@@ -4309,7 +4172,8 @@ function _getCompletionRecords(path, context) {
     return getStatementListCompletion(path.get("consequent"), {
       canHaveBreak: true,
       shouldPopulateBreak: false,
-      inCaseClause: true
+      inCaseClause: true,
+      shouldPreserveBreak: context.shouldPreserveBreak
     });
   } else if (path.isBreakStatement()) {
     records.push(BreakCompletion(path));
@@ -4318,11 +4182,12 @@ function _getCompletionRecords(path, context) {
   }
   return records;
 }
-function getCompletionRecords() {
+function getCompletionRecords(shouldPreserveBreak = false) {
   const records = _getCompletionRecords(this, {
     canHaveBreak: false,
     shouldPopulateBreak: false,
-    inCaseClause: false
+    inCaseClause: false,
+    shouldPreserveBreak
   });
   return records.map(r => r.path);
 }
@@ -4365,9 +4230,9 @@ function get(key, context = true) {
   if (context === true) context = this.context;
   const parts = key.split(".");
   if (parts.length === 1) {
-    return this._getKey(key, context);
+    return _getKey.call(this, key, context);
   } else {
-    return this._getPattern(parts, context);
+    return _getPattern.call(this, parts, context);
   }
 }
 function _getKey(key, context) {
@@ -4407,6 +4272,9 @@ function _getPattern(parts, context) {
   }
   return path;
 }
+function getAssignmentIdentifiers() {
+  return _getAssignmentIdentifiers(this.node);
+}
 function getBindingIdentifiers(duplicates) {
   return _getBindingIdentifiers(this.node, duplicates);
 }
@@ -4551,6 +4419,7 @@ const NodePath_Final = class NodePath {
   key = null;
   node = null;
   type = null;
+  _store = null;
   static get({
     hub,
     parentPath,
@@ -4566,13 +4435,13 @@ const NodePath_Final = class NodePath {
       throw new Error("To get a node path the parent needs to exist");
     }
     const targetNode = container[key];
-    const paths = getOrCreateCachedPaths(hub, parent);
+    const paths = getOrCreateCachedPaths(parent, parentPath);
     let path = paths.get(targetNode);
     if (!path) {
       path = new NodePath(hub, parent);
       if (targetNode) paths.set(targetNode, path);
     }
-    path.setup(parentPath, container, listKey, key);
+    setup.call(path, parentPath, container, listKey, key);
     return path;
   }
   getScope(scope) {
@@ -4646,7 +4515,6 @@ const methods = {
   isDescendant: isDescendant,
   inType: inType,
   getTypeAnnotation: getTypeAnnotation,
-  _getTypeAnnotation: _getTypeAnnotation,
   isBaseType: isBaseType,
   couldBeBaseType: couldBeBaseType,
   baseTypeStrictlyMatches: baseTypeStrictlyMatches,
@@ -4654,7 +4522,6 @@ const methods = {
   replaceWithMultiple: replaceWithMultiple,
   replaceWithSourceString: replaceWithSourceString,
   replaceWith: replaceWith,
-  _replaceWith: _replaceWith,
   replaceExpressionWithStatements: replaceExpressionWithStatements,
   replaceInline: replaceInline,
   evaluateTruthy: evaluateTruthy,
@@ -4663,12 +4530,10 @@ const methods = {
   ensureBlock: ensureBlock,
   unwrapFunctionEnvironment: unwrapFunctionEnvironment,
   arrowFunctionToExpression: arrowFunctionToExpression,
+  splitExportDeclaration: splitExportDeclaration,
+  ensureFunctionName: ensureFunctionName,
   matchesPattern: matchesPattern,
-  has: has,
   isStatic: isStatic,
-  is: is,
-  isnt: isnt,
-  equals: equals,
   isNodeType: isNodeType,
   canHaveVariableDeclarationOrExpression: canHaveVariableDeclarationOrExpression,
   canSwapBetweenExpressionAndStatement: canSwapBetweenExpressionAndStatement,
@@ -4679,46 +4544,21 @@ const methods = {
   willIMaybeExecuteBefore: willIMaybeExecuteBefore,
   _guessExecutionStatusRelativeTo: _guessExecutionStatusRelativeTo,
   resolve: resolve,
-  _resolve: _resolve,
   isConstantExpression: isConstantExpression,
   isInStrictMode: isInStrictMode,
-  call: call,
-  _call: _call,
   isDenylisted: isDenylisted,
-  isBlacklisted: isDenylisted,
   visit: visit,
   skip: skip,
   skipKey: skipKey,
   stop: stop,
-  setScope: setScope,
   setContext: setContext,
-  resync: resync,
-  _resyncParent: _resyncParent,
-  _resyncKey: _resyncKey,
-  _resyncList: _resyncList,
-  _resyncRemoved: _resyncRemoved,
-  popContext: popContext,
-  pushContext: pushContext,
-  setup: setup,
-  setKey: setKey,
   requeue: requeue,
-  _getQueueContexts: _getQueueContexts,
+  requeueComputedKeyAndDecorators: requeueComputedKeyAndDecorators,
   remove: remove,
-  _removeFromScope: _removeFromScope,
-  _callRemovalHooks: _callRemovalHooks,
-  _remove: _remove,
-  _markRemoved: _markRemoved,
-  _assertUnremoved: _assertUnremoved,
   insertBefore: insertBefore,
-  _containerInsert: _containerInsert,
-  _containerInsertBefore: _containerInsertBefore,
-  _containerInsertAfter: _containerInsertAfter,
   insertAfter: insertAfter,
-  updateSiblingKeys: updateSiblingKeys,
-  _verifyNodeList: _verifyNodeList,
   unshiftContainer: unshiftContainer,
   pushContainer: pushContainer,
-  hoist: hoist,
   getOpposite: getOpposite,
   getCompletionRecords: getCompletionRecords,
   getSibling: getSibling,
@@ -4727,8 +4567,7 @@ const methods = {
   getAllNextSiblings: getAllNextSiblings,
   getAllPrevSiblings: getAllPrevSiblings,
   get: get,
-  _getKey: _getKey,
-  _getPattern: _getPattern,
+  getAssignmentIdentifiers: getAssignmentIdentifiers,
   getBindingIdentifiers: getBindingIdentifiers,
   getOuterBindingIdentifiers: getOuterBindingIdentifiers,
   getBindingIdentifierPaths: getBindingIdentifierPaths,
@@ -4826,9 +4665,9 @@ class TraversalContext {
     for (; visitIndex < queue.length;) {
       const path = queue[visitIndex];
       visitIndex++;
-      path.resync();
+      resync.call(path);
       if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) {
-        path.pushContext(this);
+        pushContext.call(path, this);
       }
       if (path.key === null) continue;
       const {
@@ -4848,7 +4687,7 @@ class TraversalContext {
       }
     }
     for (let i = 0; i < visitIndex; i++) {
-      queue[i].popContext();
+      popContext.call(queue[i]);
     }
     this.queue = null;
     return stop;
@@ -4867,22 +4706,313 @@ class TraversalContext {
 const {
   VISITOR_KEYS: VISITOR_KEYS$1
 } = _t;
-function traverseNode(node, opts, scope, state, path, skipKeys, visitSelf) {
+function _visitPaths(ctx, paths) {
+  ctx.queue = paths;
+  ctx.priorityQueue = [];
+  const visited = new Set();
+  let stop = false;
+  let visitIndex = 0;
+  for (; visitIndex < paths.length;) {
+    const path = paths[visitIndex];
+    visitIndex++;
+    resync.call(path);
+    if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== ctx) {
+      pushContext.call(path, ctx);
+    }
+    if (path.key === null) continue;
+    const {
+      node
+    } = path;
+    if (visited.has(node)) continue;
+    if (node) visited.add(node);
+    if (_visit(ctx, path)) {
+      stop = true;
+      break;
+    }
+    if (ctx.priorityQueue.length) {
+      stop = _visitPaths(ctx, ctx.priorityQueue);
+      ctx.priorityQueue = [];
+      ctx.queue = paths;
+      if (stop) break;
+    }
+  }
+  for (let i = 0; i < visitIndex; i++) {
+    popContext.call(paths[i]);
+  }
+  ctx.queue = null;
+  return stop;
+}
+function _visit(ctx, path) {
+  const node = path.node;
+  if (!node) {
+    return false;
+  }
+  const opts = ctx.opts;
+  const denylist = opts.denylist ?? opts.blacklist;
+  if (denylist?.includes(node.type)) {
+    return false;
+  }
+  if (opts.shouldSkip?.(path)) {
+    return false;
+  }
+  if (path.shouldSkip) return path.shouldStop;
+  if (_call.call(path, opts.enter)) return path.shouldStop;
+  if (path.node) {
+    if (_call.call(path, opts[node.type]?.enter)) return path.shouldStop;
+  }
+  path.shouldStop = _traverse(path.node, opts, path.scope, ctx.state, path, path.skipKeys);
+  if (path.node) {
+    if (_call.call(path, opts.exit)) return true;
+  }
+  if (path.node) {
+    _call.call(path, opts[node.type]?.exit);
+  }
+  return path.shouldStop;
+}
+function _traverse(node, opts, scope, state, path, skipKeys, visitSelf) {
   const keys = VISITOR_KEYS$1[node.type];
-  if (!keys) return false;
-  const context = new TraversalContext(scope, opts, state, path);
+  if (!keys?.length) return false;
+  const ctx = new TraversalContext(scope, opts, state, path);
   if (visitSelf) {
     if (skipKeys?.[path.parentKey]) return false;
-    return context.visitQueue([path]);
+    return _visitPaths(ctx, [path]);
   }
   for (const key of keys) {
     if (skipKeys?.[key]) continue;
-    if (context.visit(node, key)) {
-      return true;
+    const prop = node[key];
+    if (!prop) continue;
+    if (Array.isArray(prop)) {
+      if (!prop.length) continue;
+      const paths = [];
+      for (let i = 0; i < prop.length; i++) {
+        const childPath = NodePath_Final.get({
+          parentPath: path,
+          parent: node,
+          container: prop,
+          key: i,
+          listKey: key
+        });
+        paths.push(childPath);
+      }
+      if (_visitPaths(ctx, paths)) return true;
+    } else {
+      if (_visitPaths(ctx, [NodePath_Final.get({
+        parentPath: path,
+        parent: node,
+        container: node,
+        key,
+        listKey: null
+      })])) {
+        return true;
+      }
     }
   }
   return false;
 }
+function traverseNode(node, opts, scope, state, path, skipKeys, visitSelf) {
+  {
+    return _traverse(node, opts, scope, state, path, skipKeys, visitSelf);
+  }
+}
+
+function call(key) {
+  const opts = this.opts;
+  this.debug(key);
+  if (this.node) {
+    if (_call.call(this, opts[key])) return true;
+  }
+  if (this.node) {
+    return _call.call(this, opts[this.node.type]?.[key]);
+  }
+  return false;
+}
+function _call(fns) {
+  if (!fns) return false;
+  for (const fn of fns) {
+    if (!fn) continue;
+    const node = this.node;
+    if (!node) return true;
+    const ret = fn.call(this.state, this, this.state);
+    if (ret && typeof ret === "object" && typeof ret.then === "function") {
+      throw new Error(`You appear to be using a plugin with an async traversal visitor, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+    }
+    if (ret) {
+      throw new Error(`Unexpected return value from visitor method ${fn}`);
+    }
+    if (this.node !== node) return true;
+    if (this._traverseFlags > 0) return true;
+  }
+  return false;
+}
+function isDenylisted() {
+  const denylist = this.opts.denylist ?? this.opts.blacklist;
+  return denylist?.includes(this.node.type);
+}
+function restoreContext(path, context) {
+  if (path.context !== context) {
+    path.context = context;
+    path.state = context.state;
+    path.opts = context.opts;
+  }
+}
+function visit() {
+  if (!this.node) {
+    return false;
+  }
+  if (this.isDenylisted()) {
+    return false;
+  }
+  if (this.opts.shouldSkip?.(this)) {
+    return false;
+  }
+  const currentContext = this.context;
+  if (this.shouldSkip || call.call(this, "enter")) {
+    this.debug("Skip...");
+    return this.shouldStop;
+  }
+  restoreContext(this, currentContext);
+  this.debug("Recursing into...");
+  this.shouldStop = traverseNode(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
+  restoreContext(this, currentContext);
+  call.call(this, "exit");
+  return this.shouldStop;
+}
+function skip() {
+  this.shouldSkip = true;
+}
+function skipKey(key) {
+  if (this.skipKeys == null) {
+    this.skipKeys = {};
+  }
+  this.skipKeys[key] = true;
+}
+function stop() {
+  this._traverseFlags |= SHOULD_SKIP | SHOULD_STOP;
+}
+function setScope() {
+  if (this.opts?.noScope) return;
+  let path = this.parentPath;
+  if ((this.key === "key" || this.listKey === "decorators") && path.isMethod() || this.key === "discriminant" && path.isSwitchStatement()) {
+    path = path.parentPath;
+  }
+  let target;
+  while (path && !target) {
+    if (path.opts?.noScope) return;
+    target = path.scope;
+    path = path.parentPath;
+  }
+  this.scope = this.getScope(target);
+  this.scope?.init();
+}
+function setContext(context) {
+  if (this.skipKeys != null) {
+    this.skipKeys = {};
+  }
+  this._traverseFlags = 0;
+  if (context) {
+    this.context = context;
+    this.state = context.state;
+    this.opts = context.opts;
+  }
+  setScope.call(this);
+  return this;
+}
+function resync() {
+  if (this.removed) return;
+  _resyncParent.call(this);
+  _resyncList.call(this);
+  _resyncKey.call(this);
+}
+function _resyncParent() {
+  if (this.parentPath) {
+    this.parent = this.parentPath.node;
+  }
+}
+function _resyncKey() {
+  if (!this.container) return;
+  if (this.node === this.container[this.key]) {
+    return;
+  }
+  if (Array.isArray(this.container)) {
+    for (let i = 0; i < this.container.length; i++) {
+      if (this.container[i] === this.node) {
+        setKey.call(this, i);
+        return;
+      }
+    }
+  } else {
+    for (const key of Object.keys(this.container)) {
+      if (this.container[key] === this.node) {
+        setKey.call(this, key);
+        return;
+      }
+    }
+  }
+  this.key = null;
+}
+function _resyncList() {
+  if (!this.parent || !this.inList) return;
+  const newContainer = this.parent[this.listKey];
+  if (this.container === newContainer) return;
+  this.container = newContainer || null;
+}
+function popContext() {
+  this.contexts.pop();
+  if (this.contexts.length > 0) {
+    this.setContext(this.contexts[this.contexts.length - 1]);
+  } else {
+    this.setContext(undefined);
+  }
+}
+function pushContext(context) {
+  this.contexts.push(context);
+  this.setContext(context);
+}
+function setup(parentPath, container, listKey, key) {
+  this.listKey = listKey;
+  this.container = container;
+  this.parentPath = parentPath || this.parentPath;
+  setKey.call(this, key);
+}
+function setKey(key) {
+  this.key = key;
+  this.node = this.container[this.key];
+  this.type = this.node?.type;
+}
+function requeue(pathToQueue = this) {
+  if (pathToQueue.removed) return;
+  {
+    pathToQueue.shouldSkip = false;
+  }
+  const contexts = this.contexts;
+  for (const context of contexts) {
+    context.maybeQueue(pathToQueue);
+  }
+}
+function requeueComputedKeyAndDecorators() {
+  const {
+    context,
+    node
+  } = this;
+  if (!_t.isPrivate(node) && node.computed) {
+    context.maybeQueue(this.get("key"));
+  }
+  if (node.decorators) {
+    for (const decorator of this.get("decorators")) {
+      context.maybeQueue(decorator);
+    }
+  }
+}
+function _getQueueContexts() {
+  let path = this;
+  let contexts = this.contexts;
+  while (!contexts.length) {
+    path = path.parentPath;
+    if (!path) break;
+    contexts = path.contexts;
+  }
+  return contexts;
+}
 
 class Hub {
   getCode() {}
@@ -4933,25 +5063,17 @@ traverse.removeProperties = function (tree, opts) {
   traverseFast(tree, traverse.clearNode, opts);
   return tree;
 };
-function hasDenylistedType(path, state) {
-  if (path.node.type === state.type) {
-    state.has = true;
-    path.stop();
-  }
-}
 traverse.hasType = function (tree, type, denylistTypes) {
   if (denylistTypes?.includes(tree.type)) return false;
   if (tree.type === type) return true;
-  const state = {
-    has: false,
-    type: type
-  };
-  traverse(tree, {
-    noScope: true,
-    denylist: denylistTypes,
-    enter: hasDenylistedType
-  }, null, state);
-  return state.has;
+  return traverseFast(tree, function (node) {
+    if (denylistTypes?.includes(node.type)) {
+      return traverseFast.skip;
+    }
+    if (node.type === type) {
+      return traverseFast.stop;
+    }
+  });
 };
 traverse.cache = cache;