node fixes, updates

1 files changed, 137 insertions, 33 deletions

diff --git a/node_modules/@babel/traverse/lib/path/index.js b/node_modules/@babel/traverse/lib/path/index.js
index 13726557..c37c66ff 100644
--- a/node_modules/@babel/traverse/lib/path/index.js
+++ b/node_modules/@babel/traverse/lib/path/index.js
@@ -18,7 +18,8 @@ var NodePath_replacement = require("./replacement.js");
 var NodePath_evaluation = require("./evaluation.js");
 var NodePath_conversion = require("./conversion.js");
 var NodePath_introspection = require("./introspection.js");
-var NodePath_context = require("./context.js");
+var _context = require("./context.js");
+var NodePath_context = _context;
 var NodePath_removal = require("./removal.js");
 var NodePath_modification = require("./modification.js");
 var NodePath_family = require("./family.js");
@@ -50,6 +51,24 @@ const NodePath_Final = exports.default = class NodePath {
     this.context = null;
     this.scope = null;
   }
+  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;
+  }
   static get({
     hub,
     parentPath,
@@ -71,7 +90,7 @@ const NodePath_Final = exports.default = class NodePath {
       path = new NodePath(hub, parent);
       if (targetNode) paths.set(targetNode, path);
     }
-    path.setup(parentPath, container, listKey, key);
+    _context.setup.call(path, parentPath, container, listKey, key);
     return path;
   }
   getScope(scope) {
@@ -132,40 +151,125 @@ const NodePath_Final = exports.default = 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_Final.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: NodePath_ancestry.findParent,
+  find: NodePath_ancestry.find,
+  getFunctionParent: NodePath_ancestry.getFunctionParent,
+  getStatementParent: NodePath_ancestry.getStatementParent,
+  getEarliestCommonAncestorFrom: NodePath_ancestry.getEarliestCommonAncestorFrom,
+  getDeepestCommonAncestorFrom: NodePath_ancestry.getDeepestCommonAncestorFrom,
+  getAncestry: NodePath_ancestry.getAncestry,
+  isAncestor: NodePath_ancestry.isAncestor,
+  isDescendant: NodePath_ancestry.isDescendant,
+  inType: NodePath_ancestry.inType,
+  getTypeAnnotation: NodePath_inference.getTypeAnnotation,
+  isBaseType: NodePath_inference.isBaseType,
+  couldBeBaseType: NodePath_inference.couldBeBaseType,
+  baseTypeStrictlyMatches: NodePath_inference.baseTypeStrictlyMatches,
+  isGenericType: NodePath_inference.isGenericType,
+  replaceWithMultiple: NodePath_replacement.replaceWithMultiple,
+  replaceWithSourceString: NodePath_replacement.replaceWithSourceString,
+  replaceWith: NodePath_replacement.replaceWith,
+  replaceExpressionWithStatements: NodePath_replacement.replaceExpressionWithStatements,
+  replaceInline: NodePath_replacement.replaceInline,
+  evaluateTruthy: NodePath_evaluation.evaluateTruthy,
+  evaluate: NodePath_evaluation.evaluate,
+  toComputedKey: NodePath_conversion.toComputedKey,
+  ensureBlock: NodePath_conversion.ensureBlock,
+  unwrapFunctionEnvironment: NodePath_conversion.unwrapFunctionEnvironment,
+  arrowFunctionToExpression: NodePath_conversion.arrowFunctionToExpression,
+  splitExportDeclaration: NodePath_conversion.splitExportDeclaration,
+  ensureFunctionName: NodePath_conversion.ensureFunctionName,
+  matchesPattern: NodePath_introspection.matchesPattern,
+  isStatic: NodePath_introspection.isStatic,
+  isNodeType: NodePath_introspection.isNodeType,
+  canHaveVariableDeclarationOrExpression: NodePath_introspection.canHaveVariableDeclarationOrExpression,
+  canSwapBetweenExpressionAndStatement: NodePath_introspection.canSwapBetweenExpressionAndStatement,
+  isCompletionRecord: NodePath_introspection.isCompletionRecord,
+  isStatementOrBlock: NodePath_introspection.isStatementOrBlock,
+  referencesImport: NodePath_introspection.referencesImport,
+  getSource: NodePath_introspection.getSource,
+  willIMaybeExecuteBefore: NodePath_introspection.willIMaybeExecuteBefore,
+  _guessExecutionStatusRelativeTo: NodePath_introspection._guessExecutionStatusRelativeTo,
+  resolve: NodePath_introspection.resolve,
+  isConstantExpression: NodePath_introspection.isConstantExpression,
+  isInStrictMode: NodePath_introspection.isInStrictMode,
+  isDenylisted: NodePath_context.isDenylisted,
+  visit: NodePath_context.visit,
+  skip: NodePath_context.skip,
+  skipKey: NodePath_context.skipKey,
+  stop: NodePath_context.stop,
+  setContext: NodePath_context.setContext,
+  requeue: NodePath_context.requeue,
+  requeueComputedKeyAndDecorators: NodePath_context.requeueComputedKeyAndDecorators,
+  remove: NodePath_removal.remove,
+  insertBefore: NodePath_modification.insertBefore,
+  insertAfter: NodePath_modification.insertAfter,
+  unshiftContainer: NodePath_modification.unshiftContainer,
+  pushContainer: NodePath_modification.pushContainer,
+  getOpposite: NodePath_family.getOpposite,
+  getCompletionRecords: NodePath_family.getCompletionRecords,
+  getSibling: NodePath_family.getSibling,
+  getPrevSibling: NodePath_family.getPrevSibling,
+  getNextSibling: NodePath_family.getNextSibling,
+  getAllNextSiblings: NodePath_family.getAllNextSiblings,
+  getAllPrevSiblings: NodePath_family.getAllPrevSiblings,
+  get: NodePath_family.get,
+  getAssignmentIdentifiers: NodePath_family.getAssignmentIdentifiers,
+  getBindingIdentifiers: NodePath_family.getBindingIdentifiers,
+  getOuterBindingIdentifiers: NodePath_family.getOuterBindingIdentifiers,
+  getBindingIdentifierPaths: NodePath_family.getBindingIdentifierPaths,
+  getOuterBindingIdentifierPaths: NodePath_family.getOuterBindingIdentifierPaths,
+  shareCommentsWithSiblings: NodePath_comments.shareCommentsWithSiblings,
+  addComment: NodePath_comments.addComment,
+  addComments: NodePath_comments.addComments
+};
+Object.assign(NodePath_Final.prototype, methods);
 {
+  NodePath_Final.prototype.arrowFunctionToShadowed = NodePath_conversion[String("arrowFunctionToShadowed")];
+  Object.assign(NodePath_Final.prototype, {
+    has: NodePath_introspection[String("has")],
+    is: NodePath_introspection[String("is")],
+    isnt: NodePath_introspection[String("isnt")],
+    equals: NodePath_introspection[String("equals")],
+    hoist: NodePath_modification[String("hoist")],
+    updateSiblingKeys: NodePath_modification.updateSiblingKeys,
+    call: NodePath_context.call,
+    isBlacklisted: NodePath_context[String("isBlacklisted")],
+    setScope: NodePath_context.setScope,
+    resync: NodePath_context.resync,
+    popContext: NodePath_context.popContext,
+    pushContext: NodePath_context.pushContext,
+    setup: NodePath_context.setup,
+    setKey: NodePath_context.setKey
+  });
+}
+{
+  NodePath_Final.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
   NodePath_Final.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
+  Object.assign(NodePath_Final.prototype, {
+    _getTypeAnnotation: NodePath_inference._getTypeAnnotation,
+    _replaceWith: NodePath_replacement._replaceWith,
+    _resolve: NodePath_introspection._resolve,
+    _call: NodePath_context._call,
+    _resyncParent: NodePath_context._resyncParent,
+    _resyncKey: NodePath_context._resyncKey,
+    _resyncList: NodePath_context._resyncList,
+    _resyncRemoved: NodePath_context._resyncRemoved,
+    _getQueueContexts: NodePath_context._getQueueContexts,
+    _removeFromScope: NodePath_removal._removeFromScope,
+    _callRemovalHooks: NodePath_removal._callRemovalHooks,
+    _remove: NodePath_removal._remove,
+    _markRemoved: NodePath_removal._markRemoved,
+    _assertUnremoved: NodePath_removal._assertUnremoved,
+    _containerInsert: NodePath_modification._containerInsert,
+    _containerInsertBefore: NodePath_modification._containerInsertBefore,
+    _containerInsertAfter: NodePath_modification._containerInsertAfter,
+    _verifyNodeList: NodePath_modification._verifyNodeList,
+    _getKey: NodePath_family._getKey,
+    _getPattern: NodePath_family._getPattern
+  });
 }
 for (const type of t.TYPES) {
   const typeKey = `is${type}`;