@babel/traverse 7.12.13 → 7.13.15

package/lib/context.js

@@ -32,7 +32,7 @@ class TraversalContext {
     if (opts.enter || opts.exit) return true;
     if (opts[node.type]) return true;
     const keys = t.VISITOR_KEYS[node.type];
-    if (!(keys == null ? void 0 : keys.length)) return false;
+    if (!(keys != null && keys.length)) return false;
 
     for (const key of keys) {
       if (node[key]) return true;

package/lib/index.js

@@ -101,7 +101,7 @@ function hasDenylistedType(path, state) {
 }
 
 traverse.hasType = function (tree, type, denylistTypes) {
-  if (denylistTypes == null ? void 0 : denylistTypes.includes(tree.type)) return false;
+  if (denylistTypes != null && denylistTypes.includes(tree.type)) return false;
   if (tree.type === type) return true;
   const state = {
     has: false,

package/lib/path/context.js

@@ -121,6 +121,7 @@ function stop() {
 function setScope() {
   if (this.opts && this.opts.noScope) return;
   let path = this.parentPath;
+  if (this.key === "key" && path.isMethod()) path = path.parentPath;
   let target;
 
   while (path && !target) {

package/lib/path/conversion.js

@@ -95,17 +95,18 @@ function unwrapFunctionEnvironment() {
 
 function arrowFunctionToExpression({
   allowInsertArrow = true,
-  specCompliant = false
+  specCompliant = false,
+  noNewArrows = !specCompliant
 } = {}) {
   if (!this.isArrowFunctionExpression()) {
     throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
   }
 
-  const thisBinding = hoistFunctionEnvironment(this, specCompliant, allowInsertArrow);
+  const thisBinding = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow);
   this.ensureBlock();
   this.node.type = "FunctionExpression";
 
-  if (specCompliant) {
+  if (!noNewArrows) {
     const checkBinding = thisBinding ? null : this.parentPath.scope.generateUidIdentifier("arrowCheckId");
 
     if (checkBinding) {
@@ -120,7 +121,7 @@ function arrowFunctionToExpression({
   }
 }
 
-function hoistFunctionEnvironment(fnPath, specCompliant = false, allowInsertArrow = true) {
+function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow = true) {
   const thisEnvFn = fnPath.findParent(p => {
     return p.isFunction() && !p.isArrowFunctionExpression() || p.isProgram() || p.isClassProperty({
       static: false
@@ -230,16 +231,16 @@ function hoistFunctionEnvironment(fnPath, specCompliant = false, allowInsertArro
 
   let thisBinding;
 
-  if (thisPaths.length > 0 || specCompliant) {
+  if (thisPaths.length > 0 || !noNewArrows) {
     thisBinding = getThisBinding(thisEnvFn, inConstructor);
 
-    if (!specCompliant || inConstructor && hasSuperClass(thisEnvFn)) {
+    if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) {
       thisPaths.forEach(thisChild => {
         const thisRef = thisChild.isJSX() ? t.jsxIdentifier(thisBinding) : t.identifier(thisBinding);
         thisRef.loc = thisChild.node.loc;
         thisChild.replaceWith(thisRef);
       });
-      if (specCompliant) thisBinding = null;
+      if (!noNewArrows) thisBinding = null;
     }
   }
 

package/lib/path/evaluation.js

@@ -129,7 +129,7 @@ function _evaluate(path, state) {
       return deopt(binding.path, state);
     }
 
-    if (binding == null ? void 0 : binding.hasValue) {
+    if (binding != null && binding.hasValue) {
       return binding.value;
     } else {
       if (path.node.name === "undefined") {

package/lib/path/family.js

@@ -28,6 +28,23 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const NORMAL_COMPLETION = 0;
+const BREAK_COMPLETION = 1;
+
+function NormalCompletion(path) {
+  return {
+    type: NORMAL_COMPLETION,
+    path
+  };
+}
+
+function BreakCompletion(path) {
+  return {
+    type: BREAK_COMPLETION,
+    path
+  };
+}
+
 function getOpposite() {
   if (this.key === "left") {
     return this.getSibling("right");
@@ -38,102 +55,163 @@ function getOpposite() {
   return null;
 }
 
-function addCompletionRecords(path, paths) {
-  if (path) return paths.concat(path.getCompletionRecords());
-  return paths;
+function addCompletionRecords(path, records, context) {
+  if (path) return records.concat(_getCompletionRecords(path, context));
+  return records;
 }
 
-function findBreak(statements) {
-  let breakStatement;
+function completionRecordForSwitch(cases, records, context) {
+  let lastNormalCompletions = [];
 
-  if (!Array.isArray(statements)) {
-    statements = [statements];
-  }
+  for (let i = 0; i < cases.length; i++) {
+    const casePath = cases[i];
+
+    const caseCompletions = _getCompletionRecords(casePath, context);
 
-  for (const statement of statements) {
-    if (statement.isDoExpression() || statement.isProgram() || statement.isBlockStatement() || statement.isCatchClause() || statement.isLabeledStatement()) {
-      breakStatement = findBreak(statement.get("body"));
-    } else if (statement.isIfStatement()) {
-      var _findBreak;
+    const normalCompletions = [];
+    const breakCompletions = [];
 
-      breakStatement = (_findBreak = findBreak(statement.get("consequent"))) != null ? _findBreak : findBreak(statement.get("alternate"));
-    } else if (statement.isTryStatement()) {
-      var _findBreak2;
+    for (const c of caseCompletions) {
+      if (c.type === NORMAL_COMPLETION) {
+        normalCompletions.push(c);
+      }
 
-      breakStatement = (_findBreak2 = findBreak(statement.get("block"))) != null ? _findBreak2 : findBreak(statement.get("handler"));
-    } else if (statement.isBreakStatement()) {
-      breakStatement = statement;
+      if (c.type === BREAK_COMPLETION) {
+        breakCompletions.push(c);
+      }
     }
 
-    if (breakStatement) {
-      return breakStatement;
+    if (normalCompletions.length) {
+      lastNormalCompletions = normalCompletions;
     }
+
+    records = records.concat(breakCompletions);
   }
 
-  return null;
+  records = records.concat(lastNormalCompletions);
+  return records;
 }
 
-function completionRecordForSwitch(cases, paths) {
-  let isLastCaseWithConsequent = true;
-
-  for (let i = cases.length - 1; i >= 0; i--) {
-    const switchCase = cases[i];
-    const consequent = switchCase.get("consequent");
-    let breakStatement = findBreak(consequent);
+function normalCompletionToBreak(completions) {
+  completions.forEach(c => {
+    c.type = BREAK_COMPLETION;
+  });
+}
 
-    if (breakStatement) {
-      while (breakStatement.key === 0 && breakStatement.parentPath.isBlockStatement()) {
-        breakStatement = breakStatement.parentPath;
+function replaceBreakStatementInBreakCompletion(completions, reachable) {
+  completions.forEach(c => {
+    if (c.path.isBreakStatement({
+      label: null
+    })) {
+      if (reachable) {
+        c.path.replaceWith(t.unaryExpression("void", t.numericLiteral(0)));
+      } else {
+        c.path.remove();
       }
+    }
+  });
+}
 
-      const prevSibling = breakStatement.getPrevSibling();
+function getStatementListCompletion(paths, context) {
+  let completions = [];
 
-      if (breakStatement.key > 0 && (prevSibling.isExpressionStatement() || prevSibling.isBlockStatement())) {
-        paths = addCompletionRecords(prevSibling, paths);
-        breakStatement.remove();
-      } else {
-        breakStatement.replaceWith(breakStatement.scope.buildUndefinedNode());
-        paths = addCompletionRecords(breakStatement, paths);
+  if (context.canHaveBreak) {
+    let lastNormalCompletions = [];
+
+    for (let i = 0; i < paths.length; i++) {
+      const path = paths[i];
+      const newContext = Object.assign({}, context, {
+        inCaseClause: false
+      });
+
+      if (path.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) {
+          newContext.shouldPopulateBreak = true;
+        } else {
+        newContext.shouldPopulateBreak = false;
       }
-    } else if (isLastCaseWithConsequent) {
-      const statementFinder = statement => !statement.isBlockStatement() || statement.get("body").some(statementFinder);
 
-      const hasConsequent = consequent.some(statementFinder);
+      const statementCompletions = _getCompletionRecords(path, newContext);
+
+      if (statementCompletions.length > 0 && statementCompletions.every(c => c.type === BREAK_COMPLETION)) {
+        if (lastNormalCompletions.length > 0 && statementCompletions.every(c => c.path.isBreakStatement({
+          label: null
+        }))) {
+          normalCompletionToBreak(lastNormalCompletions);
+          completions = completions.concat(lastNormalCompletions);
+
+          if (lastNormalCompletions.some(c => c.path.isDeclaration())) {
+            completions = completions.concat(statementCompletions);
+            replaceBreakStatementInBreakCompletion(statementCompletions, true);
+          }
 
-      if (hasConsequent) {
-        paths = addCompletionRecords(consequent[consequent.length - 1], paths);
-        isLastCaseWithConsequent = false;
+          replaceBreakStatementInBreakCompletion(statementCompletions, false);
+        } else {
+          completions = completions.concat(statementCompletions);
+
+          if (!context.shouldPopulateBreak) {
+            replaceBreakStatementInBreakCompletion(statementCompletions, true);
+          }
+        }
+
+        break;
+      }
+
+      if (i === paths.length - 1) {
+        completions = completions.concat(statementCompletions);
+      } else {
+        completions = completions.concat(statementCompletions.filter(c => c.type === BREAK_COMPLETION));
+        lastNormalCompletions = statementCompletions.filter(c => c.type === NORMAL_COMPLETION);
       }
     }
+  } else if (paths.length) {
+    completions = completions.concat(_getCompletionRecords(paths[paths.length - 1], context));
   }
 
-  return paths;
+  return completions;
 }
 
-function getCompletionRecords() {
-  let paths = [];
-
-  if (this.isIfStatement()) {
-    paths = addCompletionRecords(this.get("consequent"), paths);
-    paths = addCompletionRecords(this.get("alternate"), paths);
-  } else if (this.isDoExpression() || this.isFor() || this.isWhile()) {
-    paths = addCompletionRecords(this.get("body"), paths);
-  } else if (this.isProgram() || this.isBlockStatement()) {
-    paths = addCompletionRecords(this.get("body").pop(), paths);
-  } else if (this.isFunction()) {
-    return this.get("body").getCompletionRecords();
-  } else if (this.isTryStatement()) {
-    paths = addCompletionRecords(this.get("block"), paths);
-    paths = addCompletionRecords(this.get("handler"), paths);
-  } else if (this.isCatchClause()) {
-    paths = addCompletionRecords(this.get("body"), paths);
-  } else if (this.isSwitchStatement()) {
-    paths = completionRecordForSwitch(this.get("cases"), paths);
+function _getCompletionRecords(path, context) {
+  let records = [];
+
+  if (path.isIfStatement()) {
+    records = addCompletionRecords(path.get("consequent"), records, context);
+    records = addCompletionRecords(path.get("alternate"), records, context);
+  } else if (path.isDoExpression() || path.isFor() || path.isWhile()) {
+    records = addCompletionRecords(path.get("body"), records, context);
+  } else if (path.isProgram() || path.isBlockStatement()) {
+    records = records.concat(getStatementListCompletion(path.get("body"), context));
+  } else if (path.isFunction()) {
+    return _getCompletionRecords(path.get("body"), context);
+  } else if (path.isTryStatement()) {
+    records = addCompletionRecords(path.get("block"), records, context);
+    records = addCompletionRecords(path.get("handler"), records, context);
+  } else if (path.isCatchClause()) {
+    records = addCompletionRecords(path.get("body"), records, context);
+  } else if (path.isSwitchStatement()) {
+    records = completionRecordForSwitch(path.get("cases"), records, context);
+  } else if (path.isSwitchCase()) {
+    records = records.concat(getStatementListCompletion(path.get("consequent"), {
+      canHaveBreak: true,
+      shouldPopulateBreak: false,
+      inCaseClause: true
+    }));
+  } else if (path.isBreakStatement()) {
+    records.push(BreakCompletion(path));
   } else {
-    paths.push(this);
+    records.push(NormalCompletion(path));
   }
 
-  return paths;
+  return records;
+}
+
+function getCompletionRecords() {
+  const records = _getCompletionRecords(this, {
+    canHaveBreak: false,
+    shouldPopulateBreak: false,
+    inCaseClause: false
+  });
+
+  return records.map(r => r.path);
 }
 
 function getSibling(key) {

package/lib/path/index.js

@@ -7,8 +7,6 @@ exports.default = exports.SHOULD_SKIP = exports.SHOULD_STOP = exports.REMOVED =
 
 var virtualTypes = _interopRequireWildcard(require("./lib/virtual-types"));
 
-var _debug = _interopRequireDefault(require("debug"));
-
 var _index = _interopRequireDefault(require("../index"));
 
 var _scope = _interopRequireDefault(require("../scope"));
@@ -47,7 +45,9 @@ function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const debug = (0, _debug.default)("babel");
+const buildDebug = require("debug");
+
+const debug = buildDebug("babel");
 const REMOVED = 1 << 0;
 exports.REMOVED = REMOVED;
 const SHOULD_STOP = 1 << 1;

package/lib/path/inference/index.js

@@ -70,7 +70,7 @@ function _getTypeAnnotation() {
 
     inferer = inferers[this.parentPath.type];
 
-    if ((_inferer = inferer) == null ? void 0 : _inferer.validParent) {
+    if ((_inferer = inferer) != null && _inferer.validParent) {
       return this.parentPath.getTypeAnnotation();
     }
   } finally {

package/lib/path/introspection.js

@@ -111,7 +111,17 @@ function isStatementOrBlock() {
 }
 
 function referencesImport(moduleSource, importName) {
-  if (!this.isReferencedIdentifier()) return false;
+  if (!this.isReferencedIdentifier()) {
+    if ((this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? t.isStringLiteral(this.node.property, {
+      value: importName
+    }) : this.node.property.name === importName)) {
+      const object = this.get("object");
+      return object.isReferencedIdentifier() && object.referencesImport(moduleSource, "*");
+    }
+
+    return false;
+  }
+
   const binding = this.scope.getBinding(this.node.name);
   if (!binding || binding.kind !== "module") return false;
   const path = binding.path;

package/lib/path/removal.js

@@ -27,7 +27,7 @@ function remove() {
 
   this.resync();
 
-  if (!((_this$opts = this.opts) == null ? void 0 : _this$opts.noScope)) {
+  if (!((_this$opts = this.opts) != null && _this$opts.noScope)) {
     this._removeFromScope();
   }
 

package/lib/path/replacement.js

@@ -194,6 +194,7 @@ function replaceExpressionWithStatements(nodes) {
 
   const functionParent = this.getFunctionParent();
   const isParentAsync = functionParent == null ? void 0 : functionParent.is("async");
+  const isParentGenerator = functionParent == null ? void 0 : functionParent.is("generator");
   const container = t.arrowFunctionExpression([], t.blockStatement(nodes));
   this.replaceWith(t.callExpression(container, []));
   this.traverse(hoistVariablesVisitor);
@@ -224,9 +225,21 @@ function replaceExpressionWithStatements(nodes) {
   const callee = this.get("callee");
   callee.arrowFunctionToExpression();
 
-  if (isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", t.FUNCTION_TYPES)) {
+  const needToAwaitFunction = isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", t.FUNCTION_TYPES);
+
+  const needToYieldFunction = isParentGenerator && _index.default.hasType(this.get("callee.body").node, "YieldExpression", t.FUNCTION_TYPES);
+
+  if (needToAwaitFunction) {
     callee.set("async", true);
-    this.replaceWith(t.awaitExpression(this.node));
+
+    if (!needToYieldFunction) {
+      this.replaceWith(t.awaitExpression(this.node));
+    }
+  }
+
+  if (needToYieldFunction) {
+    callee.set("generator", true);
+    this.replaceWith(t.yieldExpression(this.node, true));
   }
 
   return callee.get("body.body");

package/lib/scope/index.js

@@ -11,8 +11,6 @@ var _index = _interopRequireDefault(require("../index"));
 
 var _binding = _interopRequireDefault(require("./binding"));
 
-var _globals = _interopRequireDefault(require("globals"));
-
 var t = _interopRequireWildcard(require("@babel/types"));
 
 var _cache = require("../cache");
@@ -23,6 +21,8 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const globals = require("globals");
+
 function gatherNodeParts(node, parts) {
   switch (node == null ? void 0 : node.type) {
     default:
@@ -178,11 +178,7 @@ const collectorVisitor = {
 
   Declaration(path) {
     if (path.isBlockScoped()) return;
-
-    if (path.isExportDeclaration() && path.get("declaration").isDeclaration()) {
-      return;
-    }
-
+    if (path.isExportDeclaration()) return;
     const parent = path.scope.getFunctionParent() || path.scope.getProgramParent();
     parent.registerDeclaration(path);
   },
@@ -205,6 +201,7 @@ const collectorVisitor = {
         node,
         scope
       } = path;
+      if (t.isExportAllDeclaration(node)) return;
       const declar = node.declaration;
 
       if (t.isClassDeclaration(declar) || t.isFunctionDeclaration(declar)) {
@@ -225,7 +222,6 @@ const collectorVisitor = {
   },
 
   LabeledStatement(path) {
-    path.scope.getProgramParent().addGlobal(path.node);
     path.scope.getBlockParent().registerDeclaration(path);
   },
 
@@ -256,16 +252,6 @@ const collectorVisitor = {
     }
   },
 
-  Block(path) {
-    const paths = path.get("body");
-
-    for (const bodyPath of paths) {
-      if (bodyPath.isFunctionDeclaration()) {
-        path.scope.getBlockParent().registerDeclaration(bodyPath);
-      }
-    }
-  },
-
   CatchClause(path) {
     path.scope.registerBinding("let", path);
   },
@@ -324,8 +310,19 @@ class Scope {
   }
 
   get parent() {
-    const parent = this.path.findParent(p => p.isScope());
-    return parent == null ? void 0 : parent.scope;
+    var _parent;
+
+    let parent,
+        path = this.path;
+
+    do {
+      const isKey = path.key === "key";
+      path = path.parentPath;
+      if (isKey && path.isMethod()) path = path.parentPath;
+      if (path && path.isScope()) parent = path;
+    } while (path && !parent);
+
+    return (_parent = parent) == null ? void 0 : _parent.scope;
   }
 
   get parentBlock() {
@@ -469,11 +466,11 @@ class Scope {
     console.log(sep);
   }
 
-  toArray(node, i, allowArrayLike) {
+  toArray(node, i, arrayLikeIsIterable) {
     if (t.isIdentifier(node)) {
       const binding = this.getBinding(node.name);
 
-      if ((binding == null ? void 0 : binding.constant) && binding.path.isGenericType("Array")) {
+      if (binding != null && binding.constant && binding.path.isGenericType("Array")) {
         return node;
       }
     }
@@ -500,7 +497,7 @@ class Scope {
       helperName = "toArray";
     }
 
-    if (allowArrayLike) {
+    if (arrayLikeIsIterable) {
       args.unshift(this.hub.addHelper(helperName));
       helperName = "maybeArrayLike";
     }
@@ -722,19 +719,6 @@ class Scope {
     this.globals = Object.create(null);
     this.uids = Object.create(null);
     this.data = Object.create(null);
-
-    if (path.isFunction()) {
-      if (path.isFunctionExpression() && path.has("id") && !path.get("id").node[t.NOT_LOCAL_BINDING]) {
-        this.registerBinding("local", path.get("id"), path);
-      }
-
-      const params = path.get("params");
-
-      for (const param of params) {
-        this.registerBinding("param", param);
-      }
-    }
-
     const programParent = this.getProgramParent();
     if (programParent.crawling) return;
     const state = {
@@ -743,6 +727,21 @@ class Scope {
       assignments: []
     };
     this.crawling = true;
+
+    if (path.type !== "Program" && collectorVisitor._exploded) {
+      for (const visit of collectorVisitor.enter) {
+        visit(path, state);
+      }
+
+      const typeVisitors = collectorVisitor[path.type];
+
+      if (typeVisitors) {
+        for (const visit of typeVisitors.enter) {
+          visit(path, state);
+        }
+      }
+    }
+
     path.traverse(collectorVisitor, state);
     this.crawling = false;
 
@@ -892,7 +891,7 @@ class Scope {
       if (binding) {
         var _previousPath;
 
-        if (((_previousPath = previousPath) == null ? void 0 : _previousPath.isPattern()) && binding.kind !== "param") {} else {
+        if ((_previousPath = previousPath) != null && _previousPath.isPattern() && binding.kind !== "param") {} else {
           return binding;
         }
       }
@@ -966,5 +965,5 @@ class Scope {
 }
 
 exports.default = Scope;
-Scope.globals = Object.keys(_globals.default.builtin);
+Scope.globals = Object.keys(globals.builtin);
 Scope.contextVariables = ["arguments", "undefined", "Infinity", "NaN"];

package/lib/scope/lib/renamer.js

@@ -28,7 +28,7 @@ const renameVisitor = {
 
   Scope(path, state) {
     if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
-      path.skip();
+      skipAllButComputedMethodKey(path);
     }
   },
 
@@ -128,4 +128,17 @@ class Renamer {
 
 }
 
-exports.default = Renamer;
+exports.default = Renamer;
+
+function skipAllButComputedMethodKey(path) {
+  if (!path.isMethod() || !path.node.computed) {
+    path.skip();
+    return;
+  }
+
+  const keys = t.VISITOR_KEYS[path.type];
+
+  for (const key of keys) {
+    if (key !== "key") path.skipKey(key);
+  }
+}

package/lib/visitors.js

@@ -65,11 +65,11 @@ function explode(visitor) {
     if (shouldIgnoreKey(nodeType)) continue;
     const fns = visitor[nodeType];
     let aliases = t.FLIPPED_ALIAS_KEYS[nodeType];
-    const deprecratedKey = t.DEPRECATED_KEYS[nodeType];
+    const deprecatedKey = t.DEPRECATED_KEYS[nodeType];
 
-    if (deprecratedKey) {
-      console.trace(`Visitor defined for ${nodeType} but it has been renamed to ${deprecratedKey}`);
-      aliases = [deprecratedKey];
+    if (deprecatedKey) {
+      console.trace(`Visitor defined for ${nodeType} but it has been renamed to ${deprecatedKey}`);
+      aliases = [deprecatedKey];
     }
 
     if (!aliases) continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babel/traverse",
-  "version": "7.12.13",
+  "version": "7.13.15",
   "description": "The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babel.dev/docs/en/next/babel-traverse",
@@ -17,16 +17,15 @@
   "main": "lib/index.js",
   "dependencies": {
     "@babel/code-frame": "^7.12.13",
-    "@babel/generator": "^7.12.13",
+    "@babel/generator": "^7.13.9",
     "@babel/helper-function-name": "^7.12.13",
     "@babel/helper-split-export-declaration": "^7.12.13",
-    "@babel/parser": "^7.12.13",
-    "@babel/types": "^7.12.13",
+    "@babel/parser": "^7.13.15",
+    "@babel/types": "^7.13.14",
     "debug": "^4.1.0",
-    "globals": "^11.1.0",
-    "lodash": "^4.17.19"
+    "globals": "^11.1.0"
   },
   "devDependencies": {
-    "@babel/helper-plugin-test-runner": "7.12.13"
+    "@babel/helper-plugin-test-runner": "7.13.10"
   }
 }