Added node_modules for the updating to work properly.

1 files changed, 260 insertions, 0 deletions

diff --git a/node_modules/@babel/traverse/lib/path/replacement.js b/node_modules/@babel/traverse/lib/path/replacement.js
new file mode 100644
index 0000000..ee5cdce
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/replacement.js
@@ -0,0 +1,260 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._replaceWith = _replaceWith;
+exports.replaceExpressionWithStatements = replaceExpressionWithStatements;
+exports.replaceInline = replaceInline;
+exports.replaceWith = replaceWith;
+exports.replaceWithMultiple = replaceWithMultiple;
+exports.replaceWithSourceString = replaceWithSourceString;
+
+var _codeFrame = require("@babel/code-frame");
+
+var _index = require("../index");
+
+var _index2 = require("./index");
+
+var _cache = require("../cache");
+
+var _parser = require("@babel/parser");
+
+var _t = require("@babel/types");
+
+var _helperHoistVariables = require("@babel/helper-hoist-variables");
+
+const {
+  FUNCTION_TYPES,
+  arrowFunctionExpression,
+  assignmentExpression,
+  awaitExpression,
+  blockStatement,
+  callExpression,
+  cloneNode,
+  expressionStatement,
+  identifier,
+  inheritLeadingComments,
+  inheritTrailingComments,
+  inheritsComments,
+  isExpression,
+  isProgram,
+  isStatement,
+  removeComments,
+  returnStatement,
+  toSequenceExpression,
+  validate,
+  yieldExpression
+} = _t;
+
+function replaceWithMultiple(nodes) {
+  var _pathCache$get;
+
+  this.resync();
+  nodes = this._verifyNodeList(nodes);
+  inheritLeadingComments(nodes[0], this.node);
+  inheritTrailingComments(nodes[nodes.length - 1], this.node);
+  (_pathCache$get = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get.delete(this.node);
+  this.node = this.container[this.key] = null;
+  const paths = this.insertAfter(nodes);
+
+  if (this.node) {
+    this.requeue();
+  } else {
+    this.remove();
+  }
+
+  return paths;
+}
+
+function replaceWithSourceString(replacement) {
+  this.resync();
+
+  try {
+    replacement = `(${replacement})`;
+    replacement = (0, _parser.parse)(replacement);
+  } catch (err) {
+    const loc = err.loc;
+
+    if (loc) {
+      err.message += " - make sure this is an expression.\n" + (0, _codeFrame.codeFrameColumns)(replacement, {
+        start: {
+          line: loc.line,
+          column: loc.column + 1
+        }
+      });
+      err.code = "BABEL_REPLACE_SOURCE_ERROR";
+    }
+
+    throw err;
+  }
+
+  replacement = replacement.program.body[0].expression;
+
+  _index.default.removeProperties(replacement);
+
+  return this.replaceWith(replacement);
+}
+
+function replaceWith(replacement) {
+  this.resync();
+
+  if (this.removed) {
+    throw new Error("You can't replace this node, we've already removed it");
+  }
+
+  if (replacement instanceof _index2.default) {
+    replacement = replacement.node;
+  }
+
+  if (!replacement) {
+    throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead");
+  }
+
+  if (this.node === replacement) {
+    return [this];
+  }
+
+  if (this.isProgram() && !isProgram(replacement)) {
+    throw new Error("You can only replace a Program root node with another Program node");
+  }
+
+  if (Array.isArray(replacement)) {
+    throw new Error("Don't use `path.replaceWith()` with an array of nodes, use `path.replaceWithMultiple()`");
+  }
+
+  if (typeof replacement === "string") {
+    throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
+  }
+
+  let nodePath = "";
+
+  if (this.isNodeType("Statement") && isExpression(replacement)) {
+    if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
+      replacement = expressionStatement(replacement);
+      nodePath = "expression";
+    }
+  }
+
+  if (this.isNodeType("Expression") && isStatement(replacement)) {
+    if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
+      return this.replaceExpressionWithStatements([replacement]);
+    }
+  }
+
+  const oldNode = this.node;
+
+  if (oldNode) {
+    inheritsComments(replacement, oldNode);
+    removeComments(oldNode);
+  }
+
+  this._replaceWith(replacement);
+
+  this.type = replacement.type;
+  this.setScope();
+  this.requeue();
+  return [nodePath ? this.get(nodePath) : this];
+}
+
+function _replaceWith(node) {
+  var _pathCache$get2;
+
+  if (!this.container) {
+    throw new ReferenceError("Container is falsy");
+  }
+
+  if (this.inList) {
+    validate(this.parent, this.key, [node]);
+  } else {
+    validate(this.parent, this.key, node);
+  }
+
+  this.debug(`Replace with ${node == null ? void 0 : node.type}`);
+  (_pathCache$get2 = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get2.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 functionParent = this.getFunctionParent();
+  const isParentAsync = functionParent == null ? void 0 : functionParent.is("async");
+  const isParentGenerator = functionParent == null ? void 0 : functionParent.is("generator");
+  const container = arrowFunctionExpression([], blockStatement(nodes));
+  this.replaceWith(callExpression(container, []));
+  const callee = this.get("callee");
+  (0, _helperHoistVariables.default)(callee.get("body"), id => {
+    this.scope.push({
+      id
+    });
+  }, "var");
+  const completionRecords = this.get("callee").getCompletionRecords();
+
+  for (const path of completionRecords) {
+    if (!path.isExpressionStatement()) continue;
+    const loop = path.findParent(path => path.isLoop());
+
+    if (loop) {
+      let uid = loop.getData("expressionReplacementReturnUid");
+
+      if (!uid) {
+        uid = callee.scope.generateDeclaredUidIdentifier("ret");
+        callee.get("body").pushContainer("body", returnStatement(cloneNode(uid)));
+        loop.setData("expressionReplacementReturnUid", uid);
+      } else {
+        uid = identifier(uid.name);
+      }
+
+      path.get("expression").replaceWith(assignmentExpression("=", cloneNode(uid), path.node.expression));
+    } else {
+      path.replaceWith(returnStatement(path.node.expression));
+    }
+  }
+
+  callee.arrowFunctionToExpression();
+  const newCallee = callee;
+
+  const needToAwaitFunction = isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", FUNCTION_TYPES);
+
+  const needToYieldFunction = isParentGenerator && _index.default.hasType(this.get("callee.body").node, "YieldExpression", FUNCTION_TYPES);
+
+  if (needToAwaitFunction) {
+    newCallee.set("async", true);
+
+    if (!needToYieldFunction) {
+      this.replaceWith(awaitExpression(this.node));
+    }
+  }
+
+  if (needToYieldFunction) {
+    newCallee.set("generator", true);
+    this.replaceWith(yieldExpression(this.node, true));
+  }
+
+  return newCallee.get("body.body");
+}
+
+function replaceInline(nodes) {
+  this.resync();
+
+  if (Array.isArray(nodes)) {
+    if (Array.isArray(this.container)) {
+      nodes = this._verifyNodeList(nodes);
+
+      const paths = this._containerInsertAfter(nodes);
+
+      this.remove();
+      return paths;
+    } else {
+      return this.replaceWithMultiple(nodes);
+    }
+  } else {
+    return this.replaceWith(nodes);
+  }
+}
\ No newline at end of file