@babel/traverse 8.0.0-alpha.7 → 8.0.0-alpha.9

package/lib/index.js

@@ -63,7 +63,7 @@ const {
   isImportSpecifier,
   isJSXIdentifier,
   isJSXMemberExpression,
-  isMemberExpression,
+  isMemberExpression: isMemberExpression$1,
   isRestElement: nodeIsRestElement,
   isReferenced: nodeIsReferenced,
   isScope: nodeIsScope,
@@ -95,7 +95,7 @@ function isReferencedMemberExpression() {
     node,
     parent
   } = this;
-  return isMemberExpression(node) && nodeIsReferenced(node, parent);
+  return isMemberExpression$1(node) && nodeIsReferenced(node, parent);
 }
 function isBindingIdentifier() {
   const {
@@ -169,10 +169,10 @@ function isFlow() {
   }
 }
 function isRestProperty() {
-  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern();
+  return nodeIsRestElement(this.node) && this.parentPath?.isObjectPattern();
 }
 function isSpreadProperty() {
-  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression();
+  return nodeIsRestElement(this.node) && this.parentPath?.isObjectExpression();
 }
 function isForAwaitStatement() {
   return isForOfStatement(this.node, {
@@ -213,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)) {
@@ -226,7 +226,7 @@ function explode(visitor) {
       visitor[part] = fns;
     }
   }
-  verify(visitor);
+  verify$1(visitor);
   delete visitor.__esModule;
   ensureEntranceObjects(visitor);
   ensureCallbackArrays(visitor);
@@ -281,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 }`?");
@@ -318,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) {
@@ -409,10 +409,10 @@ function mergePair(dest, src) {
 
 var visitors = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  explode: explode,
+  explode: explode$1,
   isExplodedVisitor: isExplodedVisitor,
   merge: merge,
-  verify: verify
+  verify: verify$1
 });
 
 let pathsCache = new WeakMap();
@@ -475,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) {
@@ -534,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
     });
     {
@@ -632,6 +631,7 @@ const {
   identifier: identifier$3,
   isArrayExpression,
   isBinary,
+  isCallExpression: isCallExpression$1,
   isClass,
   isClassBody,
   isClassDeclaration,
@@ -642,6 +642,7 @@ const {
   isIdentifier: isIdentifier$5,
   isImportDeclaration,
   isLiteral: isLiteral$1,
+  isMemberExpression,
   isMethod,
   isModuleSpecifier,
   isNullLiteral,
@@ -885,6 +886,9 @@ const collectorVisitor = {
     if (path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
       path.scope.registerBinding("local", path);
     }
+  },
+  TSTypeAnnotation(path) {
+    path.skip();
   }
 };
 let uid = 0;
@@ -924,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;
   }
@@ -1230,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);
     }
@@ -1328,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;
@@ -1609,20 +1623,6 @@ function inType(...candidateTypes) {
   return false;
 }
 
-var NodePath_ancestry = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  find: find,
-  findParent: findParent,
-  getAncestry: getAncestry,
-  getDeepestCommonAncestorFrom: getDeepestCommonAncestorFrom,
-  getEarliestCommonAncestorFrom: getEarliestCommonAncestorFrom,
-  getFunctionParent: getFunctionParent,
-  getStatementParent: getStatementParent,
-  inType: inType,
-  isAncestor: isAncestor,
-  isDescendant: isDescendant
-});
-
 const {
   createFlowUnionType,
   createTSUnionType,
@@ -2118,16 +2118,6 @@ function isGenericType(genericName) {
   });
 }
 
-var NodePath_inference = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  _getTypeAnnotation: _getTypeAnnotation,
-  baseTypeStrictlyMatches: baseTypeStrictlyMatches,
-  couldBeBaseType: couldBeBaseType,
-  getTypeAnnotation: getTypeAnnotation,
-  isBaseType: isBaseType,
-  isGenericType: isGenericType
-});
-
 const {
   FUNCTION_TYPES,
   arrowFunctionExpression: arrowFunctionExpression$2,
@@ -2201,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");
   }
@@ -2371,16 +2361,6 @@ function replaceInline(nodes) {
   }
 }
 
-var NodePath_replacement = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  _replaceWith: _replaceWith,
-  replaceExpressionWithStatements: replaceExpressionWithStatements,
-  replaceInline: replaceInline,
-  replaceWith: replaceWith,
-  replaceWithMultiple: replaceWithMultiple,
-  replaceWithSourceString: replaceWithSourceString
-});
-
 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"];
@@ -2720,12 +2700,6 @@ function evaluate() {
   };
 }
 
-var NodePath_evaluation = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  evaluate: evaluate,
-  evaluateTruthy: evaluateTruthy
-});
-
 const {
   arrowFunctionExpression: arrowFunctionExpression$1,
   assignmentExpression: assignmentExpression$1,
@@ -3173,14 +3147,6 @@ function getScopeInformation(fnPath) {
   };
 }
 
-var NodePath_conversion = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  arrowFunctionToExpression: arrowFunctionToExpression,
-  ensureBlock: ensureBlock,
-  toComputedKey: toComputedKey,
-  unwrapFunctionEnvironment: unwrapFunctionEnvironment
-});
-
 const {
   STATEMENT_OR_BLOCK_KEYS,
   VISITOR_KEYS: VISITOR_KEYS$3,
@@ -3196,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 {
@@ -3510,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() {
@@ -3539,29 +3517,6 @@ function isInStrictMode() {
   return !!strictParent;
 }
 
-var NodePath_introspection = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  _guessExecutionStatusRelativeTo: _guessExecutionStatusRelativeTo,
-  _resolve: _resolve,
-  canHaveVariableDeclarationOrExpression: canHaveVariableDeclarationOrExpression,
-  canSwapBetweenExpressionAndStatement: canSwapBetweenExpressionAndStatement,
-  equals: equals,
-  getSource: getSource,
-  has: has,
-  is: is,
-  isCompletionRecord: isCompletionRecord,
-  isConstantExpression: isConstantExpression,
-  isInStrictMode: isInStrictMode,
-  isNodeType: isNodeType,
-  isStatementOrBlock: isStatementOrBlock,
-  isStatic: isStatic,
-  isnt: isnt,
-  matchesPattern: matchesPattern,
-  referencesImport: referencesImport,
-  resolve: resolve,
-  willIMaybeExecuteBefore: willIMaybeExecuteBefore
-});
-
 function call(key) {
   const opts = this.opts;
   this.debug(key);
@@ -3752,31 +3707,6 @@ function _getQueueContexts() {
   return contexts;
 }
 
-var NodePath_context = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  _call: _call,
-  _getQueueContexts: _getQueueContexts,
-  _resyncKey: _resyncKey,
-  _resyncList: _resyncList,
-  _resyncParent: _resyncParent,
-  _resyncRemoved: _resyncRemoved,
-  call: call,
-  isBlacklisted: isDenylisted,
-  isDenylisted: isDenylisted,
-  popContext: popContext,
-  pushContext: pushContext,
-  requeue: requeue,
-  resync: resync,
-  setContext: setContext,
-  setKey: setKey,
-  setScope: setScope,
-  setup: setup,
-  skip: skip,
-  skipKey: skipKey,
-  stop: stop,
-  visit: visit
-});
-
 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) {
@@ -3856,16 +3786,6 @@ function _assertUnremoved() {
   }
 }
 
-var NodePath_removal = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  _assertUnremoved: _assertUnremoved,
-  _callRemovalHooks: _callRemovalHooks,
-  _markRemoved: _markRemoved,
-  _remove: _remove,
-  _removeFromScope: _removeFromScope,
-  remove: remove
-});
-
 const {
   react
 } = _t;
@@ -4121,18 +4041,19 @@ function insertAfter(nodes_) {
       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);
@@ -4191,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) {
@@ -4204,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],
@@ -4217,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,
@@ -4231,24 +4152,9 @@ function hoist(scope = this.scope) {
   return hoister.run();
 }
 
-var NodePath_modification = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  _containerInsert: _containerInsert,
-  _containerInsertAfter: _containerInsertAfter,
-  _containerInsertBefore: _containerInsertBefore,
-  _verifyNodeList: _verifyNodeList,
-  hoist: hoist,
-  insertAfter: insertAfter,
-  insertBefore: insertBefore,
-  pushContainer: pushContainer,
-  unshiftContainer: unshiftContainer,
-  updateSiblingKeys: updateSiblingKeys
-});
-
 const {
   getBindingIdentifiers: _getBindingIdentifiers,
   getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
-  isDeclaration,
   numericLiteral,
   unaryExpression
 } = _t;
@@ -4421,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,
@@ -4469,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,
@@ -4478,7 +4384,7 @@ function _getKey(key, context) {
       }).setContext(context);
     });
   } else {
-    return NodePath.get({
+    return NodePath_Final.get({
       parentPath: this,
       parent: node,
       container: node,
@@ -4527,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;
@@ -4559,24 +4465,6 @@ function getOuterBindingIdentifierPaths(duplicates = false) {
   return this.getBindingIdentifierPaths(duplicates, true);
 }
 
-var NodePath_family = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  _getKey: _getKey,
-  _getPattern: _getPattern,
-  get: get,
-  getAllNextSiblings: getAllNextSiblings,
-  getAllPrevSiblings: getAllPrevSiblings,
-  getBindingIdentifierPaths: getBindingIdentifierPaths,
-  getBindingIdentifiers: getBindingIdentifiers,
-  getCompletionRecords: getCompletionRecords,
-  getNextSibling: getNextSibling,
-  getOpposite: getOpposite,
-  getOuterBindingIdentifierPaths: getOuterBindingIdentifierPaths,
-  getOuterBindingIdentifiers: getOuterBindingIdentifiers,
-  getPrevSibling: getPrevSibling,
-  getSibling: getSibling
-});
-
 const {
   addComment: _addComment,
   addComments: _addComments
@@ -4619,13 +4507,6 @@ function addComments(type, comments) {
   _addComments(this.node, type, comments);
 }
 
-var NodePath_comments = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  addComment: addComment,
-  addComments: addComments,
-  shareCommentsWithSiblings: shareCommentsWithSiblings
-});
-
 const {
   validate
 } = _t;
@@ -4633,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;
@@ -4645,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;
@@ -4734,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);
@@ -4810,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,
@@ -4941,12 +4913,12 @@ function traverse(parent, opts = {}, scope, state, parentPath, visitSelf) {
   if (!VISITOR_KEYS[parent.type]) {
     return;
   }
-  explode(opts);
+  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;
@@ -4983,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