@babel/traverse 8.0.0-alpha.12 → 8.0.0-alpha.14

package/lib/index.js

@@ -1,9 +1,9 @@
-import * as _t from '@babel/types';
 import buildDebug from 'debug';
-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 globals from 'globals';
+import generator from '@babel/generator';
 import template from '@babel/template';
 
 const ReferencedIdentifier = ["Identifier", "JSXIdentifier"];
@@ -67,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,
@@ -289,7 +289,7 @@ function verify$1(visitor) {
     }
     if (shouldIgnoreKey(nodeType)) continue;
     if (!TYPES.includes(nodeType)) {
-      throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type`);
+      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-alpha.14"}`);
     }
     const visitors = visitor[nodeType];
     if (typeof visitors === "object") {
@@ -313,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];
@@ -332,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 = {};
@@ -408,13 +406,17 @@ const _environmentVisitor = {
     if (path.isArrowFunctionExpression()) return;
     path.skip();
     if (path.isMethod()) {
-      path.requeueComputedKeyAndDecorators();
+      {
+        path.requeueComputedKeyAndDecorators();
+      }
     }
   },
   Property(path) {
     if (path.isObjectProperty()) return;
     path.skip();
-    path.requeueComputedKeyAndDecorators();
+    {
+      path.requeueComputedKeyAndDecorators();
+    }
   }
 };
 function environmentVisitor(visitor) {
@@ -430,41 +432,9 @@ var visitors = /*#__PURE__*/Object.freeze({
   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
@@ -477,7 +447,9 @@ const renameVisitor = {
     if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
       path.skip();
       if (path.isMethod()) {
-        path.requeueComputedKeyAndDecorators();
+        {
+          path.requeueComputedKeyAndDecorators();
+        }
       }
     }
   },
@@ -494,7 +466,7 @@ const renameVisitor = {
   },
   "AssignmentExpression|Declaration|VariableDeclarator"(path, state) {
     if (path.isVariableDeclaration()) return;
-    const ids = path.isAssignmentExpression() ? path.getAssignmentIdentifiers() : 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;
     }
@@ -548,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;
@@ -626,10 +607,10 @@ function isDeclaredInLoop(path) {
   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") {
       return true;
@@ -638,11 +619,46 @@ function isDeclaredInLoop(path) {
   return false;
 }
 
+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 {
   NOT_LOCAL_BINDING,
   assignmentExpression: assignmentExpression$3,
   callExpression: callExpression$3,
-  cloneNode: cloneNode$4,
+  cloneNode: cloneNode$3,
   getBindingIdentifiers: getBindingIdentifiers$3,
   identifier: identifier$3,
   isArrayExpression,
@@ -677,8 +693,8 @@ const {
   memberExpression: memberExpression$1,
   numericLiteral: numericLiteral$2,
   toIdentifier,
-  variableDeclaration: variableDeclaration$2,
-  variableDeclarator: variableDeclarator$2,
+  variableDeclaration: variableDeclaration$1,
+  variableDeclarator: variableDeclarator$1,
   isRecordExpression,
   isTupleExpression,
   isObjectProperty,
@@ -896,12 +912,12 @@ 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.node.id[NOT_LOCAL_BINDING]) {
       path.scope.registerBinding("local", path.get("id"), path);
     }
   },
   ClassExpression(path) {
-    if (path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
+    if (path.node.id && !path.node.id[NOT_LOCAL_BINDING]) {
       path.scope.registerBinding("local", path.get("id"), path);
     }
   },
@@ -914,8 +930,8 @@ class Scope {
   uid;
   path;
   block;
-  labels;
   inited;
+  labels;
   bindings;
   references;
   globals;
@@ -950,31 +966,23 @@ class Scope {
     } while (path && !parent);
     return parent?.scope;
   }
-  get parentBlock() {
-    return this.path.parent;
-  }
-  get hub() {
-    return this.path.hub;
-  }
-  traverse(node, opts, state) {
-    traverse(node, opts, this, state, this.path);
-  }
   generateDeclaredUidIdentifier(name) {
     const id = this.generateUidIdentifier(name);
     this.push({
       id
     });
-    return cloneNode$4(id);
+    return cloneNode$3(id);
   }
   generateUidIdentifier(name) {
     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;
     do {
-      uid = this._generateUid(name, i);
+      uid = `_${name}`;
+      if (i > 1) uid += i;
       i++;
     } while (this.hasLabel(uid) || this.hasBinding(uid) || this.hasGlobal(uid) || this.hasReference(uid));
     const program = this.getProgramParent();
@@ -982,11 +990,6 @@ class Scope {
     program.uids[uid] = true;
     return uid;
   }
-  _generateUid(name, i) {
-    let id = name;
-    if (i > 1) id += i;
-    return `_${id}`;
-  }
   generateUidBasedOnNode(node, defaultName) {
     const parts = [];
     gatherNodeParts(node, parts);
@@ -1020,7 +1023,7 @@ class Scope {
         this.push({
           id
         });
-        return cloneNode$4(id);
+        return cloneNode$3(id);
       }
       return id;
     }
@@ -1030,7 +1033,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) {
@@ -1043,12 +1046,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);
@@ -1067,37 +1064,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);
   }
@@ -1303,8 +1269,14 @@ class Scope {
     this.globals = Object.create(null);
     this.uids = Object.create(null);
     this.data = Object.create(null);
-    const programParent = this.getProgramParent();
-    if (programParent.crawling) return;
+    let scope = this;
+    do {
+      if (scope.crawling) return;
+      if (scope.path.isProgram()) {
+        break;
+      }
+    } while (scope = scope.parent);
+    const programParent = scope;
     const state = {
       references: [],
       constantViolations: [],
@@ -1375,12 +1347,12 @@ class Scope {
     const dataKey = `declaration:${kind}:${blockHoist}`;
     let declarPath = !unique && path.getData(dataKey);
     if (!declarPath) {
-      const declar = variableDeclaration$2(kind, []);
+      const declar = variableDeclaration$1(kind, []);
       declar._blockHoist = blockHoist;
       [declarPath] = path.unshiftContainer("body", [declar]);
       if (!unique) path.setData(dataKey, declarPath);
     }
-    const declarator = variableDeclarator$2(id, init);
+    const declarator = variableDeclarator$1(id, init);
     const len = declarPath.node.declarations.push(declarator);
     path.scope.registerBinding(kind, declarPath.get("declarations")[len - 1]);
   }
@@ -1433,20 +1405,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;
   }
@@ -2191,167 +2149,6 @@ function isGenericType(genericName) {
   });
 }
 
-const {
-  react
-} = _t;
-const {
-  cloneNode: cloneNode$3,
-  jsxExpressionContainer,
-  variableDeclaration: variableDeclaration$1,
-  variableDeclarator: variableDeclarator$1
-} = _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.includes(scope.path)) {
-        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$1(uid, this.path.node);
-    const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
-    const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : variableDeclaration$1("var", [declarator])]);
-    const parent = this.path.parentPath;
-    if (parent.isJSXElement() && this.path.container === parent.node.children) {
-      uid = jsxExpressionContainer(uid);
-    }
-    this.path.replaceWith(cloneNode$3(uid));
-    return attachTo.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init");
-  }
-}
-
 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) {
@@ -2387,247 +2184,48 @@ const {
 } = _t;
 function remove() {
   _assertUnremoved.call(this);
-  this.resync();
-  if (!this.opts?.noScope) {
-    _removeFromScope.call(this);
-  }
+  resync.call(this);
   if (_callRemovalHooks.call(this)) {
     _markRemoved.call(this);
     return;
   }
-  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);
-    this.updateSiblingKeys(this.key, -1);
-  } else {
-    _replaceWith.call(this, 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.");
-  }
-}
-
-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 && 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;
-  _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) {
-        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 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);
+  if (!this.opts?.noScope) {
+    _removeFromScope.call(this);
+  }
+  this.shareCommentsWithSiblings();
+  _remove.call(this);
+  _markRemoved.call(this);
 }
