@babel/traverse 8.0.0-alpha.1 → 8.0.0-alpha.10

package/lib/index.js

@@ -30,24 +30,174 @@ const ForAwaitStatement = ["ForOfStatement"];
 
 var virtualTypes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  ReferencedIdentifier: ReferencedIdentifier,
-  ReferencedMemberExpression: ReferencedMemberExpression,
   BindingIdentifier: BindingIdentifier,
-  Statement: Statement,
-  Expression: Expression,
-  Scope: Scope$1,
-  Referenced: Referenced,
   BlockScoped: BlockScoped,
-  Var: Var,
-  User: User,
+  ExistentialTypeParam: ExistentialTypeParam,
+  Expression: Expression,
+  Flow: Flow,
+  ForAwaitStatement: ForAwaitStatement,
   Generated: Generated,
+  NumericLiteralTypeAnnotation: NumericLiteralTypeAnnotation,
   Pure: Pure,
-  Flow: Flow,
+  Referenced: Referenced,
+  ReferencedIdentifier: ReferencedIdentifier,
+  ReferencedMemberExpression: ReferencedMemberExpression,
   RestProperty: RestProperty,
+  Scope: Scope$1,
   SpreadProperty: SpreadProperty,
-  ExistentialTypeParam: ExistentialTypeParam,
-  NumericLiteralTypeAnnotation: NumericLiteralTypeAnnotation,
-  ForAwaitStatement: ForAwaitStatement
+  Statement: Statement,
+  User: User,
+  Var: Var
+});
+
+const {
+  isBinding,
+  isBlockScoped: nodeIsBlockScoped,
+  isExportDeclaration: isExportDeclaration$1,
+  isExpression: nodeIsExpression,
+  isFlow: nodeIsFlow,
+  isForStatement,
+  isForXStatement,
+  isIdentifier: isIdentifier$6,
+  isImportDeclaration: isImportDeclaration$1,
+  isImportSpecifier,
+  isJSXIdentifier,
+  isJSXMemberExpression,
+  isMemberExpression: isMemberExpression$1,
+  isRestElement: nodeIsRestElement,
+  isReferenced: nodeIsReferenced,
+  isScope: nodeIsScope,
+  isStatement: nodeIsStatement,
+  isVar: nodeIsVar,
+  isVariableDeclaration: isVariableDeclaration$2,
+  react: react$1,
+  isForOfStatement
+} = _t;
+const {
+  isCompatTag
+} = react$1;
+function isReferencedIdentifier(opts) {
+  const {
+    node,
+    parent
+  } = this;
+  if (!isIdentifier$6(node, opts) && !isJSXMemberExpression(parent, opts)) {
+    if (isJSXIdentifier(node, opts)) {
+      if (isCompatTag(node.name)) return false;
+    } else {
+      return false;
+    }
+  }
+  return nodeIsReferenced(node, parent, this.parentPath.parent);
+}
+function isReferencedMemberExpression() {
+  const {
+    node,
+    parent
+  } = this;
+  return isMemberExpression$1(node) && nodeIsReferenced(node, parent);
+}
+function isBindingIdentifier() {
+  const {
+    node,
+    parent
+  } = this;
+  const grandparent = this.parentPath.parent;
+  return isIdentifier$6(node) && isBinding(node, parent, grandparent);
+}
+function isStatement$1() {
+  const {
+    node,
+    parent
+  } = this;
+  if (nodeIsStatement(node)) {
+    if (isVariableDeclaration$2(node)) {
+      if (isForXStatement(parent, {
+        left: node
+      })) return false;
+      if (isForStatement(parent, {
+        init: node
+      })) return false;
+    }
+    return true;
+  } else {
+    return false;
+  }
+}
+function isExpression$3() {
+  if (this.isIdentifier()) {
+    return this.isReferencedIdentifier();
+  } else {
+    return nodeIsExpression(this.node);
+  }
+}
+function isScope() {
+  return nodeIsScope(this.node, this.parent);
+}
+function isReferenced() {
+  return nodeIsReferenced(this.node, this.parent);
+}
+function isBlockScoped() {
+  return nodeIsBlockScoped(this.node);
+}
+function isVar() {
+  return nodeIsVar(this.node);
+}
+function isUser() {
+  return this.node && !!this.node.loc;
+}
+function isGenerated() {
+  return !this.isUser();
+}
+function isPure(constantsOnly) {
+  return this.scope.isPure(this.node, constantsOnly);
+}
+function isFlow() {
+  const {
+    node
+  } = this;
+  if (nodeIsFlow(node)) {
+    return true;
+  } else if (isImportDeclaration$1(node)) {
+    return node.importKind === "type" || node.importKind === "typeof";
+  } else if (isExportDeclaration$1(node)) {
+    return node.exportKind === "type";
+  } else if (isImportSpecifier(node)) {
+    return node.importKind === "type" || node.importKind === "typeof";
+  } else {
+    return false;
+  }
+}
+function isRestProperty() {
+  return nodeIsRestElement(this.node) && this.parentPath?.isObjectPattern();
+}
+function isSpreadProperty() {
+  return nodeIsRestElement(this.node) && this.parentPath?.isObjectExpression();
+}
+function isForAwaitStatement() {
+  return isForOfStatement(this.node, {
+    await: true
+  });
+}
+
+var NodePath_virtual_types_validator = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  isBindingIdentifier: isBindingIdentifier,
+  isBlockScoped: isBlockScoped,
+  isExpression: isExpression$3,
+  isFlow: isFlow,
+  isForAwaitStatement: isForAwaitStatement,
+  isGenerated: isGenerated,
+  isPure: isPure,
+  isReferenced: isReferenced,
+  isReferencedIdentifier: isReferencedIdentifier,
+  isReferencedMemberExpression: isReferencedMemberExpression,
+  isRestProperty: isRestProperty,
+  isScope: isScope,
+  isSpreadProperty: isSpreadProperty,
+  isStatement: isStatement$1,
+  isUser: isUser,
+  isVar: isVar
 });
 
 const {
@@ -63,7 +213,7 @@ function isVirtualType(type) {
 function isExplodedVisitor(visitor) {
   return visitor?._exploded;
 }
-function explode(visitor) {
+function explode$1(visitor) {
   if (isExplodedVisitor(visitor)) return visitor;
   visitor._exploded = true;
   for (const nodeType of Object.keys(visitor)) {
@@ -76,7 +226,7 @@ function explode(visitor) {
       visitor[part] = fns;
     }
   }
-  verify(visitor);
+  verify$1(visitor);
   delete visitor.__esModule;
   ensureEntranceObjects(visitor);
   ensureCallbackArrays(visitor);
@@ -131,7 +281,7 @@ function explode(visitor) {
   }
   return visitor;
 }
-function verify(visitor) {
+function verify$1(visitor) {
   if (visitor._verified) return;
   if (typeof visitor === "function") {
     throw new Error("You passed `traverse()` a function when it expected a visitor object, " + "are you sure you didn't mean `{ enter: Function }`?");
@@ -168,7 +318,7 @@ function validateVisitorMethods(path, val) {
 function merge(visitors, states = [], wrapper) {
   const mergedVisitor = {};
   for (let i = 0; i < visitors.length; i++) {
-    const visitor = explode(visitors[i]);
+    const visitor = explode$1(visitors[i]);
     const state = states[i];
     let topVisitor = visitor;
     if (state || wrapper) {
@@ -232,8 +382,10 @@ function ensureCallbackArrays(obj) {
   if (obj.exit && !Array.isArray(obj.exit)) obj.exit = [obj.exit];
 }
 function wrapCheck(nodeType, fn) {
+  const fnKey = `is${nodeType}`;
+  const validator = NodePath_virtual_types_validator[fnKey];
   const newFn = function (path) {
-    if (path[`is${nodeType}`]()) {
+    if (validator.call(path)) {
       return fn.apply(this, arguments);
     }
   };
@@ -257,32 +409,45 @@ function mergePair(dest, src) {
 
 var visitors = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  explode: explode$1,
   isExplodedVisitor: isExplodedVisitor,
-  explode: explode,
-  verify: verify,
-  merge: merge
+  merge: merge,
+  verify: verify$1
 });
 
-let path = new WeakMap();
+let pathsCache = new WeakMap();
 let scope = new WeakMap();
 function clear() {
   clearPath();
   clearScope();
 }
 function clearPath() {
-  path = new WeakMap();
+  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,
-  get path () { return path; },
-  get scope () { return scope; },
   clear: clear,
   clearPath: clearPath,
-  clearScope: clearScope
+  clearScope: clearScope,
+  getCachedPaths: getCachedPaths,
+  getOrCreateCachedPaths: getOrCreateCachedPaths,
+  get path () { return pathsCache; },
+  get scope () { return scope; }
 });
 
 const renameVisitor = {
@@ -310,7 +475,6 @@ const renameVisitor = {
     } = node.key;
     if (node.shorthand && (name === state.oldName || name === state.newName) && scope.getBindingIdentifier(name) === state.binding.identifier) {
       node.shorthand = false;
-      if (node.extra?.shorthand) node.extra.shorthand = false;
     }
   },
   "AssignmentExpression|Declaration|VariableDeclarator"(path, state) {
@@ -369,7 +533,7 @@ class Renamer {
       }
     }
     const blockToTraverse = scope.block;
-    traverseNode(blockToTraverse, explode(renameVisitor), scope, this, scope.path, {
+    traverseNode(blockToTraverse, explode$1(renameVisitor), scope, this, scope.path, {
       discriminant: true
     });
     {
@@ -399,9 +563,7 @@ class Binding {
     this.scope = scope;
     this.path = path;
     this.kind = kind;
-    if ((kind === "var" || kind === "hoisted") && isDeclaredInLoop(path || (() => {
-      throw new Error("Internal Babel error: unreachable ");
-    })())) {
+    if ((kind === "var" || kind === "hoisted") && isDeclaredInLoop(path)) {
       this.reassign(path);
     }
     this.clearValue();
@@ -465,10 +627,11 @@ const {
   NOT_LOCAL_BINDING,
   callExpression: callExpression$3,
   cloneNode: cloneNode$3,
-  getBindingIdentifiers: getBindingIdentifiers$1,
+  getBindingIdentifiers: getBindingIdentifiers$3,
   identifier: identifier$3,
   isArrayExpression,
   isBinary,
+  isCallExpression: isCallExpression$1,
   isClass,
   isClassBody,
   isClassDeclaration,
@@ -476,9 +639,10 @@ const {
   isExportDefaultDeclaration,
   isExportNamedDeclaration: isExportNamedDeclaration$1,
   isFunctionDeclaration,
-  isIdentifier: isIdentifier$6,
-  isImportDeclaration: isImportDeclaration$1,
+  isIdentifier: isIdentifier$5,
+  isImportDeclaration,
   isLiteral: isLiteral$1,
+  isMemberExpression,
   isMethod,
   isModuleSpecifier,
   isNullLiteral,
@@ -496,7 +660,6 @@ const {
   memberExpression: memberExpression$1,
   numericLiteral: numericLiteral$2,
   toIdentifier,
-  unaryExpression: unaryExpression$2,
   variableDeclaration: variableDeclaration$1,
   variableDeclarator: variableDeclarator$1,
   isRecordExpression,
@@ -505,15 +668,16 @@ const {
   isTopicReference,
   isMetaProperty,
   isPrivateName,
-  isExportDeclaration: isExportDeclaration$1
+  isExportDeclaration,
+  buildUndefinedNode: buildUndefinedNode$1
 } = _t;
 function gatherNodeParts(node, parts) {
   switch (node?.type) {
     default:
-      if (isImportDeclaration$1(node) || isExportDeclaration$1(node)) {
-        if ((isExportAllDeclaration(node) || isExportNamedDeclaration$1(node) || isImportDeclaration$1(node)) && node.source) {
+      if (isImportDeclaration(node) || isExportDeclaration(node)) {
+        if ((isExportAllDeclaration(node) || isExportNamedDeclaration$1(node) || isImportDeclaration(node)) && node.source) {
           gatherNodeParts(node.source, parts);
-        } else if ((isExportNamedDeclaration$1(node) || isImportDeclaration$1(node)) && node.specifiers?.length) {
+        } else if ((isExportNamedDeclaration$1(node) || isImportDeclaration(node)) && node.specifiers?.length) {
           for (const e of node.specifiers) gatherNodeParts(e, parts);
         } else if ((isExportDefaultDeclaration(node) || isExportNamedDeclaration$1(node)) && node.declaration) {
           gatherNodeParts(node.declaration, parts);
@@ -673,7 +837,7 @@ const collectorVisitor = {
         binding?.reference(path);
       } else if (isVariableDeclaration$1(declar)) {
         for (const decl of declar.declarations) {
-          for (const name of Object.keys(getBindingIdentifiers$1(decl))) {
+          for (const name of Object.keys(getBindingIdentifiers$3(decl))) {
             const binding = scope.getBinding(name);
             binding?.reference(path);
           }
@@ -720,8 +884,11 @@ const collectorVisitor = {
   },
   ClassExpression(path) {
     if (path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
-      path.scope.registerBinding("local", path);
+      path.scope.registerBinding("local", path.get("id"), path);
     }
+  },
+  TSTypeAnnotation(path) {
+    path.skip();
   }
 };
 let uid = 0;
@@ -761,7 +928,7 @@ class Scope {
       const shouldSkip = path.key === "key" || path.listKey === "decorators";
       path = path.parentPath;
       if (shouldSkip && path.isMethod()) path = path.parentPath;
-      if (path && path.isScope()) parent = path;
+      if (path?.isScope()) parent = path;
     } while (path && !parent);
     return parent?.scope;
   }
@@ -816,7 +983,7 @@ class Scope {
     if (isThisExpression(node) || isSuper$1(node) || isTopicReference(node)) {
       return true;
     }
-    if (isIdentifier$6(node)) {
+    if (isIdentifier$5(node)) {
       const binding = this.getBinding(node.name);
       if (binding) {
         return binding.constant;
@@ -883,7 +1050,7 @@ class Scope {
     console.log(sep);
   }
   toArray(node, i, arrayLikeIsIterable) {
-    if (isIdentifier$6(node)) {
+    if (isIdentifier$5(node)) {
       const binding = this.getBinding(node.name);
       if (binding?.constant && binding.path.isGenericType("Array")) {
         return node;
@@ -892,7 +1059,7 @@ class Scope {
     if (isArrayExpression(node)) {
       return node;
     }
-    if (isIdentifier$6(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]);
@@ -955,7 +1122,7 @@ class Scope {
     }
   }
   buildUndefinedNode() {
-    return unaryExpression$2("void", numericLiteral$2(0), true);
+    return buildUndefinedNode$1();
   }
   registerConstantViolation(path) {
     const ids = path.getBindingIdentifiers();
@@ -1016,7 +1183,7 @@ class Scope {
     return !!this.getProgramParent().references[name];
   }
   isPure(node, constantsOnly) {
-    if (isIdentifier$6(node)) {
+    if (isIdentifier$5(node)) {
       const binding = this.getBinding(node.name);
       if (!binding) return false;
       if (constantsOnly) return binding.constant;
@@ -1067,13 +1234,23 @@ class Scope {
       return true;
     } else if (isUnaryExpression(node)) {
       return this.isPure(node.argument, constantsOnly);
-    } else if (isTaggedTemplateExpression(node)) {
-      return matchesPattern$1(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly);
     } else if (isTemplateLiteral(node)) {
       for (const expression of node.expressions) {
         if (!this.isPure(expression, constantsOnly)) return false;
       }
       return true;
+    } else if (isTaggedTemplateExpression(node)) {
+      return matchesPattern$1(node.tag, "String.raw") && !this.hasBinding("String", {
+        noGlobals: true
+      }) && this.isPure(node.quasi, constantsOnly);
+    } else if (isMemberExpression(node)) {
+      return !node.computed && isIdentifier$5(node.object) && node.object.name === "Symbol" && isIdentifier$5(node.property) && node.property.name !== "for" && !this.hasBinding("Symbol", {
+        noGlobals: true
+      });
+    } else if (isCallExpression$1(node)) {
+      return matchesPattern$1(node.callee, "Symbol.for") && !this.hasBinding("Symbol", {
+        noGlobals: true
+      }) && node.arguments.length === 1 && _t.isStringLiteral(node.arguments[0]);
     } else {
       return isPureish(node);
     }
@@ -1165,9 +1342,9 @@ class Scope {
       kind = "var",
       id
     } = opts;
-    if (!init && !unique && (kind === "var" || kind === "let") && path.isFunction() && !path.node.name && _t.isCallExpression(path.parent, {
+    if (!init && !unique && (kind === "var" || kind === "let") && path.isFunction() && !path.node.name && isCallExpression$1(path.parent, {
       callee: path.node
-    }) && path.parent.arguments.length <= path.node.params.length && _t.isIdentifier(id)) {
+    }) && path.parent.arguments.length <= path.node.params.length && isIdentifier$5(id)) {
       path.pushContainer("params", id);
       path.scope.registerBinding("param", path.get("params")[path.node.params.length - 1]);
       return;
@@ -1446,20 +1623,6 @@ function inType(...candidateTypes) {
   return false;
 }
 
-var NodePath_ancestry = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  findParent: findParent,
-  find: find,
-  getFunctionParent: getFunctionParent,
-  getStatementParent: getStatementParent,
-  getEarliestCommonAncestorFrom: getEarliestCommonAncestorFrom,
-  getDeepestCommonAncestorFrom: getDeepestCommonAncestorFrom,
-  getAncestry: getAncestry,
-  isAncestor: isAncestor,
-  isDescendant: isDescendant,
-  inType: inType
-});
-
 const {
   createFlowUnionType,
   createTSUnionType,
@@ -1469,10 +1632,10 @@ const {
 } = _t;
 function createUnionType(types) {
   {
-    if (isFlowType(types[0])) {
+    if (types.every(v => isFlowType(v))) {
       return createFlowUnionType(types);
     }
-    if (isTSType(types[0])) {
+    if (types.every(v => isTSType(v))) {
       return createTSUnionType(types);
     }
   }
@@ -1638,7 +1801,7 @@ const {
   tupleTypeAnnotation,
   unionTypeAnnotation,
   voidTypeAnnotation: voidTypeAnnotation$1,
-  isIdentifier: isIdentifier$5
+  isIdentifier: isIdentifier$4
 } = _t;
 function VariableDeclarator() {
   if (!this.get("id").isIdentifier()) return;
@@ -1753,7 +1916,7 @@ function CallExpression() {
   } = this.node;
   if (isObjectKeys(callee)) {
     return arrayTypeAnnotation(stringTypeAnnotation$1());
-  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier$5(callee, {
+  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier$4(callee, {
     name: "Array"
   })) {
     return arrayTypeAnnotation(anyTypeAnnotation$1());
@@ -1789,36 +1952,36 @@ function resolveCall(callee) {
 
 var inferers = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  VariableDeclarator: VariableDeclarator,
-  TypeCastExpression: TypeCastExpression,
-  TSAsExpression: TSAsExpression,
-  TSNonNullExpression: TSNonNullExpression,
-  NewExpression: NewExpression,
-  TemplateLiteral: TemplateLiteral,
-  UnaryExpression: UnaryExpression,
-  BinaryExpression: BinaryExpression,
-  LogicalExpression: LogicalExpression,
-  ConditionalExpression: ConditionalExpression,
-  SequenceExpression: SequenceExpression,
-  ParenthesizedExpression: ParenthesizedExpression,
+  ArrayExpression: ArrayExpression,
+  ArrowFunctionExpression: Func,
   AssignmentExpression: AssignmentExpression,
-  UpdateExpression: UpdateExpression,
-  StringLiteral: StringLiteral,
-  NumericLiteral: NumericLiteral,
+  BinaryExpression: BinaryExpression,
   BooleanLiteral: BooleanLiteral,
+  CallExpression: CallExpression,
+  ClassDeclaration: Func,
+  ClassExpression: Func,
+  ConditionalExpression: ConditionalExpression,
+  FunctionDeclaration: Func,
+  FunctionExpression: Func,
+  Identifier: infererReference,
+  LogicalExpression: LogicalExpression,
+  NewExpression: NewExpression,
   NullLiteral: NullLiteral,
-  RegExpLiteral: RegExpLiteral,
+  NumericLiteral: NumericLiteral,
   ObjectExpression: ObjectExpression,
-  ArrayExpression: ArrayExpression,
+  ParenthesizedExpression: ParenthesizedExpression,
+  RegExpLiteral: RegExpLiteral,
   RestElement: RestElement,
-  FunctionExpression: Func,
-  ArrowFunctionExpression: Func,
-  FunctionDeclaration: Func,
-  ClassExpression: Func,
-  ClassDeclaration: Func,
-  CallExpression: CallExpression,
+  SequenceExpression: SequenceExpression,
+  StringLiteral: StringLiteral,
+  TSAsExpression: TSAsExpression,
+  TSNonNullExpression: TSNonNullExpression,
   TaggedTemplateExpression: TaggedTemplateExpression,
-  Identifier: infererReference
+  TemplateLiteral: TemplateLiteral,
+  TypeCastExpression: TypeCastExpression,
+  UnaryExpression: UnaryExpression,
+  UpdateExpression: UpdateExpression,
+  VariableDeclarator: VariableDeclarator
 });
 
 const {
@@ -1829,7 +1992,7 @@ const {
   isEmptyTypeAnnotation,
   isFlowBaseAnnotation,
   isGenericTypeAnnotation,
-  isIdentifier: isIdentifier$4,
+  isIdentifier: isIdentifier$3,
   isMixedTypeAnnotation,
   isNumberTypeAnnotation,
   isStringTypeAnnotation,
@@ -1948,42 +2111,40 @@ function isGenericType(genericName) {
       return true;
     }
   }
-  return isGenericTypeAnnotation(type) && isIdentifier$4(type.id, {
+  return isGenericTypeAnnotation(type) && isIdentifier$3(type.id, {
     name: genericName
-  }) || isTSTypeReference(type) && isIdentifier$4(type.typeName, {
+  }) || isTSTypeReference(type) && isIdentifier$3(type.typeName, {
     name: genericName
   });
 }
 
-var NodePath_inference = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  getTypeAnnotation: getTypeAnnotation,
-  _getTypeAnnotation: _getTypeAnnotation,
-  isBaseType: isBaseType,
-  couldBeBaseType: couldBeBaseType,
-  baseTypeStrictlyMatches: baseTypeStrictlyMatches,
-  isGenericType: isGenericType
-});
-
 const {
   FUNCTION_TYPES,
   arrowFunctionExpression: arrowFunctionExpression$2,
   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,
-  isExpression: isExpression$3,
+  isBlockStatement: isBlockStatement$1,
+  isEmptyStatement,
+  isExpression: isExpression$2,
+  isExpressionStatement,
+  isIfStatement,
   isProgram,
-  isStatement: isStatement$1,
+  isStatement,
+  isVariableDeclaration,
   removeComments,
   returnStatement: returnStatement$1,
-  toSequenceExpression,
+  sequenceExpression: sequenceExpression$1,
   validate: validate$1,
   yieldExpression
 } = _t;
@@ -1992,7 +2153,7 @@ function replaceWithMultiple(nodes) {
   nodes = this._verifyNodeList(nodes);
   inheritLeadingComments(nodes[0], this.node);
   inheritTrailingComments(nodes[nodes.length - 1], this.node);
-  path.get(this.parent)?.delete(this.node);
+  getCachedPaths(this.hub, this.parent)?.delete(this.node);
   this.node = this.container[this.key] = null;
   const paths = this.insertAfter(nodes);
   if (this.node) {
@@ -2030,7 +2191,7 @@ function replaceWith(replacementPath) {
   if (this.removed) {
     throw new Error("You can't replace this node, we've already removed it");
   }
-  let replacement = replacementPath instanceof NodePath ? replacementPath.node : replacementPath;
+  let replacement = replacementPath instanceof NodePath_Final ? replacementPath.node : replacementPath;
   if (!replacement) {
     throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead");
   }
@@ -2047,13 +2208,13 @@ 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$3(replacement)) {
+  if (this.isNodeType("Statement") && isExpression$2(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
       replacement = expressionStatement$2(replacement);
       nodePath = "expression";
     }
   }
-  if (this.isNodeType("Expression") && isStatement$1(replacement)) {
+  if (this.isNodeType("Expression") && isStatement(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
       return this.replaceExpressionWithStatements([replacement]);
     }
@@ -2079,14 +2240,18 @@ function _replaceWith(node) {
     validate$1(this.parent, this.key, node);
   }
   this.debug(`Replace with ${node?.type}`);
-  path.get(this.parent)?.set(node, this).delete(this.node);
+  getCachedPaths(this.hub, this.parent)?.set(node, this).delete(this.node);
   this.node = this.container[this.key] = node;
 }
 function replaceExpressionWithStatements(nodes) {
   this.resync();
-  const nodesAsSequenceExpression = toSequenceExpression(nodes, this.scope);
-  if (nodesAsSequenceExpression) {
-    return this.replaceWith(nodesAsSequenceExpression)[0].get("expressions");
+  const declars = [];
+  const nodesAsSingleExpression = gatherSequenceExpressions(nodes, declars);
+  if (nodesAsSingleExpression) {
+    for (const id of declars) this.scope.push({
+      id
+    });
+    return this.replaceWith(nodesAsSingleExpression)[0].get("expressions");
   }
   const functionParent = this.getFunctionParent();
   const isParentAsync = functionParent?.is("async");
@@ -2133,6 +2298,53 @@ function replaceExpressionWithStatements(nodes) {
   }
   return newCallee.get("body.body");
 }
+function gatherSequenceExpressions(nodes, declars) {
+  const exprs = [];
+  let ensureLastUndefined = true;
+  for (const node of nodes) {
+    if (!isEmptyStatement(node)) {
+      ensureLastUndefined = false;
+    }
+    if (isExpression$2(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);
+        for (const key of Object.keys(bindings)) {
+          declars.push(cloneNode$2(bindings[key]));
+        }
+        if (declar.init) {
+          exprs.push(assignmentExpression$2("=", declar.id, declar.init));
+        }
+      }
+      ensureLastUndefined = true;
+    } else if (isIfStatement(node)) {
+      const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], declars) : buildUndefinedNode();
+      const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], declars) : buildUndefinedNode();
+      if (!consequent || !alternate) return;
+      exprs.push(conditionalExpression$1(node.test, consequent, alternate));
+    } else if (isBlockStatement$1(node)) {
+      const body = gatherSequenceExpressions(node.body, declars);
+      if (!body) return;
+      exprs.push(body);
+    } else if (isEmptyStatement(node)) {
+      if (nodes.indexOf(node) === 0) {
+        ensureLastUndefined = true;
+      }
+    } else {
+      return;
+    }
+  }
+  if (ensureLastUndefined) exprs.push(buildUndefinedNode());
+  if (exprs.length === 1) {
+    return exprs[0];
+  } else {
+    return sequenceExpression$1(exprs);
+  }
+}
 function replaceInline(nodes) {
   this.resync();
   if (Array.isArray(nodes)) {
@@ -2149,20 +2361,14 @@ function replaceInline(nodes) {
   }
 }
 
-var NodePath_replacement = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  replaceWithMultiple: replaceWithMultiple,
-  replaceWithSourceString: replaceWithSourceString,
-  replaceWith: replaceWith,
-  _replaceWith: _replaceWith,
-  replaceExpressionWithStatements: replaceExpressionWithStatements,
-  replaceInline: replaceInline
-});
-
-const VALID_CALLEES = ["String", "Number", "Math"];
+const VALID_OBJECT_CALLEES = ["Number", "String", "Math"];
+const VALID_IDENTIFIER_CALLEES = ["isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "btoa", "atob"];
 const INVALID_METHODS = ["random"];
-function isValidCallee(val) {
-  return VALID_CALLEES.includes(val);
+function isValidObjectCallee(val) {
+  return VALID_OBJECT_CALLEES.includes(val);
+}
+function isValidIdentifierCallee(val) {
+  return VALID_IDENTIFIER_CALLEES.includes(val);
 }
 function isInvalidMethod(val) {
   return INVALID_METHODS.includes(val);
@@ -2437,15 +2643,18 @@ function _evaluate(path, state) {
     const callee = path.get("callee");
     let context;
     let func;
-    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && isValidCallee(callee.node.name)) {
+    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && (isValidObjectCallee(callee.node.name) || isValidIdentifierCallee(callee.node.name))) {
       func = global[callee.node.name];
     }
     if (callee.isMemberExpression()) {
       const object = callee.get("object");
       const property = callee.get("property");
-      if (object.isIdentifier() && property.isIdentifier() && isValidCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
+      if (object.isIdentifier() && property.isIdentifier() && isValidObjectCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
         context = global[object.node.name];
-        func = context[property.node.name];
+        const key = property.node.name;
+        if (Object.hasOwn(context, key)) {
+          func = context[key];
+        }
       }
       if (object.isLiteral() && property.isIdentifier()) {
         const type = typeof object.node.value;
@@ -2491,12 +2700,6 @@ function evaluate() {
   };
 }
 
-var NodePath_evaluation = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  evaluateTruthy: evaluateTruthy,
-  evaluate: evaluate
-});
-
 const {
   arrowFunctionExpression: arrowFunctionExpression$1,
   assignmentExpression: assignmentExpression$1,
@@ -2506,7 +2709,7 @@ const {
   conditionalExpression,
   expressionStatement: expressionStatement$1,
   identifier,
-  isIdentifier: isIdentifier$3,
+  isIdentifier: isIdentifier$2,
   jsxIdentifier,
   logicalExpression,
   LOGICAL_OPERATORS,
@@ -2534,7 +2737,7 @@ function toComputedKey() {
     throw new ReferenceError("todo");
   }
   if (!this.node.computed) {
-    if (isIdentifier$3(key)) key = stringLiteral(key.name);
+    if (isIdentifier$2(key)) key = stringLiteral(key.name);
   }
   return key;
 }
@@ -2944,20 +3147,12 @@ function getScopeInformation(fnPath) {
   };
 }
 
-var NodePath_conversion = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  toComputedKey: toComputedKey,
-  ensureBlock: ensureBlock,
-  unwrapFunctionEnvironment: unwrapFunctionEnvironment,
-  arrowFunctionToExpression: arrowFunctionToExpression
-});
-
 const {
   STATEMENT_OR_BLOCK_KEYS,
   VISITOR_KEYS: VISITOR_KEYS$3,
   isBlockStatement,
-  isExpression: isExpression$2,
-  isIdentifier: isIdentifier$2,
+  isExpression: isExpression$1,
+  isIdentifier: isIdentifier$1,
   isLiteral,
   isStringLiteral,
   isType,
@@ -2967,7 +3162,7 @@ function matchesPattern(pattern, allowPartial) {
   return _matchesPattern(this.node, pattern, allowPartial);
 }
 function has(key) {
-  const val = this.node && this.node[key];
+  const val = this.node?.[key];
   if (val && Array.isArray(val)) {
     return !!val.length;
   } else {
@@ -2997,7 +3192,7 @@ function canSwapBetweenExpressionAndStatement(replacement) {
   if (this.isExpression()) {
     return isBlockStatement(replacement);
   } else if (this.isBlockStatement()) {
-    return isExpression$2(replacement);
+    return isExpression$1(replacement);
   }
   return false;
 }
@@ -3052,7 +3247,7 @@ function referencesImport(moduleSource, importName) {
   if (path.isImportNamespaceSpecifier() && importName === "*") {
     return true;
   }
-  if (path.isImportSpecifier() && isIdentifier$2(path.node.imported, {
+  if (path.isImportSpecifier() && isIdentifier$1(path.node.imported, {
     name: importName
   })) {
     return true;
@@ -3281,6 +3476,18 @@ function isConstantExpression() {
     } = this.node;
     return operator !== "in" && operator !== "instanceof" && this.get("left").isConstantExpression() && this.get("right").isConstantExpression();
   }
+  if (this.isMemberExpression()) {
+    return !this.node.computed && this.get("object").isIdentifier({
+      name: "Symbol"
+    }) && !this.scope.hasBinding("Symbol", {
+      noGlobals: true
+    });
+  }
+  if (this.isCallExpression()) {
+    return this.node.arguments.length === 1 && this.get("callee").matchesPattern("Symbol.for") && !this.scope.hasBinding("Symbol", {
+      noGlobals: true
+    }) && this.get("arguments")[0].isStringLiteral();
+  }
   return false;
 }
 function isInStrictMode() {
@@ -3310,29 +3517,6 @@ function isInStrictMode() {
   return !!strictParent;
 }
 
-var NodePath_introspection = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  matchesPattern: matchesPattern,
-  has: has,
-  isStatic: isStatic,
-  is: is,
-  isnt: isnt,
-  equals: equals,
-  isNodeType: isNodeType,
-  canHaveVariableDeclarationOrExpression: canHaveVariableDeclarationOrExpression,
-  canSwapBetweenExpressionAndStatement: canSwapBetweenExpressionAndStatement,
-  isCompletionRecord: isCompletionRecord,
-  isStatementOrBlock: isStatementOrBlock,
-  referencesImport: referencesImport,
-  getSource: getSource,
-  willIMaybeExecuteBefore: willIMaybeExecuteBefore,
-  _guessExecutionStatusRelativeTo: _guessExecutionStatusRelativeTo,
-  resolve: resolve,
-  _resolve: _resolve,
-  isConstantExpression: isConstantExpression,
-  isInStrictMode: isInStrictMode
-});
-
 function call(key) {
   const opts = this.opts;
   this.debug(key);
@@ -3523,31 +3707,6 @@ function _getQueueContexts() {
   return contexts;
 }
 
-var NodePath_context = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  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
-});
-
 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) {
@@ -3578,6 +3737,9 @@ const hooks = [function (self, parent) {
   }
 }];
 
+const {
+  getBindingIdentifiers: getBindingIdentifiers$1
+} = _t;
 function remove() {
   this._assertUnremoved();
   this.resync();
@@ -3593,12 +3755,14 @@ function remove() {
   this._markRemoved();
 }
 function _removeFromScope() {
-  const bindings = this.getBindingIdentifiers();
+  const bindings = getBindingIdentifiers$1(this.node, false, false, true);
   Object.keys(bindings).forEach(name => this.scope.removeBinding(name));
 }
 function _callRemovalHooks() {
-  for (const fn of hooks) {
-    if (fn(this, this.parentPath)) return true;
+  if (this.parentPath) {
+    for (const fn of hooks) {
+      if (fn(this, this.parentPath)) return true;
+    }
   }
 }
 function _remove() {
@@ -3611,7 +3775,9 @@ function _remove() {
 }
 function _markRemoved() {
   this._traverseFlags |= SHOULD_SKIP | REMOVED;
-  if (this.parent) path.get(this.parent).delete(this.node);
+  if (this.parent) {
+    getCachedPaths(this.hub, this.parent).delete(this.node);
+  }
   this.node = null;
 }
 function _assertUnremoved() {
@@ -3620,18 +3786,8 @@ function _assertUnremoved() {
   }
 }
 
-var NodePath_removal = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  remove: remove,
-  _removeFromScope: _removeFromScope,
-  _callRemovalHooks: _callRemovalHooks,
-  _remove: _remove,
-  _markRemoved: _markRemoved,
-  _assertUnremoved: _assertUnremoved
-});
-
 const {
-  react: react$1
+  react
 } = _t;
 const {
   cloneNode: cloneNode$1,
@@ -3641,7 +3797,7 @@ const {
 } = _t;
 const referenceVisitor = {
   ReferencedIdentifier(path, state) {
-    if (path.isJSXIdentifier() && react$1.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
+    if (path.isJSXIdentifier() && react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
       return;
     }
     if (path.node.name === "this") {
@@ -3802,8 +3958,8 @@ const {
   isAssignmentExpression,
   isCallExpression,
   isExportNamedDeclaration,
-  isExpression: isExpression$1,
-  isIdentifier: isIdentifier$1,
+  isExpression,
+  isIdentifier,
   isSequenceExpression,
   isSuper,
   thisExpression
@@ -3864,7 +4020,7 @@ function isHiddenInSequenceExpression(path) {
   return isSequenceExpression(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath));
 }
 function isAlmostConstantAssignment(node, scope) {
-  if (!isAssignmentExpression(node) || !isIdentifier$1(node.left)) {
+  if (!isAssignmentExpression(node) || !isIdentifier(node.left)) {
     return false;
   }
   const blockScope = scope.getBlockParent();
@@ -3882,21 +4038,22 @@ function insertAfter(nodes_) {
   } = this;
   if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
     return parentPath.insertAfter(nodes.map(node => {
-      return isExpression$1(node) ? expressionStatement(node) : node;
+      return isExpression(node) ? expressionStatement(node) : node;
     }));
   } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
-    if (this.node) {
-      const node = this.node;
+    const self = this;
+    if (self.node) {
+      const node = self.node;
       let {
         scope
       } = this;
       if (scope.path.isPattern()) {
         assertExpression(node);
-        this.replaceWith(callExpression(arrowFunctionExpression([], node), []));
-        this.get("callee.body").insertAfter(nodes);
-        return [this];
+        self.replaceWith(callExpression(arrowFunctionExpression([], node), []));
+        self.get("callee.body").insertAfter(nodes);
+        return [self];
       }
-      if (isHiddenInSequenceExpression(this)) {
+      if (isHiddenInSequenceExpression(self)) {
         nodes.unshift(node);
       } else if (isCallExpression(node) && isSuper(node.callee)) {
         nodes.unshift(node);
@@ -3932,7 +4089,7 @@ function insertAfter(nodes_) {
 }
 function updateSiblingKeys(fromIndex, incrementBy) {
   if (!this.parent) return;
-  const paths = path.get(this.parent);
+  const paths = getCachedPaths(this.hub, this.parent) || [];
   for (const [, path] of paths) {
     if (typeof path.key === "number" && path.key >= fromIndex) {
       path.key += incrementBy;
@@ -3955,7 +4112,7 @@ function _verifyNodeList(nodes) {
       msg = "contains a non-object node";
     } else if (!node.type) {
       msg = "without a type";
-    } else if (node instanceof NodePath) {
+    } else if (node instanceof NodePath_Final) {
       msg = "has a NodePath when it expected a raw object";
     }
     if (msg) {
@@ -3968,7 +4125,7 @@ function _verifyNodeList(nodes) {
 function unshiftContainer(listKey, nodes) {
   this._assertUnremoved();
   nodes = this._verifyNodeList(nodes);
-  const path = NodePath.get({
+  const path = NodePath_Final.get({
     parentPath: this,
     parent: this.node,
     container: this.node[listKey],
@@ -3981,7 +4138,7 @@ function pushContainer(listKey, nodes) {
   this._assertUnremoved();
   const verifiedNodes = this._verifyNodeList(nodes);
   const container = this.node[listKey];
-  const path = NodePath.get({
+  const path = NodePath_Final.get({
     parentPath: this,
     parent: this.node,
     container: container,
@@ -3995,24 +4152,9 @@ function hoist(scope = this.scope) {
   return hoister.run();
 }
 
-var NodePath_modification = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  insertBefore: insertBefore,
-  _containerInsert: _containerInsert,
-  _containerInsertBefore: _containerInsertBefore,
-  _containerInsertAfter: _containerInsertAfter,
-  insertAfter: insertAfter,
-  updateSiblingKeys: updateSiblingKeys,
-  _verifyNodeList: _verifyNodeList,
-  unshiftContainer: unshiftContainer,
-  pushContainer: pushContainer,
-  hoist: hoist
-});
-
 const {
   getBindingIdentifiers: _getBindingIdentifiers,
   getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
-  isDeclaration,
   numericLiteral,
   unaryExpression
 } = _t;
@@ -4185,7 +4327,7 @@ function getCompletionRecords() {
   return records.map(r => r.path);
 }
 function getSibling(key) {
-  return NodePath.get({
+  return NodePath_Final.get({
     parentPath: this.parentPath,
     parent: this.parent,
     container: this.container,
@@ -4233,7 +4375,7 @@ function _getKey(key, context) {
   const container = node[key];
   if (Array.isArray(container)) {
     return container.map((_, i) => {
-      return NodePath.get({
+      return NodePath_Final.get({
         listKey: key,
         parentPath: this,
         parent: node,
@@ -4242,7 +4384,7 @@ function _getKey(key, context) {
       }).setContext(context);
     });
   } else {
-    return NodePath.get({
+    return NodePath_Final.get({
       parentPath: this,
       parent: node,
       container: node,
@@ -4291,7 +4433,7 @@ function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
     }
     if (id.isExportDeclaration()) {
       const declaration = id.get("declaration");
-      if (isDeclaration(declaration)) {
+      if (declaration.isDeclaration()) {
         search.push(declaration);
       }
       continue;
@@ -4323,24 +4465,6 @@ function getOuterBindingIdentifierPaths(duplicates = false) {
   return this.getBindingIdentifierPaths(duplicates, true);
 }
 
-var NodePath_family = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  getOpposite: getOpposite,
-  getCompletionRecords: getCompletionRecords,
-  getSibling: getSibling,
-  getPrevSibling: getPrevSibling,
-  getNextSibling: getNextSibling,
-  getAllNextSiblings: getAllNextSiblings,
-  getAllPrevSiblings: getAllPrevSiblings,
-  get: get,
-  _getKey: _getKey,
-  _getPattern: _getPattern,
-  getBindingIdentifiers: getBindingIdentifiers,
-  getOuterBindingIdentifiers: getOuterBindingIdentifiers,
-  getBindingIdentifierPaths: getBindingIdentifierPaths,
-  getOuterBindingIdentifierPaths: getOuterBindingIdentifierPaths
-});
-
 const {
   addComment: _addComment,
   addComments: _addComments
@@ -4370,12 +4494,10 @@ function shareCommentsWithSiblings() {
   }
 }
 function removeIfExisting(list, toRemove) {
-  if (!toRemove) return list;
-  let lastFoundIndex = -1;
+  if (!toRemove?.length) return list;
+  const set = new Set(toRemove);
   return list.filter(el => {
-    const i = toRemove.indexOf(el, lastFoundIndex);
-    if (i === -1) return true;
-    lastFoundIndex = i;
+    return !set.has(el);
   });
 }
 function addComment(type, content, line) {
@@ -4385,171 +4507,6 @@ function addComments(type, comments) {
   _addComments(this.node, type, comments);
 }
 
-var NodePath_comments = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  shareCommentsWithSiblings: shareCommentsWithSiblings,
-  addComment: addComment,
-  addComments: addComments
-});
-
-const {
-  isBinding,
-  isBlockScoped: nodeIsBlockScoped,
-  isExportDeclaration,
-  isExpression: nodeIsExpression,
-  isFlow: nodeIsFlow,
-  isForStatement,
-  isForXStatement,
-  isIdentifier,
-  isImportDeclaration,
-  isImportSpecifier,
-  isJSXIdentifier,
-  isJSXMemberExpression,
-  isMemberExpression,
-  isRestElement: nodeIsRestElement,
-  isReferenced: nodeIsReferenced,
-  isScope: nodeIsScope,
-  isStatement: nodeIsStatement,
-  isVar: nodeIsVar,
-  isVariableDeclaration,
-  react,
-  isForOfStatement
-} = _t;
-const {
-  isCompatTag
-} = react;
-function isReferencedIdentifier(opts) {
-  const {
-    node,
-    parent
-  } = this;
-  if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {
-    if (isJSXIdentifier(node, opts)) {
-      if (isCompatTag(node.name)) return false;
-    } else {
-      return false;
-    }
-  }
-  return nodeIsReferenced(node, parent, this.parentPath.parent);
-}
-function isReferencedMemberExpression() {
-  const {
-    node,
-    parent
-  } = this;
-  return isMemberExpression(node) && nodeIsReferenced(node, parent);
-}
-function isBindingIdentifier() {
-  const {
-    node,
-    parent
-  } = this;
-  const grandparent = this.parentPath.parent;
-  return isIdentifier(node) && isBinding(node, parent, grandparent);
-}
-function isStatement() {
-  const {
-    node,
-    parent
-  } = this;
-  if (nodeIsStatement(node)) {
-    if (isVariableDeclaration(node)) {
-      if (isForXStatement(parent, {
-        left: node
-      })) return false;
-      if (isForStatement(parent, {
-        init: node
-      })) return false;
-    }
-    return true;
-  } else {
-    return false;
-  }
-}
-function isExpression() {
-  if (this.isIdentifier()) {
-    return this.isReferencedIdentifier();
-  } else {
-    return nodeIsExpression(this.node);
-  }
-}
-function isScope() {
-  return nodeIsScope(this.node, this.parent);
-}
-function isReferenced() {
-  return nodeIsReferenced(this.node, this.parent);
-}
-function isBlockScoped() {
-  return nodeIsBlockScoped(this.node);
-}
-function isVar() {
-  return nodeIsVar(this.node);
-}
-function isUser() {
-  return this.node && !!this.node.loc;
-}
-function isGenerated() {
-  return !this.isUser();
-}
-function isPure(constantsOnly) {
-  return this.scope.isPure(this.node, constantsOnly);
-}
-function isFlow() {
-  const {
-    node
-  } = this;
-  if (nodeIsFlow(node)) {
-    return true;
-  } else if (isImportDeclaration(node)) {
-    return node.importKind === "type" || node.importKind === "typeof";
-  } else if (isExportDeclaration(node)) {
-    return node.exportKind === "type";
-  } else if (isImportSpecifier(node)) {
-    return node.importKind === "type" || node.importKind === "typeof";
-  } else {
-    return false;
-  }
-}
-function isRestProperty() {
-  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern();
-}
-function isSpreadProperty() {
-  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression();
-}
-function isForAwaitStatement() {
-  return isForOfStatement(this.node, {
-    await: true
-  });
-}
-function isExistentialTypeParam() {
-  throw new Error("`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.");
-}
-function isNumericLiteralTypeAnnotation() {
-  throw new Error("`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.");
-}
-
-var NodePath_virtual_types_validator = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isReferencedIdentifier: isReferencedIdentifier,
-  isReferencedMemberExpression: isReferencedMemberExpression,
-  isBindingIdentifier: isBindingIdentifier,
-  isStatement: isStatement,
-  isExpression: isExpression,
-  isScope: isScope,
-  isReferenced: isReferenced,
-  isBlockScoped: isBlockScoped,
-  isVar: isVar,
-  isUser: isUser,
-  isGenerated: isGenerated,
-  isPure: isPure,
-  isFlow: isFlow,
-  isRestProperty: isRestProperty,
-  isSpreadProperty: isSpreadProperty,
-  isForAwaitStatement: isForAwaitStatement,
-  isExistentialTypeParam: isExistentialTypeParam,
-  isNumericLiteralTypeAnnotation: isNumericLiteralTypeAnnotation
-});
-
 const {
   validate
 } = _t;
@@ -4557,7 +4514,7 @@ const debug = buildDebug("babel");
 const REMOVED = 1 << 0;
 const SHOULD_STOP = 1 << 1;
 const SHOULD_SKIP = 1 << 2;
-class NodePath {
+const NodePath_Final = class NodePath {
   constructor(hub, parent) {
     this.parent = parent;
     this.hub = hub;
@@ -4569,6 +4526,24 @@ class NodePath {
   state = null;
   opts = null;
   _traverseFlags = 0;
+  get removed() {
+    return (this._traverseFlags & 1) > 0;
+  }
+  set removed(v) {
+    if (v) this._traverseFlags |= 1;else this._traverseFlags &= -2;
+  }
+  get shouldStop() {
+    return (this._traverseFlags & 2) > 0;
+  }
+  set shouldStop(v) {
+    if (v) this._traverseFlags |= 2;else this._traverseFlags &= -3;
+  }
+  get shouldSkip() {
+    return (this._traverseFlags & 4) > 0;
+  }
+  set shouldSkip(v) {
+    if (v) this._traverseFlags |= 4;else this._traverseFlags &= -5;
+  }
   skipKeys = null;
   parentPath = null;
   container = null;
@@ -4591,18 +4566,14 @@ class NodePath {
       throw new Error("To get a node path the parent needs to exist");
     }
     const targetNode = container[key];
-    let paths = path.get(parent);
-    if (!paths) {
-      paths = new Map();
-      path.set(parent, paths);
+    const paths = getOrCreateCachedPaths(hub, parent);
+    let path = paths.get(targetNode);
+    if (!path) {
+      path = new NodePath(hub, parent);
+      if (targetNode) paths.set(targetNode, path);
     }
-    let path$1 = paths.get(targetNode);
-    if (!path$1) {
-      path$1 = new NodePath(hub, parent);
-      if (targetNode) paths.set(targetNode, path$1);
-    }
-    path$1.setup(parentPath, container, listKey, key);
-    return path$1;
+    path.setup(parentPath, container, listKey, key);
+    return path;
   }
   getScope(scope) {
     return this.isScope() ? new Scope(this) : scope;
@@ -4662,51 +4633,124 @@ class NodePath {
   get parentKey() {
     return this.listKey || this.key;
   }
-  get shouldSkip() {
-    return !!(this._traverseFlags & SHOULD_SKIP);
-  }
-  set shouldSkip(v) {
-    if (v) {
-      this._traverseFlags |= SHOULD_SKIP;
-    } else {
-      this._traverseFlags &= ~SHOULD_SKIP;
-    }
-  }
-  get shouldStop() {
-    return !!(this._traverseFlags & SHOULD_STOP);
-  }
-  set shouldStop(v) {
-    if (v) {
-      this._traverseFlags |= SHOULD_STOP;
-    } else {
-      this._traverseFlags &= ~SHOULD_STOP;
-    }
-  }
-  get removed() {
-    return !!(this._traverseFlags & REMOVED);
-  }
-  set removed(v) {
-    if (v) {
-      this._traverseFlags |= REMOVED;
-    } else {
-      this._traverseFlags &= ~REMOVED;
-    }
-  }
-}
-Object.assign(NodePath.prototype, NodePath_ancestry, NodePath_inference, NodePath_replacement, NodePath_evaluation, NodePath_conversion, NodePath_introspection, NodePath_context, NodePath_removal, NodePath_modification, NodePath_family, NodePath_comments);
+};
+const methods = {
+  findParent: findParent,
+  find: find,
+  getFunctionParent: getFunctionParent,
+  getStatementParent: getStatementParent,
+  getEarliestCommonAncestorFrom: getEarliestCommonAncestorFrom,
+  getDeepestCommonAncestorFrom: getDeepestCommonAncestorFrom,
+  getAncestry: getAncestry,
+  isAncestor: isAncestor,
+  isDescendant: isDescendant,
+  inType: inType,
+  getTypeAnnotation: getTypeAnnotation,
+  _getTypeAnnotation: _getTypeAnnotation,
+  isBaseType: isBaseType,
+  couldBeBaseType: couldBeBaseType,
+  baseTypeStrictlyMatches: baseTypeStrictlyMatches,
+  isGenericType: isGenericType,
+  replaceWithMultiple: replaceWithMultiple,
+  replaceWithSourceString: replaceWithSourceString,
+  replaceWith: replaceWith,
+  _replaceWith: _replaceWith,
+  replaceExpressionWithStatements: replaceExpressionWithStatements,
+  replaceInline: replaceInline,
+  evaluateTruthy: evaluateTruthy,
+  evaluate: evaluate,
+  toComputedKey: toComputedKey,
+  ensureBlock: ensureBlock,
+  unwrapFunctionEnvironment: unwrapFunctionEnvironment,
+  arrowFunctionToExpression: arrowFunctionToExpression,
+  matchesPattern: matchesPattern,
+  has: has,
+  isStatic: isStatic,
+  is: is,
+  isnt: isnt,
+  equals: equals,
+  isNodeType: isNodeType,
+  canHaveVariableDeclarationOrExpression: canHaveVariableDeclarationOrExpression,
+  canSwapBetweenExpressionAndStatement: canSwapBetweenExpressionAndStatement,
+  isCompletionRecord: isCompletionRecord,
+  isStatementOrBlock: isStatementOrBlock,
+  referencesImport: referencesImport,
+  getSource: getSource,
+  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,
+  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,
+  getPrevSibling: getPrevSibling,
+  getNextSibling: getNextSibling,
+  getAllNextSiblings: getAllNextSiblings,
+  getAllPrevSiblings: getAllPrevSiblings,
+  get: get,
+  _getKey: _getKey,
+  _getPattern: _getPattern,
+  getBindingIdentifiers: getBindingIdentifiers,
+  getOuterBindingIdentifiers: getOuterBindingIdentifiers,
+  getBindingIdentifierPaths: getBindingIdentifierPaths,
+  getOuterBindingIdentifierPaths: getOuterBindingIdentifierPaths,
+  shareCommentsWithSiblings: shareCommentsWithSiblings,
+  addComment: addComment,
+  addComments: addComments
+};
+Object.assign(NodePath_Final.prototype, methods);
 for (const type of _t.TYPES) {
   const typeKey = `is${type}`;
   const fn = _t[typeKey];
-  NodePath.prototype[typeKey] = function (opts) {
+  NodePath_Final.prototype[typeKey] = function (opts) {
     return fn(this.node, opts);
   };
-  NodePath.prototype[`assert${type}`] = function (opts) {
+  NodePath_Final.prototype[`assert${type}`] = function (opts) {
     if (!fn(this.node, opts)) {
       throw new TypeError(`Expected node path of type ${type}`);
     }
   };
 }
-Object.assign(NodePath.prototype, NodePath_virtual_types_validator);
+Object.assign(NodePath_Final.prototype, NodePath_virtual_types_validator);
 for (const type of Object.keys(virtualTypes)) {
   if (type[0] === "_") continue;
   if (!_t.TYPES.includes(type)) _t.TYPES.push(type);
@@ -4738,7 +4782,7 @@ class TraversalContext {
     return false;
   }
   create(node, container, key, listKey) {
-    return NodePath.get({
+    return NodePath_Final.get({
       parentPath: this.parentPath,
       parent: node,
       container,
@@ -4778,7 +4822,10 @@ class TraversalContext {
     this.priorityQueue = [];
     const visited = new WeakSet();
     let stop = false;
-    for (const path of queue) {
+    let visitIndex = 0;
+    for (; visitIndex < queue.length;) {
+      const path = queue[visitIndex];
+      visitIndex++;
       path.resync();
       if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) {
         path.pushContext(this);
@@ -4800,8 +4847,8 @@ class TraversalContext {
         if (stop) break;
       }
     }
-    for (const path of queue) {
-      path.popContext();
+    for (let i = 0; i < visitIndex; i++) {
+      queue[i].popContext();
     }
     this.queue = null;
     return stop;
@@ -4820,12 +4867,16 @@ class TraversalContext {
 const {
   VISITOR_KEYS: VISITOR_KEYS$1
 } = _t;
-function traverseNode(node, opts, scope, state, path, skipKeys) {
+function traverseNode(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 (visitSelf) {
+    if (skipKeys?.[path.parentKey]) return false;
+    return context.visitQueue([path]);
+  }
   for (const key of keys) {
-    if (skipKeys && skipKeys[key]) continue;
+    if (skipKeys?.[key]) continue;
     if (context.visit(node, key)) {
       return true;
     }
@@ -4849,22 +4900,25 @@ const {
   removeProperties,
   traverseFast
 } = _t;
-function traverse(parent, opts = {}, scope, state, parentPath) {
+function traverse(parent, opts = {}, scope, state, parentPath, visitSelf) {
   if (!parent) return;
   if (!opts.noScope && !scope) {
     if (parent.type !== "Program" && parent.type !== "File") {
       throw new Error("You must pass a scope and parentPath unless traversing a Program/File. " + `Instead of that you tried to traverse a ${parent.type} node without ` + "passing scope and parentPath.");
     }
   }
+  if (!parentPath && visitSelf) {
+    throw new Error("visitSelf can only be used when providing a NodePath.");
+  }
   if (!VISITOR_KEYS[parent.type]) {
     return;
   }
-  explode(opts);
-  traverseNode(parent, opts, scope, state, parentPath);
+  explode$1(opts);
+  traverseNode(parent, opts, scope, state, parentPath, null, visitSelf);
 }
 traverse.visitors = visitors;
-traverse.verify = verify;
-traverse.explode = explode;
+traverse.verify = verify$1;
+traverse.explode = explode$1;
 traverse.cheap = function (node, enter) {
   traverseFast(node, enter);
   return;
@@ -4874,7 +4928,6 @@ traverse.node = function (node, opts, scope, state, path, skipKeys) {
 };
 traverse.clearNode = function (node, opts) {
   removeProperties(node, opts);
-  path.delete(node);
 };
 traverse.removeProperties = function (tree, opts) {
   traverseFast(tree, traverse.clearNode, opts);
@@ -4902,5 +4955,5 @@ traverse.hasType = function (tree, type, denylistTypes) {
 };
 traverse.cache = cache;
 
-export { Hub, NodePath, Scope, traverse as default, visitors };
+export { Hub, NodePath_Final as NodePath, Scope, traverse as default, visitors };
 //# sourceMappingURL=index.js.map