-function setKey(key) {
-  this.key = key;
-  this.node = this.container[this.key];
-  this.type = this.node?.type;
+function _removeFromScope() {
+  const bindings = getBindingIdentifiers$2(this.node, false, false, true);
+  Object.keys(bindings).forEach(name => this.scope.removeBinding(name));
 }
-function requeue(pathToQueue = this) {
-  if (pathToQueue.removed) return;
-  {
-    pathToQueue.shouldSkip = false;
-  }
-  const contexts = this.contexts;
-  for (const context of contexts) {
-    context.maybeQueue(pathToQueue);
+function _callRemovalHooks() {
+  if (this.parentPath) {
+    for (const fn of hooks) {
+      if (fn(this, this.parentPath)) return true;
+    }
   }
 }
-function requeueComputedKeyAndDecorators() {
-  const {
-    context,
-    node
-  } = this;
-  if (!_t.isPrivate(node) && node.computed) {
-    context.maybeQueue(this.get("key"));
+function _remove() {
+  if (Array.isArray(this.container)) {
+    this.container.splice(this.key, 1);
+    updateSiblingKeys.call(this, this.key, -1);
+  } else {
+    _replaceWith.call(this, null);
   }
-  if (node.decorators) {
-    for (const decorator of this.get("decorators")) {
-      context.maybeQueue(decorator);
-    }
+}
+function _markRemoved() {
+  this._traverseFlags |= SHOULD_SKIP | REMOVED;
+  if (this.parent) {
+    getCachedPaths(this.hub, this.parent).delete(this.node);
   }
+  this.node = null;
 }
-function _getQueueContexts() {
-  let path = this;
-  let contexts = this.contexts;
-  while (!contexts.length) {
-    path = path.parentPath;
-    if (!path) break;
-    contexts = path.contexts;
+function _assertUnremoved() {
+  if (this.removed) {
+    throw this.buildCodeFrameError("NodePath has been removed so is read-only.");
   }
-  return contexts;
 }
 
 const {
@@ -2671,7 +2269,7 @@ function insertBefore(nodes_) {
   }
 }
 function _containerInsert(from, nodes) {
-  this.updateSiblingKeys(from, nodes.length);
+  updateSiblingKeys.call(this, from, nodes.length);
   const paths = [];
   this.container.splice(from, 0, ...nodes);
   for (let i = 0; i < nodes.length; i++) {
@@ -2679,12 +2277,12 @@ function _containerInsert(from, nodes) {
     const path = this.getSibling(to);
     paths.push(path);
     if (this.context?.queue) {
-      path.pushContext(this.context);
+      pushContext.call(path, this.context);
     }
   }
   const contexts = _getQueueContexts.call(this);
   for (const path of paths) {
-    path.setScope();
+    setScope.call(path);
     path.debug("Inserted.");
     for (const context of contexts) {
       context.maybeQueue(path, true);
@@ -2774,7 +2372,7 @@ 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) {
+    if (typeof path.key === "number" && path.container === this.container && path.key >= fromIndex) {
       path.key += incrementBy;
     }
   }
@@ -2830,10 +2428,6 @@ function pushContainer(listKey, nodes) {
   }).setContext(this.context);
   return path.replaceWithMultiple(verifiedNodes);
 }
-function hoist(scope = this.scope) {
-  const hoister = new PathHoister(this, scope);
-  return hoister.run();
-}
 
 const {
   FUNCTION_TYPES,
@@ -2866,7 +2460,7 @@ const {
   yieldExpression
 } = _t;
 function replaceWithMultiple(nodes) {
-  this.resync();
+  resync.call(this);
   nodes = _verifyNodeList.call(this, nodes);
   inheritLeadingComments(nodes[0], this.node);
   inheritTrailingComments(nodes[nodes.length - 1], this.node);
@@ -2881,7 +2475,7 @@ function replaceWithMultiple(nodes) {
   return paths;
 }
 function replaceWithSourceString(replacement) {
-  this.resync();
+  resync.call(this);
   let ast;
   try {
     replacement = `(${replacement})`;
@@ -2904,7 +2498,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");
   }
@@ -2943,7 +2537,7 @@ function replaceWith(replacementPath) {
   }
   _replaceWith.call(this, replacement);
   this.type = replacement.type;
-  this.setScope();
+  setScope.call(this);
   this.requeue();
   return [nodePath ? this.get(nodePath) : this];
 }
@@ -2961,7 +2555,7 @@ function _replaceWith(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) {
@@ -2971,8 +2565,8 @@ 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 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");
@@ -3061,7 +2655,7 @@ function gatherSequenceExpressions(nodes, declars) {
   }
 }
 function replaceInline(nodes) {
-  this.resync();
+  resync.call(this);
   if (Array.isArray(nodes)) {
     if (Array.isArray(this.container)) {
       nodes = _verifyNodeList.call(this, nodes);
@@ -3499,7 +3093,7 @@ function ensureBlock() {
   }
   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() {
@@ -4014,24 +3608,9 @@ const {
 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 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);
 }
@@ -4794,7 +4373,7 @@ const NodePath_Final = class NodePath {
       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) {
@@ -4886,11 +4465,7 @@ const methods = {
   splitExportDeclaration: splitExportDeclaration,
   ensureFunctionName: ensureFunctionName,
   matchesPattern: matchesPattern,
-  has: has,
   isStatic: isStatic,
-  is: is,
-  isnt: isnt,
-  equals: equals,
   isNodeType: isNodeType,
   canHaveVariableDeclarationOrExpression: canHaveVariableDeclarationOrExpression,
   canSwapBetweenExpressionAndStatement: canSwapBetweenExpressionAndStatement,
@@ -4903,29 +4478,19 @@ const methods = {
   resolve: resolve,
   isConstantExpression: isConstantExpression,
   isInStrictMode: isInStrictMode,
-  call: call,
   isDenylisted: isDenylisted,
-  isBlacklisted: isDenylisted,
   visit: visit,
   skip: skip,
   skipKey: skipKey,
   stop: stop,
-  setScope: setScope,
   setContext: setContext,
-  resync: resync,
-  popContext: popContext,
-  pushContext: pushContext,
-  setup: setup,
-  setKey: setKey,
   requeue: requeue,
   requeueComputedKeyAndDecorators: requeueComputedKeyAndDecorators,
   remove: remove,
   insertBefore: insertBefore,
   insertAfter: insertAfter,
-  updateSiblingKeys: updateSiblingKeys,
   unshiftContainer: unshiftContainer,
   pushContainer: pushContainer,
-  hoist: hoist,
   getOpposite: getOpposite,
   getCompletionRecords: getCompletionRecords,
   getSibling: getSibling,
@@ -5032,9 +4597,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 {
@@ -5054,7 +4619,7 @@ class TraversalContext {
       }
     }
     for (let i = 0; i < visitIndex; i++) {
-      queue[i].popContext();
+      popContext.call(queue[i]);
     }
     this.queue = null;
     return stop;
@@ -5090,6 +4655,205 @@ function traverseNode(node, opts, scope, state, path, skipKeys, visitSelf) {
   return false;
 }
 
+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() {}
   getScope() {}