node: updatemain

19 files changed, 0 insertions, 4123 deletions

diff --git a/node_modules/regenerator-transform/LICENSE b/node_modules/regenerator-transform/LICENSE
deleted file mode 100644
index cde61b6c..00000000
--- a/node_modules/regenerator-transform/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2014-present, Facebook, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/node_modules/regenerator-transform/README.md b/node_modules/regenerator-transform/README.md
deleted file mode 100644
index 03d3310c..00000000
--- a/node_modules/regenerator-transform/README.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# regenerator-transform
-
-Transform async/generator functions with [regenerator](https://github.com/facebook/regenerator)
-
-## Installation
-
-```sh
-$ npm install regenerator-transform
-```
-
-## Usage
-
-### Via `.babelrc` (Recommended)
-
-**.babelrc**
-
-```js
-// without options
-{
-  "plugins": ["regenerator-transform"]
-}
-// with options
-{
-  "plugins": [
-    ["regenerator-transform", {
-      asyncGenerators: false, // true by default
-      generators: false, // true by default
-      async: false // true by default
-    }]
-  ]
-}
-```
-
-### Via CLI
-
-```sh
-$ babel --plugins regenerator-transform script.js
-```
-
-### Via Node API
-
-```javascript
-require("@babel/core").transformSync("code", {
-  plugins: ["regenerator-transform"]
-});
-```
diff --git a/node_modules/regenerator-transform/lib/emit.js b/node_modules/regenerator-transform/lib/emit.js
deleted file mode 100644
index bf741fac..00000000
--- a/node_modules/regenerator-transform/lib/emit.js
+++ /dev/null
@@ -1,904 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _assert = _interopRequireDefault(require("assert"));
-var leap = _interopRequireWildcard(require("./leap"));
-var meta = _interopRequireWildcard(require("./meta"));
-var util = _interopRequireWildcard(require("./util"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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; }
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var hasOwn = Object.prototype.hasOwnProperty;
-function Emitter(contextId) {
-  _assert["default"].ok(this instanceof Emitter);
-  util.getTypes().assertIdentifier(contextId);
-
-  // Used to generate unique temporary names.
-  this.nextTempId = 0;
-
-  // In order to make sure the context object does not collide with
-  // anything in the local scope, we might have to rename it, so we
-  // refer to it symbolically instead of just assuming that it will be
-  // called "context".
-  this.contextId = contextId;
-
-  // An append-only list of Statements that grows each time this.emit is
-  // called.
-  this.listing = [];
-
-  // A sparse array whose keys correspond to locations in this.listing
-  // that have been marked as branch/jump targets.
-  this.marked = [true];
-  this.insertedLocs = new Set();
-
-  // The last location will be marked when this.getDispatchLoop is
-  // called.
-  this.finalLoc = this.loc();
-
-  // A list of all leap.TryEntry statements emitted.
-  this.tryEntries = [];
-
-  // Each time we evaluate the body of a loop, we tell this.leapManager
-  // to enter a nested loop context that determines the meaning of break
-  // and continue statements therein.
-  this.leapManager = new leap.LeapManager(this);
-}
-var Ep = Emitter.prototype;
-exports.Emitter = Emitter;
-
-// Offsets into this.listing that could be used as targets for branches or
-// jumps are represented as numeric Literal nodes. This representation has
-// the amazingly convenient benefit of allowing the exact value of the
-// location to be determined at any time, even after generating code that
-// refers to the location.
-// We use 'Number.MAX_VALUE' to mark uninitialized location. We can safely do
-// so because no code can realistically have about 1.8e+308 locations before
-// hitting memory limit of the machine it's running on. For comparison, the
-// estimated number of atoms in the observable universe is around 1e+80.
-var PENDING_LOCATION = Number.MAX_VALUE;
-Ep.loc = function () {
-  var l = util.getTypes().numericLiteral(PENDING_LOCATION);
-  this.insertedLocs.add(l);
-  return l;
-};
-Ep.getInsertedLocs = function () {
-  return this.insertedLocs;
-};
-Ep.getContextId = function () {
-  return util.getTypes().clone(this.contextId);
-};
-
-// Sets the exact value of the given location to the offset of the next
-// Statement emitted.
-Ep.mark = function (loc) {
-  util.getTypes().assertLiteral(loc);
-  var index = this.listing.length;
-  if (loc.value === PENDING_LOCATION) {
-    loc.value = index;
-  } else {
-    // Locations can be marked redundantly, but their values cannot change
-    // once set the first time.
-    _assert["default"].strictEqual(loc.value, index);
-  }
-  this.marked[index] = true;
-  return loc;
-};
-Ep.emit = function (node) {
-  var t = util.getTypes();
-  if (t.isExpression(node)) {
-    node = t.expressionStatement(node);
-  }
-  t.assertStatement(node);
-  this.listing.push(node);
-};
-
-// Shorthand for emitting assignment statements. This will come in handy
-// for assignments to temporary variables.
-Ep.emitAssign = function (lhs, rhs) {
-  this.emit(this.assign(lhs, rhs));
-  return lhs;
-};
-
-// Shorthand for an assignment statement.
-Ep.assign = function (lhs, rhs) {
-  var t = util.getTypes();
-  return t.expressionStatement(t.assignmentExpression("=", t.cloneDeep(lhs), rhs));
-};
-
-// Convenience function for generating expressions like context.next,
-// context.sent, and context.rval.
-Ep.contextProperty = function (name, computed) {
-  var t = util.getTypes();
-  return t.memberExpression(this.getContextId(), computed ? t.stringLiteral(name) : t.identifier(name), !!computed);
-};
-
-// Shorthand for setting context.rval and jumping to `context.stop()`.
-Ep.stop = function (rval) {
-  if (rval) {
-    this.setReturnValue(rval);
-  }
-  this.jump(this.finalLoc);
-};
-Ep.setReturnValue = function (valuePath) {
-  util.getTypes().assertExpression(valuePath.value);
-  this.emitAssign(this.contextProperty("rval"), this.explodeExpression(valuePath));
-};
-Ep.clearPendingException = function (tryLoc, assignee) {
-  var t = util.getTypes();
-  t.assertLiteral(tryLoc);
-  var catchCall = t.callExpression(this.contextProperty("catch", true), [t.clone(tryLoc)]);
-  if (assignee) {
-    this.emitAssign(assignee, catchCall);
-  } else {
-    this.emit(catchCall);
-  }
-};
-
-// Emits code for an unconditional jump to the given location, even if the
-// exact value of the location is not yet known.
-Ep.jump = function (toLoc) {
-  this.emitAssign(this.contextProperty("next"), toLoc);
-  this.emit(util.getTypes().breakStatement());
-};
-
-// Conditional jump.
-Ep.jumpIf = function (test, toLoc) {
-  var t = util.getTypes();
-  t.assertExpression(test);
-  t.assertLiteral(toLoc);
-  this.emit(t.ifStatement(test, t.blockStatement([this.assign(this.contextProperty("next"), toLoc), t.breakStatement()])));
-};
-
-// Conditional jump, with the condition negated.
-Ep.jumpIfNot = function (test, toLoc) {
-  var t = util.getTypes();
-  t.assertExpression(test);
-  t.assertLiteral(toLoc);
-  var negatedTest;
-  if (t.isUnaryExpression(test) && test.operator === "!") {
-    // Avoid double negation.
-    negatedTest = test.argument;
-  } else {
-    negatedTest = t.unaryExpression("!", test);
-  }
-  this.emit(t.ifStatement(negatedTest, t.blockStatement([this.assign(this.contextProperty("next"), toLoc), t.breakStatement()])));
-};
-
-// Returns a unique MemberExpression that can be used to store and
-// retrieve temporary values. Since the object of the member expression is
-// the context object, which is presumed to coexist peacefully with all
-// other local variables, and since we just increment `nextTempId`
-// monotonically, uniqueness is assured.
-Ep.makeTempVar = function () {
-  return this.contextProperty("t" + this.nextTempId++);
-};
-Ep.getContextFunction = function (id) {
-  var t = util.getTypes();
-  return t.functionExpression(id || null /*Anonymous*/, [this.getContextId()], t.blockStatement([this.getDispatchLoop()]), false,
-  // Not a generator anymore!
-  false // Nor an expression.
-  );
-};
-
-// Turns this.listing into a loop of the form
-//
-//   while (1) switch (context.next) {
-//   case 0:
-//   ...
-//   case n:
-//     return context.stop();
-//   }
-//
-// Each marked location in this.listing will correspond to one generated
-// case statement.
-Ep.getDispatchLoop = function () {
-  var self = this;
-  var t = util.getTypes();
-  var cases = [];
-  var current;
-
-  // If we encounter a break, continue, or return statement in a switch
-  // case, we can skip the rest of the statements until the next case.
-  var alreadyEnded = false;
-  self.listing.forEach(function (stmt, i) {
-    if (self.marked.hasOwnProperty(i)) {
-      cases.push(t.switchCase(t.numericLiteral(i), current = []));
-      alreadyEnded = false;
-    }
-    if (!alreadyEnded) {
-      current.push(stmt);
-      if (t.isCompletionStatement(stmt)) alreadyEnded = true;
-    }
-  });
-
-  // Now that we know how many statements there will be in this.listing,
-  // we can finally resolve this.finalLoc.value.
-  this.finalLoc.value = this.listing.length;
-  cases.push(t.switchCase(this.finalLoc, [
-    // Intentionally fall through to the "end" case...
-  ]),
-  // So that the runtime can jump to the final location without having
-  // to know its offset, we provide the "end" case as a synonym.
-  t.switchCase(t.stringLiteral("end"), [
-  // This will check/clear both context.thrown and context.rval.
-  t.returnStatement(t.callExpression(this.contextProperty("stop"), []))]));
-  return t.whileStatement(t.numericLiteral(1), t.switchStatement(t.assignmentExpression("=", this.contextProperty("prev"), this.contextProperty("next")), cases));
-};
-Ep.getTryLocsList = function () {
-  if (this.tryEntries.length === 0) {
-    // To avoid adding a needless [] to the majority of runtime.wrap
-    // argument lists, force the caller to handle this case specially.
-    return null;
-  }
-  var t = util.getTypes();
-  var lastLocValue = 0;
-  return t.arrayExpression(this.tryEntries.map(function (tryEntry) {
-    var thisLocValue = tryEntry.firstLoc.value;
-    _assert["default"].ok(thisLocValue >= lastLocValue, "try entries out of order");
-    lastLocValue = thisLocValue;
-    var ce = tryEntry.catchEntry;
-    var fe = tryEntry.finallyEntry;
-    var locs = [tryEntry.firstLoc,
-    // The null here makes a hole in the array.
-    ce ? ce.firstLoc : null];
-    if (fe) {
-      locs[2] = fe.firstLoc;
-      locs[3] = fe.afterLoc;
-    }
-    return t.arrayExpression(locs.map(function (loc) {
-      return loc && t.clone(loc);
-    }));
-  }));
-};
-
-// All side effects must be realized in order.
-
-// If any subexpression harbors a leap, all subexpressions must be
-// neutered of side effects.
-
-// No destructive modification of AST nodes.
-
-Ep.explode = function (path, ignoreResult) {
-  var t = util.getTypes();
-  var node = path.node;
-  var self = this;
-  t.assertNode(node);
-  if (t.isDeclaration(node)) throw getDeclError(node);
-  if (t.isStatement(node)) return self.explodeStatement(path);
-  if (t.isExpression(node)) return self.explodeExpression(path, ignoreResult);
-  switch (node.type) {
-    case "Program":
-      return path.get("body").map(self.explodeStatement, self);
-    case "VariableDeclarator":
-      throw getDeclError(node);
-
-    // These node types should be handled by their parent nodes
-    // (ObjectExpression, SwitchStatement, and TryStatement, respectively).
-    case "Property":
-    case "SwitchCase":
-    case "CatchClause":
-      throw new Error(node.type + " nodes should be handled by their parents");
-    default:
-      throw new Error("unknown Node of type " + JSON.stringify(node.type));
-  }
-};
-function getDeclError(node) {
-  return new Error("all declarations should have been transformed into " + "assignments before the Exploder began its work: " + JSON.stringify(node));
-}
-Ep.explodeStatement = function (path, labelId) {
-  var t = util.getTypes();
-  var stmt = path.node;
-  var self = this;
-  var before, after, head;
-  t.assertStatement(stmt);
-  if (labelId) {
-    t.assertIdentifier(labelId);
-  } else {
-    labelId = null;
-  }
-
-  // Explode BlockStatement nodes even if they do not contain a yield,
-  // because we don't want or need the curly braces.
-  if (t.isBlockStatement(stmt)) {
-    path.get("body").forEach(function (path) {
-      self.explodeStatement(path);
-    });
-    return;
-  }
-  if (!meta.containsLeap(stmt)) {
-    // Technically we should be able to avoid emitting the statement
-    // altogether if !meta.hasSideEffects(stmt), but that leads to
-    // confusing generated code (for instance, `while (true) {}` just
-    // disappears) and is probably a more appropriate job for a dedicated
-    // dead code elimination pass.
-    self.emit(stmt);
-    return;
-  }
-  switch (stmt.type) {
-    case "ExpressionStatement":
-      self.explodeExpression(path.get("expression"), true);
-      break;
-    case "LabeledStatement":
-      after = this.loc();
-
-      // Did you know you can break from any labeled block statement or
-      // control structure? Well, you can! Note: when a labeled loop is
-      // encountered, the leap.LabeledEntry created here will immediately
-      // enclose a leap.LoopEntry on the leap manager's stack, and both
-      // entries will have the same label. Though this works just fine, it
-      // may seem a bit redundant. In theory, we could check here to
-      // determine if stmt knows how to handle its own label; for example,
-      // stmt happens to be a WhileStatement and so we know it's going to
-      // establish its own LoopEntry when we explode it (below). Then this
-      // LabeledEntry would be unnecessary. Alternatively, we might be
-      // tempted not to pass stmt.label down into self.explodeStatement,
-      // because we've handled the label here, but that's a mistake because
-      // labeled loops may contain labeled continue statements, which is not
-      // something we can handle in this generic case. All in all, I think a
-      // little redundancy greatly simplifies the logic of this case, since
-      // it's clear that we handle all possible LabeledStatements correctly
-      // here, regardless of whether they interact with the leap manager
-      // themselves. Also remember that labels and break/continue-to-label
-      // statements are rare, and all of this logic happens at transform
-      // time, so it has no additional runtime cost.
-      self.leapManager.withEntry(new leap.LabeledEntry(after, stmt.label), function () {
-        self.explodeStatement(path.get("body"), stmt.label);
-      });
-      self.mark(after);
-      break;
-    case "WhileStatement":
-      before = this.loc();
-      after = this.loc();
-      self.mark(before);
-      self.jumpIfNot(self.explodeExpression(path.get("test")), after);
-      self.leapManager.withEntry(new leap.LoopEntry(after, before, labelId), function () {
-        self.explodeStatement(path.get("body"));
-      });
-      self.jump(before);
-      self.mark(after);
-      break;
-    case "DoWhileStatement":
-      var first = this.loc();
-      var test = this.loc();
-      after = this.loc();
-      self.mark(first);
-      self.leapManager.withEntry(new leap.LoopEntry(after, test, labelId), function () {
-        self.explode(path.get("body"));
-      });
-      self.mark(test);
-      self.jumpIf(self.explodeExpression(path.get("test")), first);
-      self.mark(after);
-      break;
-    case "ForStatement":
-      head = this.loc();
-      var update = this.loc();
-      after = this.loc();
-      if (stmt.init) {
-        // We pass true here to indicate that if stmt.init is an expression
-        // then we do not care about its result.
-        self.explode(path.get("init"), true);
-      }
-      self.mark(head);
-      if (stmt.test) {
-        self.jumpIfNot(self.explodeExpression(path.get("test")), after);
-      } else {
-        // No test means continue unconditionally.
-      }
-      self.leapManager.withEntry(new leap.LoopEntry(after, update, labelId), function () {
-        self.explodeStatement(path.get("body"));
-      });
-      self.mark(update);
-      if (stmt.update) {
-        // We pass true here to indicate that if stmt.update is an
-        // expression then we do not care about its result.
-        self.explode(path.get("update"), true);
-      }
-      self.jump(head);
-      self.mark(after);
-      break;
-    case "TypeCastExpression":
-      return self.explodeExpression(path.get("expression"));
-    case "ForInStatement":
-      head = this.loc();
-      after = this.loc();
-      var keyIterNextFn = self.makeTempVar();
-      self.emitAssign(keyIterNextFn, t.callExpression(util.runtimeProperty("keys"), [self.explodeExpression(path.get("right"))]));
-      self.mark(head);
-      var keyInfoTmpVar = self.makeTempVar();
-      self.jumpIf(t.memberExpression(t.assignmentExpression("=", keyInfoTmpVar, t.callExpression(t.cloneDeep(keyIterNextFn), [])), t.identifier("done"), false), after);
-      self.emitAssign(stmt.left, t.memberExpression(t.cloneDeep(keyInfoTmpVar), t.identifier("value"), false));
-      self.leapManager.withEntry(new leap.LoopEntry(after, head, labelId), function () {
-        self.explodeStatement(path.get("body"));
-      });
-      self.jump(head);
-      self.mark(after);
-      break;
-    case "BreakStatement":
-      self.emitAbruptCompletion({
-        type: "break",
-        target: self.leapManager.getBreakLoc(stmt.label)
-      });
-      break;
-    case "ContinueStatement":
-      self.emitAbruptCompletion({
-        type: "continue",
-        target: self.leapManager.getContinueLoc(stmt.label)
-      });
-      break;
-    case "SwitchStatement":
-      // Always save the discriminant into a temporary variable in case the
-      // test expressions overwrite values like context.sent.
-      var disc = self.emitAssign(self.makeTempVar(), self.explodeExpression(path.get("discriminant")));
-      after = this.loc();
-      var defaultLoc = this.loc();
-      var condition = defaultLoc;
-      var caseLocs = [];
-
-      // If there are no cases, .cases might be undefined.
-      var cases = stmt.cases || [];
-      for (var i = cases.length - 1; i >= 0; --i) {
-        var c = cases[i];
-        t.assertSwitchCase(c);
-        if (c.test) {
-          condition = t.conditionalExpression(t.binaryExpression("===", t.cloneDeep(disc), c.test), caseLocs[i] = this.loc(), condition);
-        } else {
-          caseLocs[i] = defaultLoc;
-        }
-      }
-      var discriminant = path.get("discriminant");
-      util.replaceWithOrRemove(discriminant, condition);
-      self.jump(self.explodeExpression(discriminant));
-      self.leapManager.withEntry(new leap.SwitchEntry(after), function () {
-        path.get("cases").forEach(function (casePath) {
-          var i = casePath.key;
-          self.mark(caseLocs[i]);
-          casePath.get("consequent").forEach(function (path) {
-            self.explodeStatement(path);
-          });
-        });
-      });
-      self.mark(after);
-      if (defaultLoc.value === PENDING_LOCATION) {
-        self.mark(defaultLoc);
-        _assert["default"].strictEqual(after.value, defaultLoc.value);
-      }
-      break;
-    case "IfStatement":
-      var elseLoc = stmt.alternate && this.loc();
-      after = this.loc();
-      self.jumpIfNot(self.explodeExpression(path.get("test")), elseLoc || after);
-      self.explodeStatement(path.get("consequent"));
-      if (elseLoc) {
-        self.jump(after);
-        self.mark(elseLoc);
-        self.explodeStatement(path.get("alternate"));
-      }
-      self.mark(after);
-      break;
-    case "ReturnStatement":
-      self.emitAbruptCompletion({
-        type: "return",
-        value: self.explodeExpression(path.get("argument"))
-      });
-      break;
-    case "WithStatement":
-      throw new Error("WithStatement not supported in generator functions.");
-    case "TryStatement":
-      after = this.loc();
-      var handler = stmt.handler;
-      var catchLoc = handler && this.loc();
-      var catchEntry = catchLoc && new leap.CatchEntry(catchLoc, handler.param);
-      var finallyLoc = stmt.finalizer && this.loc();
-      var finallyEntry = finallyLoc && new leap.FinallyEntry(finallyLoc, after);
-      var tryEntry = new leap.TryEntry(self.getUnmarkedCurrentLoc(), catchEntry, finallyEntry);
-      self.tryEntries.push(tryEntry);
-      self.updateContextPrevLoc(tryEntry.firstLoc);
-      self.leapManager.withEntry(tryEntry, function () {
-        self.explodeStatement(path.get("block"));
-        if (catchLoc) {
-          if (finallyLoc) {
-            // If we have both a catch block and a finally block, then
-            // because we emit the catch block first, we need to jump over
-            // it to the finally block.
-            self.jump(finallyLoc);
-          } else {
-            // If there is no finally block, then we need to jump over the
-            // catch block to the fall-through location.
-            self.jump(after);
-          }
-          self.updateContextPrevLoc(self.mark(catchLoc));
-          var bodyPath = path.get("handler.body");
-          var safeParam = self.makeTempVar();
-          self.clearPendingException(tryEntry.firstLoc, safeParam);
-          bodyPath.traverse(catchParamVisitor, {
-            getSafeParam: function getSafeParam() {
-              return t.cloneDeep(safeParam);
-            },
-            catchParamName: handler.param.name
-          });
-          self.leapManager.withEntry(catchEntry, function () {
-            self.explodeStatement(bodyPath);
-          });
-        }
-        if (finallyLoc) {
-          self.updateContextPrevLoc(self.mark(finallyLoc));
-          self.leapManager.withEntry(finallyEntry, function () {
-            self.explodeStatement(path.get("finalizer"));
-          });
-          self.emit(t.returnStatement(t.callExpression(self.contextProperty("finish"), [finallyEntry.firstLoc])));
-        }
-      });
-      self.mark(after);
-      break;
-    case "ThrowStatement":
-      self.emit(t.throwStatement(self.explodeExpression(path.get("argument"))));
-      break;
-    case "ClassDeclaration":
-      self.emit(self.explodeClass(path));
-      break;
-    default:
-      throw new Error("unknown Statement of type " + JSON.stringify(stmt.type));
-  }
-};
-var catchParamVisitor = {
-  Identifier: function Identifier(path, state) {
-    if (path.node.name === state.catchParamName && util.isReference(path)) {
-      util.replaceWithOrRemove(path, state.getSafeParam());
-    }
-  },
-  Scope: function Scope(path, state) {
-    if (path.scope.hasOwnBinding(state.catchParamName)) {
-      // Don't descend into nested scopes that shadow the catch
-      // parameter with their own declarations.
-      path.skip();
-    }
-  }
-};
-Ep.emitAbruptCompletion = function (record) {
-  if (!isValidCompletion(record)) {
-    _assert["default"].ok(false, "invalid completion record: " + JSON.stringify(record));
-  }
-  _assert["default"].notStrictEqual(record.type, "normal", "normal completions are not abrupt");
-  var t = util.getTypes();
-  var abruptArgs = [t.stringLiteral(record.type)];
-  if (record.type === "break" || record.type === "continue") {
-    t.assertLiteral(record.target);
-    abruptArgs[1] = this.insertedLocs.has(record.target) ? record.target : t.cloneDeep(record.target);
-  } else if (record.type === "return" || record.type === "throw") {
-    if (record.value) {
-      t.assertExpression(record.value);
-      abruptArgs[1] = this.insertedLocs.has(record.value) ? record.value : t.cloneDeep(record.value);
-    }
-  }
-  this.emit(t.returnStatement(t.callExpression(this.contextProperty("abrupt"), abruptArgs)));
-};
-function isValidCompletion(record) {
-  var type = record.type;
-  if (type === "normal") {
-    return !hasOwn.call(record, "target");
-  }
-  if (type === "break" || type === "continue") {
-    return !hasOwn.call(record, "value") && util.getTypes().isLiteral(record.target);
-  }
-  if (type === "return" || type === "throw") {
-    return hasOwn.call(record, "value") && !hasOwn.call(record, "target");
-  }
-  return false;
-}
-
-// Not all offsets into emitter.listing are potential jump targets. For
-// example, execution typically falls into the beginning of a try block
-// without jumping directly there. This method returns the current offset
-// without marking it, so that a switch case will not necessarily be
-// generated for this offset (I say "not necessarily" because the same
-// location might end up being marked in the process of emitting other
-// statements). There's no logical harm in marking such locations as jump
-// targets, but minimizing the number of switch cases keeps the generated
-// code shorter.
-Ep.getUnmarkedCurrentLoc = function () {
-  return util.getTypes().numericLiteral(this.listing.length);
-};
-
-// The context.prev property takes the value of context.next whenever we
-// evaluate the switch statement discriminant, which is generally good
-// enough for tracking the last location we jumped to, but sometimes
-// context.prev needs to be more precise, such as when we fall
-// successfully out of a try block and into a finally block without
-// jumping. This method exists to update context.prev to the freshest
-// available location. If we were implementing a full interpreter, we
-// would know the location of the current instruction with complete
-// precision at all times, but we don't have that luxury here, as it would
-// be costly and verbose to set context.prev before every statement.
-Ep.updateContextPrevLoc = function (loc) {
-  var t = util.getTypes();
-  if (loc) {
-    t.assertLiteral(loc);
-    if (loc.value === PENDING_LOCATION) {
-      // If an uninitialized location literal was passed in, set its value
-      // to the current this.listing.length.
-      loc.value = this.listing.length;
-    } else {
-      // Otherwise assert that the location matches the current offset.
-      _assert["default"].strictEqual(loc.value, this.listing.length);
-    }
-  } else {
-    loc = this.getUnmarkedCurrentLoc();
-  }
-
-  // Make sure context.prev is up to date in case we fell into this try
-  // statement without jumping to it. TODO Consider avoiding this
-  // assignment when we know control must have jumped here.
-  this.emitAssign(this.contextProperty("prev"), loc);
-};
-
-// In order to save the rest of explodeExpression from a combinatorial
-// trainwreck of special cases, explodeViaTempVar is responsible for
-// deciding when a subexpression needs to be "exploded," which is my
-// very technical term for emitting the subexpression as an assignment
-// to a temporary variable and the substituting the temporary variable
-// for the original subexpression. Think of exploded view diagrams, not
-// Michael Bay movies. The point of exploding subexpressions is to
-// control the precise order in which the generated code realizes the
-// side effects of those subexpressions.
-Ep.explodeViaTempVar = function (tempVar, childPath, hasLeapingChildren, ignoreChildResult) {
-  _assert["default"].ok(!ignoreChildResult || !tempVar, "Ignoring the result of a child expression but forcing it to " + "be assigned to a temporary variable?");
-  var t = util.getTypes();
-  var result = this.explodeExpression(childPath, ignoreChildResult);
-  if (ignoreChildResult) {
-    // Side effects already emitted above.
-  } else if (tempVar || hasLeapingChildren && !t.isLiteral(result)) {
-    // If tempVar was provided, then the result will always be assigned
-    // to it, even if the result does not otherwise need to be assigned
-    // to a temporary variable.  When no tempVar is provided, we have
-    // the flexibility to decide whether a temporary variable is really
-    // necessary.  Unfortunately, in general, a temporary variable is
-    // required whenever any child contains a yield expression, since it
-    // is difficult to prove (at all, let alone efficiently) whether
-    // this result would evaluate to the same value before and after the
-    // yield (see #206).  One narrow case where we can prove it doesn't
-    // matter (and thus we do not need a temporary variable) is when the
-    // result in question is a Literal value.
-    result = this.emitAssign(tempVar || this.makeTempVar(), result);
-  }
-  return result;
-};
-Ep.explodeExpression = function (path, ignoreResult) {
-  var t = util.getTypes();
-  var expr = path.node;
-  if (expr) {
-    t.assertExpression(expr);
-  } else {
-    return expr;
-  }
-  var self = this;
-  var result; // Used optionally by several cases below.
-  var after;
-  function finish(expr) {
-    t.assertExpression(expr);
-    if (ignoreResult) {
-      self.emit(expr);
-    }
-    return expr;
-  }
-
-  // If the expression does not contain a leap, then we either emit the
-  // expression as a standalone statement or return it whole.
-  if (!meta.containsLeap(expr)) {
-    return finish(expr);
-  }
-
-  // If any child contains a leap (such as a yield or labeled continue or
-  // break statement), then any sibling subexpressions will almost
-  // certainly have to be exploded in order to maintain the order of their
-  // side effects relative to the leaping child(ren).
-  var hasLeapingChildren = meta.containsLeap.onlyChildren(expr);
-
-  // If ignoreResult is true, then we must take full responsibility for
-  // emitting the expression with all its side effects, and we should not
-  // return a result.
-
-  switch (expr.type) {
-    case "MemberExpression":
-      return finish(t.memberExpression(self.explodeExpression(path.get("object")), expr.computed ? self.explodeViaTempVar(null, path.get("property"), hasLeapingChildren) : expr.property, expr.computed));
-    case "CallExpression":
-      var calleePath = path.get("callee");
-      var argsPath = path.get("arguments");
-      var newCallee;
-      var newArgs;
-      var hasLeapingArgs = argsPath.some(function (argPath) {
-        return meta.containsLeap(argPath.node);
-      });
-      var injectFirstArg = null;
-      if (t.isMemberExpression(calleePath.node)) {
-        if (hasLeapingArgs) {
-          // If the arguments of the CallExpression contained any yield
-          // expressions, then we need to be sure to evaluate the callee
-          // before evaluating the arguments, but if the callee was a member
-          // expression, then we must be careful that the object of the
-          // member expression still gets bound to `this` for the call.
-
-          var newObject = self.explodeViaTempVar(
-          // Assign the exploded callee.object expression to a temporary
-          // variable so that we can use it twice without reevaluating it.
-          self.makeTempVar(), calleePath.get("object"), hasLeapingChildren);
-          var newProperty = calleePath.node.computed ? self.explodeViaTempVar(null, calleePath.get("property"), hasLeapingChildren) : calleePath.node.property;
-          injectFirstArg = newObject;
-          newCallee = t.memberExpression(t.memberExpression(t.cloneDeep(newObject), newProperty, calleePath.node.computed), t.identifier("call"), false);
-        } else {
-          newCallee = self.explodeExpression(calleePath);
-        }
-      } else {
-        newCallee = self.explodeViaTempVar(null, calleePath, hasLeapingChildren);
-        if (t.isMemberExpression(newCallee)) {
-          // If the callee was not previously a MemberExpression, then the
-          // CallExpression was "unqualified," meaning its `this` object
-          // should be the global object. If the exploded expression has
-          // become a MemberExpression (e.g. a context property, probably a
-          // temporary variable), then we need to force it to be unqualified
-          // by using the (0, object.property)(...) trick; otherwise, it
-          // will receive the object of the MemberExpression as its `this`
-          // object.
-          newCallee = t.sequenceExpression([t.numericLiteral(0), t.cloneDeep(newCallee)]);
-        }
-      }
-      if (hasLeapingArgs) {
-        newArgs = argsPath.map(function (argPath) {
-          return self.explodeViaTempVar(null, argPath, hasLeapingChildren);
-        });
-        if (injectFirstArg) newArgs.unshift(injectFirstArg);
-        newArgs = newArgs.map(function (arg) {
-          return t.cloneDeep(arg);
-        });
-      } else {
-        newArgs = path.node.arguments;
-      }
-      return finish(t.callExpression(newCallee, newArgs));
-    case "NewExpression":
-      return finish(t.newExpression(self.explodeViaTempVar(null, path.get("callee"), hasLeapingChildren), path.get("arguments").map(function (argPath) {
-        return self.explodeViaTempVar(null, argPath, hasLeapingChildren);
-      })));
-    case "ObjectExpression":
-      return finish(t.objectExpression(path.get("properties").map(function (propPath) {
-        if (propPath.isObjectProperty()) {
-          return t.objectProperty(propPath.node.key, self.explodeViaTempVar(null, propPath.get("value"), hasLeapingChildren), propPath.node.computed);
-        } else {
-          return propPath.node;
-        }
-      })));
-    case "ArrayExpression":
-      return finish(t.arrayExpression(path.get("elements").map(function (elemPath) {
-        if (!elemPath.node) {
-          return null;
-        }
-        if (elemPath.isSpreadElement()) {
-          return t.spreadElement(self.explodeViaTempVar(null, elemPath.get("argument"), hasLeapingChildren));
-        } else {
-          return self.explodeViaTempVar(null, elemPath, hasLeapingChildren);
-        }
-      })));
-    case "SequenceExpression":
-      var lastIndex = expr.expressions.length - 1;
-      path.get("expressions").forEach(function (exprPath) {
-        if (exprPath.key === lastIndex) {
-          result = self.explodeExpression(exprPath, ignoreResult);
-        } else {
-          self.explodeExpression(exprPath, true);
-        }
-      });
-      return result;
-    case "LogicalExpression":
-      after = this.loc();
-      if (!ignoreResult) {
-        result = self.makeTempVar();
-      }
-      var left = self.explodeViaTempVar(result, path.get("left"), hasLeapingChildren);
-      if (expr.operator === "&&") {
-        self.jumpIfNot(left, after);
-      } else {
-        _assert["default"].strictEqual(expr.operator, "||");
-        self.jumpIf(left, after);
-      }
-      self.explodeViaTempVar(result, path.get("right"), hasLeapingChildren, ignoreResult);
-      self.mark(after);
-      return result;
-    case "ConditionalExpression":
-      var elseLoc = this.loc();
-      after = this.loc();
-      var test = self.explodeExpression(path.get("test"));
-      self.jumpIfNot(test, elseLoc);
-      if (!ignoreResult) {
-        result = self.makeTempVar();
-      }
-      self.explodeViaTempVar(result, path.get("consequent"), hasLeapingChildren, ignoreResult);
-      self.jump(after);
-      self.mark(elseLoc);
-      self.explodeViaTempVar(result, path.get("alternate"), hasLeapingChildren, ignoreResult);
-      self.mark(after);
-      return result;
-    case "UnaryExpression":
-      return finish(t.unaryExpression(expr.operator,
-      // Can't (and don't need to) break up the syntax of the argument.
-      // Think about delete a[b].
-      self.explodeExpression(path.get("argument")), !!expr.prefix));
-    case "BinaryExpression":
-      return finish(t.binaryExpression(expr.operator, self.explodeViaTempVar(null, path.get("left"), hasLeapingChildren), self.explodeViaTempVar(null, path.get("right"), hasLeapingChildren)));
-    case "AssignmentExpression":
-      if (expr.operator === "=") {
-        // If this is a simple assignment, the left hand side does not need
-        // to be read before the right hand side is evaluated, so we can
-        // avoid the more complicated logic below.
-        return finish(t.assignmentExpression(expr.operator, self.explodeExpression(path.get("left")), self.explodeExpression(path.get("right"))));
-      }
-      var lhs = self.explodeExpression(path.get("left"));
-      var temp = self.emitAssign(self.makeTempVar(), lhs);
-
-      // For example,
-      //
-      //   x += yield y
-      //
-      // becomes
-      //
-      //   context.t0 = x
-      //   x = context.t0 += yield y
-      //
-      // so that the left-hand side expression is read before the yield.
-      // Fixes https://github.com/facebook/regenerator/issues/345.
-
-      return finish(t.assignmentExpression("=", t.cloneDeep(lhs), t.assignmentExpression(expr.operator, t.cloneDeep(temp), self.explodeExpression(path.get("right")))));
-    case "UpdateExpression":
-      return finish(t.updateExpression(expr.operator, self.explodeExpression(path.get("argument")), expr.prefix));
-    case "YieldExpression":
-      after = this.loc();
-      var arg = expr.argument && self.explodeExpression(path.get("argument"));
-      if (arg && expr.delegate) {
-        var _result = self.makeTempVar();
-        var _ret = t.returnStatement(t.callExpression(self.contextProperty("delegateYield"), [arg, t.stringLiteral(_result.property.name), after]));
-        _ret.loc = expr.loc;
-        self.emit(_ret);
-        self.mark(after);
-        return _result;
-      }
-      self.emitAssign(self.contextProperty("next"), after);
-      var ret = t.returnStatement(t.cloneDeep(arg) || null);
-      // Preserve the `yield` location so that source mappings for the statements
-      // link back to the yield properly.
-      ret.loc = expr.loc;
-      self.emit(ret);
-      self.mark(after);
-      return self.contextProperty("sent");
-    case "ClassExpression":
-      return finish(self.explodeClass(path));
-    default:
-      throw new Error("unknown Expression of type " + JSON.stringify(expr.type));
-  }
-};
-Ep.explodeClass = function (path) {
-  var explodingChildren = [];
-  if (path.node.superClass) {
-    explodingChildren.push(path.get("superClass"));
-  }
-  path.get("body.body").forEach(function (member) {
-    if (member.node.computed) {
-      explodingChildren.push(member.get("key"));
-    }
-  });
-  var hasLeapingChildren = explodingChildren.some(function (child) {
-    return meta.containsLeap(child);
-  });
-  for (var i = 0; i < explodingChildren.length; i++) {
-    var child = explodingChildren[i];
-    var isLast = i === explodingChildren.length - 1;
-    if (isLast) {
-      child.replaceWith(this.explodeExpression(child));
-    } else {
-      child.replaceWith(this.explodeViaTempVar(null, child, hasLeapingChildren));
-    }
-  }
-  return path.node;
-};
\ No newline at end of file
diff --git a/node_modules/regenerator-transform/lib/hoist.js b/node_modules/regenerator-transform/lib/hoist.js
deleted file mode 100644
index 5cdd6950..00000000
--- a/node_modules/regenerator-transform/lib/hoist.js
+++ /dev/null
@@ -1,132 +0,0 @@
-"use strict";
-
-var util = _interopRequireWildcard(require("./util"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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; }
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var hasOwn = Object.prototype.hasOwnProperty;
-
-// The hoist function takes a FunctionExpression or FunctionDeclaration
-// and replaces any Declaration nodes in its body with assignments, then
-// returns a VariableDeclaration containing just the names of the removed
-// declarations.
-exports.hoist = function (funPath) {
-  var t = util.getTypes();
-  t.assertFunction(funPath.node);
-  var vars = {};
-  function varDeclToExpr(_ref, includeIdentifiers) {
-    var vdec = _ref.node,
-      scope = _ref.scope;
-    t.assertVariableDeclaration(vdec);
-    // TODO assert.equal(vdec.kind, "var");
-    var exprs = [];
-    vdec.declarations.forEach(function (dec) {
-      // Note: We duplicate 'dec.id' here to ensure that the variable declaration IDs don't
-      // have the same 'loc' value, since that can make sourcemaps and retainLines behave poorly.
-      vars[dec.id.name] = t.identifier(dec.id.name);
-
-      // Remove the binding, to avoid "duplicate declaration" errors when it will
-      // be injected again.
-      scope.removeBinding(dec.id.name);
-      if (dec.init) {
-        exprs.push(t.assignmentExpression("=", dec.id, dec.init));
-      } else if (includeIdentifiers) {
-        exprs.push(dec.id);
-      }
-    });
-    if (exprs.length === 0) return null;
-    if (exprs.length === 1) return exprs[0];
-    return t.sequenceExpression(exprs);
-  }
-  funPath.get("body").traverse({
-    VariableDeclaration: {
-      exit: function exit(path) {
-        var expr = varDeclToExpr(path, false);
-        if (expr === null) {
-          path.remove();
-        } else {
-          // We don't need to traverse this expression any further because
-          // there can't be any new declarations inside an expression.
-          util.replaceWithOrRemove(path, t.expressionStatement(expr));
-        }
-
-        // Since the original node has been either removed or replaced,
-        // avoid traversing it any further.
-        path.skip();
-      }
-    },
-    ForStatement: function ForStatement(path) {
-      var init = path.get("init");
-      if (init.isVariableDeclaration()) {
-        util.replaceWithOrRemove(init, varDeclToExpr(init, false));
-      }
-    },
-    ForXStatement: function ForXStatement(path) {
-      var left = path.get("left");
-      if (left.isVariableDeclaration()) {
-        util.replaceWithOrRemove(left, varDeclToExpr(left, true));
-      }
-    },
-    FunctionDeclaration: function FunctionDeclaration(path) {
-      var node = path.node;
-      vars[node.id.name] = node.id;
-      var assignment = t.expressionStatement(t.assignmentExpression("=", t.clone(node.id), t.functionExpression(path.scope.generateUidIdentifierBasedOnNode(node), node.params, node.body, node.generator, node.expression)));
-      if (path.parentPath.isBlockStatement()) {
-        // Insert the assignment form before the first statement in the
-        // enclosing block.
-        path.parentPath.unshiftContainer("body", assignment);
-
-        // Remove the function declaration now that we've inserted the
-        // equivalent assignment form at the beginning of the block.
-        path.remove();
-      } else {
-        // If the parent node is not a block statement, then we can just
-        // replace the declaration with the equivalent assignment form
-        // without worrying about hoisting it.
-        util.replaceWithOrRemove(path, assignment);
-      }
-
-      // Remove the binding, to avoid "duplicate declaration" errors when it will
-      // be injected again.
-      path.scope.removeBinding(node.id.name);
-
-      // Don't hoist variables out of inner functions.
-      path.skip();
-    },
-    FunctionExpression: function FunctionExpression(path) {
-      // Don't descend into nested function expressions.
-      path.skip();
-    },
-    ArrowFunctionExpression: function ArrowFunctionExpression(path) {
-      // Don't descend into nested function expressions.
-      path.skip();
-    }
-  });
-  var paramNames = {};
-  funPath.get("params").forEach(function (paramPath) {
-    var param = paramPath.node;
-    if (t.isIdentifier(param)) {
-      paramNames[param.name] = param;
-    } else {
-      // Variables declared by destructuring parameter patterns will be
-      // harmlessly re-declared.
-    }
-  });
-  var declarations = [];
-  Object.keys(vars).forEach(function (name) {
-    if (!hasOwn.call(paramNames, name)) {
-      declarations.push(t.variableDeclarator(vars[name], null));
-    }
-  });
-  if (declarations.length === 0) {
-    return null; // Be sure to handle this case!
-  }
-
-  return t.variableDeclaration("var", declarations);
-};
\ No newline at end of file
diff --git a/node_modules/regenerator-transform/lib/index.js b/node_modules/regenerator-transform/lib/index.js
deleted file mode 100644
index 37ca8392..00000000
--- a/node_modules/regenerator-transform/lib/index.js
+++ /dev/null
@@ -1,29 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports["default"] = _default;
-var _visit = require("./visit");
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-function _default(context) {
-  var plugin = {
-    visitor: (0, _visit.getVisitor)(context)
-  };
-
-  // Some presets manually call child presets, but fail to pass along the
-  // context object. Out of an abundance of caution, we verify that it
-  // exists first to avoid causing unnecessary breaking changes.
-  var version = context && context.version;
-
-  // The "name" property is not allowed in older versions of Babel (6.x)
-  // and will cause the plugin validator to throw an exception.
-  if (version && parseInt(version, 10) >= 7) {
-    plugin.name = "regenerator-transform";
-  }
-  return plugin;
-}
\ No newline at end of file
diff --git a/node_modules/regenerator-transform/lib/leap.js b/node_modules/regenerator-transform/lib/leap.js
deleted file mode 100644
index 60fcc2d1..00000000
--- a/node_modules/regenerator-transform/lib/leap.js
+++ /dev/null
@@ -1,143 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _assert = _interopRequireDefault(require("assert"));
-var _emit = require("./emit");
-var _util = require("util");
-var _util2 = require("./util");
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-function Entry() {
-  _assert["default"].ok(this instanceof Entry);
-}
-function FunctionEntry(returnLoc) {
-  Entry.call(this);
-  (0, _util2.getTypes)().assertLiteral(returnLoc);
-  this.returnLoc = returnLoc;
-}
-(0, _util.inherits)(FunctionEntry, Entry);
-exports.FunctionEntry = FunctionEntry;
-function LoopEntry(breakLoc, continueLoc, label) {
-  Entry.call(this);
-  var t = (0, _util2.getTypes)();
-  t.assertLiteral(breakLoc);
-  t.assertLiteral(continueLoc);
-  if (label) {
-    t.assertIdentifier(label);
-  } else {
-    label = null;
-  }
-  this.breakLoc = breakLoc;
-  this.continueLoc = continueLoc;
-  this.label = label;
-}
-(0, _util.inherits)(LoopEntry, Entry);
-exports.LoopEntry = LoopEntry;
-function SwitchEntry(breakLoc) {
-  Entry.call(this);
-  (0, _util2.getTypes)().assertLiteral(breakLoc);
-  this.breakLoc = breakLoc;
-}
-(0, _util.inherits)(SwitchEntry, Entry);
-exports.SwitchEntry = SwitchEntry;
-function TryEntry(firstLoc, catchEntry, finallyEntry) {
-  Entry.call(this);
-  var t = (0, _util2.getTypes)();
-  t.assertLiteral(firstLoc);
-  if (catchEntry) {
-    _assert["default"].ok(catchEntry instanceof CatchEntry);
-  } else {
-    catchEntry = null;
-  }
-  if (finallyEntry) {
-    _assert["default"].ok(finallyEntry instanceof FinallyEntry);
-  } else {
-    finallyEntry = null;
-  }
-
-  // Have to have one or the other (or both).
-  _assert["default"].ok(catchEntry || finallyEntry);
-  this.firstLoc = firstLoc;
-  this.catchEntry = catchEntry;
-  this.finallyEntry = finallyEntry;
-}
-(0, _util.inherits)(TryEntry, Entry);
-exports.TryEntry = TryEntry;
-function CatchEntry(firstLoc, paramId) {
-  Entry.call(this);
-  var t = (0, _util2.getTypes)();
-  t.assertLiteral(firstLoc);
-  t.assertIdentifier(paramId);
-  this.firstLoc = firstLoc;
-  this.paramId = paramId;
-}
-(0, _util.inherits)(CatchEntry, Entry);
-exports.CatchEntry = CatchEntry;
-function FinallyEntry(firstLoc, afterLoc) {
-  Entry.call(this);
-  var t = (0, _util2.getTypes)();
-  t.assertLiteral(firstLoc);
-  t.assertLiteral(afterLoc);
-  this.firstLoc = firstLoc;
-  this.afterLoc = afterLoc;
-}
-(0, _util.inherits)(FinallyEntry, Entry);
-exports.FinallyEntry = FinallyEntry;
-function LabeledEntry(breakLoc, label) {
-  Entry.call(this);
-  var t = (0, _util2.getTypes)();
-  t.assertLiteral(breakLoc);
-  t.assertIdentifier(label);
-  this.breakLoc = breakLoc;
-  this.label = label;
-}
-(0, _util.inherits)(LabeledEntry, Entry);
-exports.LabeledEntry = LabeledEntry;
-function LeapManager(emitter) {
-  _assert["default"].ok(this instanceof LeapManager);
-  _assert["default"].ok(emitter instanceof _emit.Emitter);
-  this.emitter = emitter;
-  this.entryStack = [new FunctionEntry(emitter.finalLoc)];
-}
-var LMp = LeapManager.prototype;
-exports.LeapManager = LeapManager;
-LMp.withEntry = function (entry, callback) {
-  _assert["default"].ok(entry instanceof Entry);
-  this.entryStack.push(entry);
-  try {
-    callback.call(this.emitter);
-  } finally {
-    var popped = this.entryStack.pop();
-    _assert["default"].strictEqual(popped, entry);
-  }
-};
-LMp._findLeapLocation = function (property, label) {
-  for (var i = this.entryStack.length - 1; i >= 0; --i) {
-    var entry = this.entryStack[i];
-    var loc = entry[property];
-    if (loc) {
-      if (label) {
-        if (entry.label && entry.label.name === label.name) {
-          return loc;
-        }
-      } else if (entry instanceof LabeledEntry) {
-        // Ignore LabeledEntry entries unless we are actually breaking to
-        // a label.
-      } else {
-        return loc;
-      }
-    }
-  }
-  return null;
-};
-LMp.getBreakLoc = function (label) {
-  return this._findLeapLocation("breakLoc", label);
-};
-LMp.getContinueLoc = function (label) {
-  return this._findLeapLocation("continueLoc", label);
-};
\ No newline at end of file
diff --git a/node_modules/regenerator-transform/lib/meta.js b/node_modules/regenerator-transform/lib/meta.js
deleted file mode 100644
index ad6cec20..00000000
--- a/node_modules/regenerator-transform/lib/meta.js
+++ /dev/null
@@ -1,102 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _assert = _interopRequireDefault(require("assert"));
-var _util = require("./util.js");
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var mMap = new WeakMap();
-function m(node) {
-  if (!mMap.has(node)) {
-    mMap.set(node, {});
-  }
-  return mMap.get(node);
-}
-var hasOwn = Object.prototype.hasOwnProperty;
-function makePredicate(propertyName, knownTypes) {
-  function onlyChildren(node) {
-    var t = (0, _util.getTypes)();
-    t.assertNode(node);
-
-    // Assume no side effects until we find out otherwise.
-    var result = false;
-    function check(child) {
-      if (result) {
-        // Do nothing.
-      } else if (Array.isArray(child)) {
-        child.some(check);
-      } else if (t.isNode(child)) {
-        _assert["default"].strictEqual(result, false);
-        result = predicate(child);
-      }
-      return result;
-    }
-    var keys = t.VISITOR_KEYS[node.type];
-    if (keys) {
-      for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        var child = node[key];
-        check(child);
-      }
-    }
-    return result;
-  }
-  function predicate(node) {
-    (0, _util.getTypes)().assertNode(node);
-    var meta = m(node);
-    if (hasOwn.call(meta, propertyName)) return meta[propertyName];
-
-    // Certain types are "opaque," which means they have no side
-    // effects or leaps and we don't care about their subexpressions.
-    if (hasOwn.call(opaqueTypes, node.type)) return meta[propertyName] = false;
-    if (hasOwn.call(knownTypes, node.type)) return meta[propertyName] = true;
-    return meta[propertyName] = onlyChildren(node);
-  }
-  predicate.onlyChildren = onlyChildren;
-  return predicate;
-}
-var opaqueTypes = {
-  FunctionExpression: true,
-  ArrowFunctionExpression: true
-};
-
-// These types potentially have side effects regardless of what side
-// effects their subexpressions have.
-var sideEffectTypes = {
-  CallExpression: true,
-  // Anything could happen!
-  ForInStatement: true,
-  // Modifies the key variable.
-  UnaryExpression: true,
-  // Think delete.
-  BinaryExpression: true,
-  // Might invoke .toString() or .valueOf().
-  AssignmentExpression: true,
-  // Side-effecting by definition.
-  UpdateExpression: true,
-  // Updates are essentially assignments.
-  NewExpression: true // Similar to CallExpression.
-};
-
-// These types are the direct cause of all leaps in control flow.
-var leapTypes = {
-  YieldExpression: true,
-  BreakStatement: true,
-  ContinueStatement: true,
-  ReturnStatement: true,
-  ThrowStatement: true
-};
-
-// All leap types are also side effect types.
-for (var type in leapTypes) {
-  if (hasOwn.call(leapTypes, type)) {
-    sideEffectTypes[type] = leapTypes[type];
-  }
-}
-exports.hasSideEffects = makePredicate("hasSideEffects", sideEffectTypes);
-exports.containsLeap = makePredicate("containsLeap", leapTypes);
\ No newline at end of file
diff --git a/node_modules/regenerator-transform/lib/replaceShorthandObjectMethod.js b/node_modules/regenerator-transform/lib/replaceShorthandObjectMethod.js
deleted file mode 100644
index 5a4c656c..00000000
--- a/node_modules/regenerator-transform/lib/replaceShorthandObjectMethod.js
+++ /dev/null
@@ -1,83 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports["default"] = replaceShorthandObjectMethod;
-var util = _interopRequireWildcard(require("./util"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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; }
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// this function converts a shorthand object generator method into a normal
-// (non-shorthand) object property which is a generator function expression. for
-// example, this:
-//
-//  var foo = {
-//    *bar(baz) { return 5; }
-//  }
-//
-// should be replaced with:
-//
-//  var foo = {
-//    bar: function*(baz) { return 5; }
-//  }
-//
-// to do this, it clones the parameter array and the body of the object generator
-// method into a new FunctionExpression.
-//
-// this method can be passed any Function AST node path, and it will return
-// either:
-//   a) the path that was passed in (iff the path did not need to be replaced) or
-//   b) the path of the new FunctionExpression that was created as a replacement
-//     (iff the path did need to be replaced)
-//
-// In either case, though, the caller can count on the fact that the return value
-// is a Function AST node path.
-//
-// If this function is called with an AST node path that is not a Function (or with an
-// argument that isn't an AST node path), it will throw an error.
-function replaceShorthandObjectMethod(path) {
-  var t = util.getTypes();
-  if (!path.node || !t.isFunction(path.node)) {
-    throw new Error("replaceShorthandObjectMethod can only be called on Function AST node paths.");
-  }
-
-  // this function only replaces shorthand object methods (called ObjectMethod
-  // in Babel-speak).
-  if (!t.isObjectMethod(path.node)) {
-    return path;
-  }
-
-  // this function only replaces generators.
-  if (!path.node.generator) {
-    return path;
-  }
-  var parameters = path.node.params.map(function (param) {
-    return t.cloneDeep(param);
-  });
-  var functionExpression = t.functionExpression(null,
-  // id
-  parameters,
-  // params
-  t.cloneDeep(path.node.body),
-  // body
-  path.node.generator, path.node.async);
-  util.replaceWithOrRemove(path, t.objectProperty(t.cloneDeep(path.node.key),
-  // key
-  functionExpression,
-  //value
-  path.node.computed,
-  // computed
-  false // shorthand
-  ));
-
-  // path now refers to the ObjectProperty AST node path, but we want to return a
-  // Function AST node path for the function expression we created. we know that
-  // the FunctionExpression we just created is the value of the ObjectProperty,
-  // so return the "value" path off of this path.
-  return path.get("value");
-}
\ No newline at end of file
diff --git a/node_modules/regenerator-transform/lib/util.js b/node_modules/regenerator-transform/lib/util.js
deleted file mode 100644
index 535cbed4..00000000
--- a/node_modules/regenerator-transform/lib/util.js
+++ /dev/null
@@ -1,49 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.getTypes = getTypes;
-exports.isReference = isReference;
-exports.replaceWithOrRemove = replaceWithOrRemove;
-exports.runtimeProperty = runtimeProperty;
-exports.wrapWithTypes = wrapWithTypes;
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var currentTypes = null;
-function wrapWithTypes(types, fn) {
-  return function () {
-    var oldTypes = currentTypes;
-    currentTypes = types;
-    try {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      return fn.apply(this, args);
-    } finally {
-      currentTypes = oldTypes;
-    }
-  };
-}
-function getTypes() {
-  return currentTypes;
-}
-function runtimeProperty(name) {
-  var t = getTypes();
-  return t.memberExpression(t.identifier("regeneratorRuntime"), t.identifier(name), false);
-}
-function isReference(path) {
-  return path.isReferenced() || path.parentPath.isAssignmentExpression({
-    left: path.node
-  });
-}
-function replaceWithOrRemove(path, replacement) {
-  if (replacement) {
-    path.replaceWith(replacement);
-  } else {
-    path.remove();
-  }
-}
\ No newline at end of file
diff --git a/node_modules/regenerator-transform/lib/visit.js b/node_modules/regenerator-transform/lib/visit.js
deleted file mode 100644
index 12767aa0..00000000
--- a/node_modules/regenerator-transform/lib/visit.js
+++ /dev/null
@@ -1,290 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _assert = _interopRequireDefault(require("assert"));
-var _hoist = require("./hoist");
-var _emit = require("./emit");
-var _replaceShorthandObjectMethod = _interopRequireDefault(require("./replaceShorthandObjectMethod"));
-var util = _interopRequireWildcard(require("./util"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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; }
-exports.getVisitor = function (_ref) {
-  var t = _ref.types;
-  return {
-    Method: function Method(path, state) {
-      var node = path.node;
-      if (!shouldRegenerate(node, state)) return;
-      var container = t.functionExpression(null, [], t.cloneNode(node.body, false), node.generator, node.async);
-      path.get("body").set("body", [t.returnStatement(t.callExpression(container, []))]);
-
-      // Regardless of whether or not the wrapped function is a an async method
-      // or generator the outer function should not be
-      node.async = false;
-      node.generator = false;
-
-      // Unwrap the wrapper IIFE's environment so super and this and such still work.
-      path.get("body.body.0.argument.callee").unwrapFunctionEnvironment();
-    },
-    Function: {
-      exit: util.wrapWithTypes(t, function (path, state) {
-        var node = path.node;
-        if (!shouldRegenerate(node, state)) return;
-
-        // if this is an ObjectMethod, we need to convert it to an ObjectProperty
-        path = (0, _replaceShorthandObjectMethod["default"])(path);
-        node = path.node;
-        var contextId = path.scope.generateUidIdentifier("context");
-        var argsId = path.scope.generateUidIdentifier("args");
-        path.ensureBlock();
-        var bodyBlockPath = path.get("body");
-        if (node.async) {
-          bodyBlockPath.traverse(awaitVisitor);
-        }
-        bodyBlockPath.traverse(functionSentVisitor, {
-          context: contextId
-        });
-        var outerBody = [];
-        var innerBody = [];
-        bodyBlockPath.get("body").forEach(function (childPath) {
-          var node = childPath.node;
-          if (t.isExpressionStatement(node) && t.isStringLiteral(node.expression)) {
-            // Babylon represents directives like "use strict" as elements
-            // of a bodyBlockPath.node.directives array, but they could just
-            // as easily be represented (by other parsers) as traditional
-            // string-literal-valued expression statements, so we need to
-            // handle that here. (#248)
-            outerBody.push(node);
-          } else if (node && node._blockHoist != null) {
-            outerBody.push(node);
-          } else {
-            innerBody.push(node);
-          }
-        });
-        if (outerBody.length > 0) {
-          // Only replace the inner body if we actually hoisted any statements
-          // to the outer body.
-          bodyBlockPath.node.body = innerBody;
-        }
-        var outerFnExpr = getOuterFnExpr(path);
-        // Note that getOuterFnExpr has the side-effect of ensuring that the
-        // function has a name (so node.id will always be an Identifier), even
-        // if a temporary name has to be synthesized.
-        t.assertIdentifier(node.id);
-        var innerFnId = t.identifier(node.id.name + "$");
-
-        // Turn all declarations into vars, and replace the original
-        // declarations with equivalent assignment expressions.
-        var vars = (0, _hoist.hoist)(path);
-        var context = {
-          usesThis: false,
-          usesArguments: false,
-          getArgsId: function getArgsId() {
-            return t.clone(argsId);
-          }
-        };
-        path.traverse(argumentsThisVisitor, context);
-        if (context.usesArguments) {
-          vars = vars || t.variableDeclaration("var", []);
-          vars.declarations.push(t.variableDeclarator(t.clone(argsId), t.identifier("arguments")));
-        }
-        var emitter = new _emit.Emitter(contextId);
-        emitter.explode(path.get("body"));
-        if (vars && vars.declarations.length > 0) {
-          outerBody.push(vars);
-        }
-        var wrapArgs = [emitter.getContextFunction(innerFnId)];
-        var tryLocsList = emitter.getTryLocsList();
-        if (node.generator) {
-          wrapArgs.push(outerFnExpr);
-        } else if (context.usesThis || tryLocsList || node.async) {
-          // Async functions that are not generators don't care about the
-          // outer function because they don't need it to be marked and don't
-          // inherit from its .prototype.
-          wrapArgs.push(t.nullLiteral());
-        }
-        if (context.usesThis) {
-          wrapArgs.push(t.thisExpression());
-        } else if (tryLocsList || node.async) {
-          wrapArgs.push(t.nullLiteral());
-        }
-        if (tryLocsList) {
-          wrapArgs.push(tryLocsList);
-        } else if (node.async) {
-          wrapArgs.push(t.nullLiteral());
-        }
-        if (node.async) {
-          // Rename any locally declared "Promise" variable,
-          // to use the global one.
-          var currentScope = path.scope;
-          do {
-            if (currentScope.hasOwnBinding("Promise")) currentScope.rename("Promise");
-          } while (currentScope = currentScope.parent);
-          wrapArgs.push(t.identifier("Promise"));
-        }
-        var wrapCall = t.callExpression(util.runtimeProperty(node.async ? "async" : "wrap"), wrapArgs);
-        outerBody.push(t.returnStatement(wrapCall));
-        node.body = t.blockStatement(outerBody);
-        // We injected a few new variable declarations (for every hoisted var),
-        // so we need to add them to the scope.
-        path.get("body.body").forEach(function (p) {
-          return p.scope.registerDeclaration(p);
-        });
-        var oldDirectives = bodyBlockPath.node.directives;
-        if (oldDirectives) {
-          // Babylon represents directives like "use strict" as elements of
-          // a bodyBlockPath.node.directives array. (#248)
-          node.body.directives = oldDirectives;
-        }
-        var wasGeneratorFunction = node.generator;
-        if (wasGeneratorFunction) {
-          node.generator = false;
-        }
-        if (node.async) {
-          node.async = false;
-        }
-        if (wasGeneratorFunction && t.isExpression(node)) {
-          util.replaceWithOrRemove(path, t.callExpression(util.runtimeProperty("mark"), [node]));
-          path.addComment("leading", "#__PURE__");
-        }
-        var insertedLocs = emitter.getInsertedLocs();
-        path.traverse({
-          NumericLiteral: function NumericLiteral(path) {
-            if (!insertedLocs.has(path.node)) {
-              return;
-            }
-            path.replaceWith(t.numericLiteral(path.node.value));
-          }
-        });
-
-        // Generators are processed in 'exit' handlers so that regenerator only has to run on
-        // an ES5 AST, but that means traversal will not pick up newly inserted references
-        // to things like 'regeneratorRuntime'. To avoid this, we explicitly requeue.
-        path.requeue();
-      })
-    }
-  };
-};
-
-// Check if a node should be transformed by regenerator
-function shouldRegenerate(node, state) {
-  if (node.generator) {
-    if (node.async) {
-      // Async generator
-      return state.opts.asyncGenerators !== false;
-    } else {
-      // Plain generator
-      return state.opts.generators !== false;
-    }
-  } else if (node.async) {
-    // Async function
-    return state.opts.async !== false;
-  } else {
-    // Not a generator or async function.
-    return false;
-  }
-}
-
-// Given a NodePath for a Function, return an Expression node that can be
-// used to refer reliably to the function object from inside the function.
-// This expression is essentially a replacement for arguments.callee, with
-// the key advantage that it works in strict mode.
-function getOuterFnExpr(funPath) {
-  var t = util.getTypes();
-  var node = funPath.node;
-  t.assertFunction(node);
-  if (!node.id) {
-    // Default-exported function declarations, and function expressions may not
-    // have a name to reference, so we explicitly add one.
-    node.id = funPath.scope.parent.generateUidIdentifier("callee");
-  }
-  if (node.generator &&
-  // Non-generator functions don't need to be marked.
-  t.isFunctionDeclaration(node)) {
-    // Return the identifier returned by runtime.mark(<node.id>).
-    return getMarkedFunctionId(funPath);
-  }
-  return t.clone(node.id);
-}
-var markInfo = new WeakMap();
-function getMarkInfo(node) {
-  if (!markInfo.has(node)) {
-    markInfo.set(node, {});
-  }
-  return markInfo.get(node);
-}
-function getMarkedFunctionId(funPath) {
-  var t = util.getTypes();
-  var node = funPath.node;
-  t.assertIdentifier(node.id);
-  var blockPath = funPath.findParent(function (path) {
-    return path.isProgram() || path.isBlockStatement();
-  });
-  if (!blockPath) {
-    return node.id;
-  }
-  var block = blockPath.node;
-  _assert["default"].ok(Array.isArray(block.body));
-  var info = getMarkInfo(block);
-  if (!info.decl) {
-    info.decl = t.variableDeclaration("var", []);
-    blockPath.unshiftContainer("body", info.decl);
-    info.declPath = blockPath.get("body.0");
-  }
-  _assert["default"].strictEqual(info.declPath.node, info.decl);
-
-  // Get a new unique identifier for our marked variable.
-  var markedId = blockPath.scope.generateUidIdentifier("marked");
-  var markCallExp = t.callExpression(util.runtimeProperty("mark"), [t.clone(node.id)]);
-  var index = info.decl.declarations.push(t.variableDeclarator(markedId, markCallExp)) - 1;
-  var markCallExpPath = info.declPath.get("declarations." + index + ".init");
-  _assert["default"].strictEqual(markCallExpPath.node, markCallExp);
-  markCallExpPath.addComment("leading", "#__PURE__");
-  return t.clone(markedId);
-}
-var argumentsThisVisitor = {
-  "FunctionExpression|FunctionDeclaration|Method": function FunctionExpressionFunctionDeclarationMethod(path) {
-    path.skip();
-  },
-  Identifier: function Identifier(path, state) {
-    if (path.node.name === "arguments" && util.isReference(path)) {
-      util.replaceWithOrRemove(path, state.getArgsId());
-      state.usesArguments = true;
-    }
-  },
-  ThisExpression: function ThisExpression(path, state) {
-    state.usesThis = true;
-  }
-};
-var functionSentVisitor = {
-  MetaProperty: function MetaProperty(path) {
-    var node = path.node;
-    if (node.meta.name === "function" && node.property.name === "sent") {
-      var t = util.getTypes();
-      util.replaceWithOrRemove(path, t.memberExpression(t.clone(this.context), t.identifier("_sent")));
-    }
-  }
-};
-var awaitVisitor = {
-  Function: function Function(path) {
-    path.skip(); // Don't descend into nested function scopes.
-  },
-
-  AwaitExpression: function AwaitExpression(path) {
-    var t = util.getTypes();
-
-    // Convert await expressions to yield expressions.
-    var argument = path.node.argument;
-
-    // Transforming `await x` to `yield regeneratorRuntime.awrap(x)`
-    // causes the argument to be wrapped in such a way that the runtime
-    // can distinguish between awaited and merely yielded values.
-    util.replaceWithOrRemove(path, t.yieldExpression(t.callExpression(util.runtimeProperty("awrap"), [argument]), false));
-  }
-};
\ No newline at end of file
diff --git a/node_modules/regenerator-transform/package.json b/node_modules/regenerator-transform/package.json
deleted file mode 100644
index 53590d50..00000000
--- a/node_modules/regenerator-transform/package.json
+++ /dev/null
@@ -1,43 +0,0 @@
-{
-  "name": "regenerator-transform",
-  "author": "Ben Newman <bn@cs.stanford.edu>",
-  "description": "Explode async and generator functions into a state machine.",
-  "version": "0.15.2",
-  "main": "lib/index.js",
-  "keywords": [
-    "regenerator",
-    "runtime",
-    "generator",
-    "async"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/facebook/regenerator/tree/main/packages/transform"
-  },
-  "license": "MIT",
-  "scripts": {
-    "prepublish": "npx babel src/ --out-dir lib/"
-  },
-  "babel": {
-    "plugins": [
-      "@babel/plugin-transform-runtime"
-    ],
-    "presets": [
-      [
-        "@babel/preset-env",
-        {
-          "loose": true
-        }
-      ]
-    ]
-  },
-  "dependencies": {
-    "@babel/runtime": "^7.8.4"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.8.4",
-    "@babel/core": "^7.8.4",
-    "@babel/plugin-transform-runtime": "^7.8.3",
-    "@babel/preset-env": "^7.8.4"
-  }
-}
diff --git a/node_modules/regenerator-transform/src/emit.js b/node_modules/regenerator-transform/src/emit.js
deleted file mode 100644
index 7b551cdd..00000000
--- a/node_modules/regenerator-transform/src/emit.js
+++ /dev/null
@@ -1,1308 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import assert from "assert";
-import * as leap from "./leap";
-import * as meta from "./meta";
-import * as util from "./util";
-
-let hasOwn = Object.prototype.hasOwnProperty;
-
-function Emitter(contextId) {
-  assert.ok(this instanceof Emitter);
-
-  util.getTypes().assertIdentifier(contextId);
-
-  // Used to generate unique temporary names.
-  this.nextTempId = 0;
-
-  // In order to make sure the context object does not collide with
-  // anything in the local scope, we might have to rename it, so we
-  // refer to it symbolically instead of just assuming that it will be
-  // called "context".
-  this.contextId = contextId;
-
-  // An append-only list of Statements that grows each time this.emit is
-  // called.
-  this.listing = [];
-
-  // A sparse array whose keys correspond to locations in this.listing
-  // that have been marked as branch/jump targets.
-  this.marked = [true];
-
-  this.insertedLocs = new Set();
-
-  // The last location will be marked when this.getDispatchLoop is
-  // called.
-  this.finalLoc = this.loc();
-
-  // A list of all leap.TryEntry statements emitted.
-  this.tryEntries = [];
-
-  // Each time we evaluate the body of a loop, we tell this.leapManager
-  // to enter a nested loop context that determines the meaning of break
-  // and continue statements therein.
-  this.leapManager = new leap.LeapManager(this);
-}
-
-let Ep = Emitter.prototype;
-exports.Emitter = Emitter;
-
-// Offsets into this.listing that could be used as targets for branches or
-// jumps are represented as numeric Literal nodes. This representation has
-// the amazingly convenient benefit of allowing the exact value of the
-// location to be determined at any time, even after generating code that
-// refers to the location.
-// We use 'Number.MAX_VALUE' to mark uninitialized location. We can safely do
-// so because no code can realistically have about 1.8e+308 locations before
-// hitting memory limit of the machine it's running on. For comparison, the
-// estimated number of atoms in the observable universe is around 1e+80.
-const PENDING_LOCATION = Number.MAX_VALUE;
-Ep.loc = function() {
-  const l = util.getTypes().numericLiteral(PENDING_LOCATION)
-  this.insertedLocs.add(l);
-  return l;
-}
-
-Ep.getInsertedLocs = function() {
-  return this.insertedLocs;
-}
-
-Ep.getContextId = function() {
-  return util.getTypes().clone(this.contextId);
-}
-
-// Sets the exact value of the given location to the offset of the next
-// Statement emitted.
-Ep.mark = function(loc) {
-  util.getTypes().assertLiteral(loc);
-  let index = this.listing.length;
-  if (loc.value === PENDING_LOCATION) {
-    loc.value = index;
-  } else {
-    // Locations can be marked redundantly, but their values cannot change
-    // once set the first time.
-    assert.strictEqual(loc.value, index);
-  }
-  this.marked[index] = true;
-  return loc;
-};
-
-Ep.emit = function(node) {
-  const t = util.getTypes();
-
-  if (t.isExpression(node)) {
-    node = t.expressionStatement(node);
-  }
-
-  t.assertStatement(node);
-  this.listing.push(node);
-};
-
-// Shorthand for emitting assignment statements. This will come in handy
-// for assignments to temporary variables.
-Ep.emitAssign = function(lhs, rhs) {
-  this.emit(this.assign(lhs, rhs));
-  return lhs;
-};
-
-// Shorthand for an assignment statement.
-Ep.assign = function(lhs, rhs) {
-  const t = util.getTypes();
-  return t.expressionStatement(
-    t.assignmentExpression("=", t.cloneDeep(lhs), rhs));
-};
-
-// Convenience function for generating expressions like context.next,
-// context.sent, and context.rval.
-Ep.contextProperty = function(name, computed) {
-  const t = util.getTypes();
-  return t.memberExpression(
-    this.getContextId(),
-    computed ? t.stringLiteral(name) : t.identifier(name),
-    !!computed
-  );
-};
-
-// Shorthand for setting context.rval and jumping to `context.stop()`.
-Ep.stop = function(rval) {
-  if (rval) {
-    this.setReturnValue(rval);
-  }
-
-  this.jump(this.finalLoc);
-};
-
-Ep.setReturnValue = function(valuePath) {
-  util.getTypes().assertExpression(valuePath.value);
-
-  this.emitAssign(
-    this.contextProperty("rval"),
-    this.explodeExpression(valuePath)
-  );
-};
-
-Ep.clearPendingException = function(tryLoc, assignee) {
-  const t = util.getTypes();
-
-  t.assertLiteral(tryLoc);
-
-  let catchCall = t.callExpression(
-    this.contextProperty("catch", true),
-    [t.clone(tryLoc)]
-  );
-
-  if (assignee) {
-    this.emitAssign(assignee, catchCall);
-  } else {
-    this.emit(catchCall);
-  }
-};
-
-// Emits code for an unconditional jump to the given location, even if the
-// exact value of the location is not yet known.
-Ep.jump = function(toLoc) {
-  this.emitAssign(this.contextProperty("next"), toLoc);
-  this.emit(util.getTypes().breakStatement());
-};
-
-// Conditional jump.
-Ep.jumpIf = function(test, toLoc) {
-  const t = util.getTypes();
-
-  t.assertExpression(test);
-  t.assertLiteral(toLoc);
-
-  this.emit(t.ifStatement(
-    test,
-    t.blockStatement([
-      this.assign(this.contextProperty("next"), toLoc),
-      t.breakStatement()
-    ])
-  ));
-};
-
-// Conditional jump, with the condition negated.
-Ep.jumpIfNot = function(test, toLoc) {
-  const t = util.getTypes();
-
-  t.assertExpression(test);
-  t.assertLiteral(toLoc);
-
-  let negatedTest;
-  if (t.isUnaryExpression(test) &&
-      test.operator === "!") {
-    // Avoid double negation.
-    negatedTest = test.argument;
-  } else {
-    negatedTest = t.unaryExpression("!", test);
-  }
-
-  this.emit(t.ifStatement(
-    negatedTest,
-    t.blockStatement([
-      this.assign(this.contextProperty("next"), toLoc),
-      t.breakStatement()
-    ])
-  ));
-};
-
-// Returns a unique MemberExpression that can be used to store and
-// retrieve temporary values. Since the object of the member expression is
-// the context object, which is presumed to coexist peacefully with all
-// other local variables, and since we just increment `nextTempId`
-// monotonically, uniqueness is assured.
-Ep.makeTempVar = function() {
-  return this.contextProperty("t" + this.nextTempId++);
-};
-
-Ep.getContextFunction = function(id) {
-  const t = util.getTypes();
-
-  return t.functionExpression(
-    id || null/*Anonymous*/,
-    [this.getContextId()],
-    t.blockStatement([this.getDispatchLoop()]),
-    false, // Not a generator anymore!
-    false // Nor an expression.
-  );
-};
-
-// Turns this.listing into a loop of the form
-//
-//   while (1) switch (context.next) {
-//   case 0:
-//   ...
-//   case n:
-//     return context.stop();
-//   }
-//
-// Each marked location in this.listing will correspond to one generated
-// case statement.
-Ep.getDispatchLoop = function() {
-  const self = this;
-  const t = util.getTypes();
-  let cases = [];
-  let current;
-
-  // If we encounter a break, continue, or return statement in a switch
-  // case, we can skip the rest of the statements until the next case.
-  let alreadyEnded = false;
-
-  self.listing.forEach(function(stmt, i) {
-    if (self.marked.hasOwnProperty(i)) {
-      cases.push(t.switchCase(
-        t.numericLiteral(i),
-        current = []));
-      alreadyEnded = false;
-    }
-
-    if (!alreadyEnded) {
-      current.push(stmt);
-      if (t.isCompletionStatement(stmt))
-        alreadyEnded = true;
-    }
-  });
-
-  // Now that we know how many statements there will be in this.listing,
-  // we can finally resolve this.finalLoc.value.
-  this.finalLoc.value = this.listing.length;
-
-  cases.push(
-    t.switchCase(this.finalLoc, [
-      // Intentionally fall through to the "end" case...
-    ]),
-
-    // So that the runtime can jump to the final location without having
-    // to know its offset, we provide the "end" case as a synonym.
-    t.switchCase(t.stringLiteral("end"), [
-      // This will check/clear both context.thrown and context.rval.
-      t.returnStatement(
-        t.callExpression(this.contextProperty("stop"), [])
-      )
-    ])
-  );
-
-  return t.whileStatement(
-    t.numericLiteral(1),
-    t.switchStatement(
-      t.assignmentExpression(
-        "=",
-        this.contextProperty("prev"),
-        this.contextProperty("next")
-      ),
-      cases
-    )
-  );
-};
-
-Ep.getTryLocsList = function() {
-  if (this.tryEntries.length === 0) {
-    // To avoid adding a needless [] to the majority of runtime.wrap
-    // argument lists, force the caller to handle this case specially.
-    return null;
-  }
-
-  const t = util.getTypes();
-  let lastLocValue = 0;
-
-  return t.arrayExpression(
-    this.tryEntries.map(function(tryEntry) {
-      let thisLocValue = tryEntry.firstLoc.value;
-      assert.ok(thisLocValue >= lastLocValue, "try entries out of order");
-      lastLocValue = thisLocValue;
-
-      let ce = tryEntry.catchEntry;
-      let fe = tryEntry.finallyEntry;
-
-      let locs = [
-        tryEntry.firstLoc,
-        // The null here makes a hole in the array.
-        ce ? ce.firstLoc : null
-      ];
-
-      if (fe) {
-        locs[2] = fe.firstLoc;
-        locs[3] = fe.afterLoc;
-      }
-
-      return t.arrayExpression(locs.map(loc => loc && t.clone(loc)));
-    })
-  );
-};
-
-// All side effects must be realized in order.
-
-// If any subexpression harbors a leap, all subexpressions must be
-// neutered of side effects.
-
-// No destructive modification of AST nodes.
-
-Ep.explode = function(path, ignoreResult) {
-  const t = util.getTypes();
-  let node = path.node;
-  let self = this;
-
-  t.assertNode(node);
-
-  if (t.isDeclaration(node))
-    throw getDeclError(node);
-
-  if (t.isStatement(node))
-    return self.explodeStatement(path);
-
-  if (t.isExpression(node))
-    return self.explodeExpression(path, ignoreResult);
-
-  switch (node.type) {
-  case "Program":
-    return path.get("body").map(
-      self.explodeStatement,
-      self
-    );
-
-  case "VariableDeclarator":
-    throw getDeclError(node);
-
-  // These node types should be handled by their parent nodes
-  // (ObjectExpression, SwitchStatement, and TryStatement, respectively).
-  case "Property":
-  case "SwitchCase":
-  case "CatchClause":
-    throw new Error(
-      node.type + " nodes should be handled by their parents");
-
-  default:
-    throw new Error(
-      "unknown Node of type " +
-        JSON.stringify(node.type));
-  }
-};
-
-function getDeclError(node) {
-  return new Error(
-    "all declarations should have been transformed into " +
-    "assignments before the Exploder began its work: " +
-    JSON.stringify(node));
-}
-
-Ep.explodeStatement = function(path, labelId) {
-  const t = util.getTypes();
-  let stmt = path.node;
-  let self = this;
-  let before, after, head;
-
-  t.assertStatement(stmt);
-
-  if (labelId) {
-    t.assertIdentifier(labelId);
-  } else {
-    labelId = null;
-  }
-
-  // Explode BlockStatement nodes even if they do not contain a yield,
-  // because we don't want or need the curly braces.
-  if (t.isBlockStatement(stmt)) {
-    path.get("body").forEach(function (path) {
-      self.explodeStatement(path);
-    });
-    return;
-  }
-
-  if (!meta.containsLeap(stmt)) {
-    // Technically we should be able to avoid emitting the statement
-    // altogether if !meta.hasSideEffects(stmt), but that leads to
-    // confusing generated code (for instance, `while (true) {}` just
-    // disappears) and is probably a more appropriate job for a dedicated
-    // dead code elimination pass.
-    self.emit(stmt);
-    return;
-  }
-
-  switch (stmt.type) {
-  case "ExpressionStatement":
-    self.explodeExpression(path.get("expression"), true);
-    break;
-
-  case "LabeledStatement":
-    after = this.loc();
-
-    // Did you know you can break from any labeled block statement or
-    // control structure? Well, you can! Note: when a labeled loop is
-    // encountered, the leap.LabeledEntry created here will immediately
-    // enclose a leap.LoopEntry on the leap manager's stack, and both
-    // entries will have the same label. Though this works just fine, it
-    // may seem a bit redundant. In theory, we could check here to
-    // determine if stmt knows how to handle its own label; for example,
-    // stmt happens to be a WhileStatement and so we know it's going to
-    // establish its own LoopEntry when we explode it (below). Then this
-    // LabeledEntry would be unnecessary. Alternatively, we might be
-    // tempted not to pass stmt.label down into self.explodeStatement,
-    // because we've handled the label here, but that's a mistake because
-    // labeled loops may contain labeled continue statements, which is not
-    // something we can handle in this generic case. All in all, I think a
-    // little redundancy greatly simplifies the logic of this case, since
-    // it's clear that we handle all possible LabeledStatements correctly
-    // here, regardless of whether they interact with the leap manager
-    // themselves. Also remember that labels and break/continue-to-label
-    // statements are rare, and all of this logic happens at transform
-    // time, so it has no additional runtime cost.
-    self.leapManager.withEntry(
-      new leap.LabeledEntry(after, stmt.label),
-      function() {
-        self.explodeStatement(path.get("body"), stmt.label);
-      }
-    );
-
-    self.mark(after);
-
-    break;
-
-  case "WhileStatement":
-    before = this.loc();
-    after = this.loc();
-
-    self.mark(before);
-    self.jumpIfNot(self.explodeExpression(path.get("test")), after);
-    self.leapManager.withEntry(
-      new leap.LoopEntry(after, before, labelId),
-      function() { self.explodeStatement(path.get("body")); }
-    );
-    self.jump(before);
-    self.mark(after);
-
-    break;
-
-  case "DoWhileStatement":
-    let first = this.loc();
-    let test = this.loc();
-    after = this.loc();
-
-    self.mark(first);
-    self.leapManager.withEntry(
-      new leap.LoopEntry(after, test, labelId),
-      function() { self.explode(path.get("body")); }
-    );
-    self.mark(test);
-    self.jumpIf(self.explodeExpression(path.get("test")), first);
-    self.mark(after);
-
-    break;
-
-  case "ForStatement":
-    head = this.loc();
-    let update = this.loc();
-    after = this.loc();
-
-    if (stmt.init) {
-      // We pass true here to indicate that if stmt.init is an expression
-      // then we do not care about its result.
-      self.explode(path.get("init"), true);
-    }
-
-    self.mark(head);
-
-    if (stmt.test) {
-      self.jumpIfNot(self.explodeExpression(path.get("test")), after);
-    } else {
-      // No test means continue unconditionally.
-    }
-
-    self.leapManager.withEntry(
-      new leap.LoopEntry(after, update, labelId),
-      function() { self.explodeStatement(path.get("body")); }
-    );
-
-    self.mark(update);
-
-    if (stmt.update) {
-      // We pass true here to indicate that if stmt.update is an
-      // expression then we do not care about its result.
-      self.explode(path.get("update"), true);
-    }
-
-    self.jump(head);
-
-    self.mark(after);
-
-    break;
-
-  case "TypeCastExpression":
-    return self.explodeExpression(path.get("expression"));
-
-  case "ForInStatement":
-    head = this.loc();
-    after = this.loc();
-
-    let keyIterNextFn = self.makeTempVar();
-    self.emitAssign(
-      keyIterNextFn,
-      t.callExpression(
-        util.runtimeProperty("keys"),
-        [self.explodeExpression(path.get("right"))]
-      )
-    );
-
-    self.mark(head);
-
-    let keyInfoTmpVar = self.makeTempVar();
-    self.jumpIf(
-      t.memberExpression(
-        t.assignmentExpression(
-          "=",
-          keyInfoTmpVar,
-          t.callExpression(t.cloneDeep(keyIterNextFn), [])
-        ),
-        t.identifier("done"),
-        false
-      ),
-      after
-    );
-
-    self.emitAssign(
-      stmt.left,
-      t.memberExpression(
-        t.cloneDeep(keyInfoTmpVar),
-        t.identifier("value"),
-        false
-      )
-    );
-
-    self.leapManager.withEntry(
-      new leap.LoopEntry(after, head, labelId),
-      function() { self.explodeStatement(path.get("body")); }
-    );
-
-    self.jump(head);
-
-    self.mark(after);
-
-    break;
-
-  case "BreakStatement":
-    self.emitAbruptCompletion({
-      type: "break",
-      target: self.leapManager.getBreakLoc(stmt.label)
-    });
-
-    break;
-
-  case "ContinueStatement":
-    self.emitAbruptCompletion({
-      type: "continue",
-      target: self.leapManager.getContinueLoc(stmt.label)
-    });
-
-    break;
-
-  case "SwitchStatement":
-    // Always save the discriminant into a temporary variable in case the
-    // test expressions overwrite values like context.sent.
-    let disc = self.emitAssign(
-      self.makeTempVar(),
-      self.explodeExpression(path.get("discriminant"))
-    );
-
-    after = this.loc();
-    let defaultLoc = this.loc();
-    let condition = defaultLoc;
-    let caseLocs = [];
-
-    // If there are no cases, .cases might be undefined.
-    let cases = stmt.cases || [];
-
-    for (let i = cases.length - 1; i >= 0; --i) {
-      let c = cases[i];
-      t.assertSwitchCase(c);
-
-      if (c.test) {
-        condition = t.conditionalExpression(
-          t.binaryExpression("===", t.cloneDeep(disc), c.test),
-          caseLocs[i] = this.loc(),
-          condition
-        );
-      } else {
-        caseLocs[i] = defaultLoc;
-      }
-    }
-
-    let discriminant = path.get("discriminant");
-    util.replaceWithOrRemove(discriminant, condition);
-    self.jump(self.explodeExpression(discriminant));
-
-    self.leapManager.withEntry(
-      new leap.SwitchEntry(after),
-      function() {
-        path.get("cases").forEach(function(casePath) {
-          let i = casePath.key;
-          self.mark(caseLocs[i]);
-
-          casePath.get("consequent").forEach(function (path) {
-            self.explodeStatement(path);
-          });
-        });
-      }
-    );
-
-    self.mark(after);
-    if (defaultLoc.value === PENDING_LOCATION) {
-      self.mark(defaultLoc);
-      assert.strictEqual(after.value, defaultLoc.value);
-    }
-
-    break;
-
-  case "IfStatement":
-    let elseLoc = stmt.alternate && this.loc();
-    after = this.loc();
-
-    self.jumpIfNot(
-      self.explodeExpression(path.get("test")),
-      elseLoc || after
-    );
-
-    self.explodeStatement(path.get("consequent"));
-
-    if (elseLoc) {
-      self.jump(after);
-      self.mark(elseLoc);
-      self.explodeStatement(path.get("alternate"));
-    }
-
-    self.mark(after);
-
-    break;
-
-  case "ReturnStatement":
-    self.emitAbruptCompletion({
-      type: "return",
-      value: self.explodeExpression(path.get("argument"))
-    });
-
-    break;
-
-  case "WithStatement":
-    throw new Error("WithStatement not supported in generator functions.");
-
-  case "TryStatement":
-    after = this.loc();
-
-    let handler = stmt.handler;
-
-    let catchLoc = handler && this.loc();
-    let catchEntry = catchLoc && new leap.CatchEntry(
-      catchLoc,
-      handler.param
-    );
-
-    let finallyLoc = stmt.finalizer && this.loc();
-    let finallyEntry = finallyLoc &&
-      new leap.FinallyEntry(finallyLoc, after);
-
-    let tryEntry = new leap.TryEntry(
-      self.getUnmarkedCurrentLoc(),
-      catchEntry,
-      finallyEntry
-    );
-
-    self.tryEntries.push(tryEntry);
-    self.updateContextPrevLoc(tryEntry.firstLoc);
-
-    self.leapManager.withEntry(tryEntry, function() {
-      self.explodeStatement(path.get("block"));
-
-      if (catchLoc) {
-        if (finallyLoc) {
-          // If we have both a catch block and a finally block, then
-          // because we emit the catch block first, we need to jump over
-          // it to the finally block.
-          self.jump(finallyLoc);
-
-        } else {
-          // If there is no finally block, then we need to jump over the
-          // catch block to the fall-through location.
-          self.jump(after);
-        }
-
-        self.updateContextPrevLoc(self.mark(catchLoc));
-
-        let bodyPath = path.get("handler.body");
-        let safeParam = self.makeTempVar();
-        self.clearPendingException(tryEntry.firstLoc, safeParam);
-
-        bodyPath.traverse(catchParamVisitor, {
-          getSafeParam: () => t.cloneDeep(safeParam),
-          catchParamName: handler.param.name
-        });
-
-        self.leapManager.withEntry(catchEntry, function() {
-          self.explodeStatement(bodyPath);
-        });
-      }
-
-      if (finallyLoc) {
-        self.updateContextPrevLoc(self.mark(finallyLoc));
-
-        self.leapManager.withEntry(finallyEntry, function() {
-          self.explodeStatement(path.get("finalizer"));
-        });
-
-        self.emit(t.returnStatement(t.callExpression(
-          self.contextProperty("finish"),
-          [finallyEntry.firstLoc]
-        )));
-      }
-    });
-
-    self.mark(after);
-
-    break;
-
-  case "ThrowStatement":
-    self.emit(t.throwStatement(
-      self.explodeExpression(path.get("argument"))
-    ));
-
-    break;
-
-  case "ClassDeclaration":
-    self.emit(self.explodeClass(path));
-    break;
-
-  default:
-    throw new Error(
-      "unknown Statement of type " +
-        JSON.stringify(stmt.type));
-  }
-};
-
-let catchParamVisitor = {
-  Identifier: function(path, state) {
-    if (path.node.name === state.catchParamName && util.isReference(path)) {
-      util.replaceWithOrRemove(path, state.getSafeParam());
-    }
-  },
-
-  Scope: function(path, state) {
-    if (path.scope.hasOwnBinding(state.catchParamName)) {
-      // Don't descend into nested scopes that shadow the catch
-      // parameter with their own declarations.
-      path.skip();
-    }
-  }
-};
-
-Ep.emitAbruptCompletion = function(record) {
-  if (!isValidCompletion(record)) {
-    assert.ok(
-      false,
-      "invalid completion record: " +
-        JSON.stringify(record)
-    );
-  }
-
-  assert.notStrictEqual(
-    record.type, "normal",
-    "normal completions are not abrupt"
-  );
-
-  const t = util.getTypes();
-  let abruptArgs = [t.stringLiteral(record.type)];
-
-  if (record.type === "break" ||
-      record.type === "continue") {
-    t.assertLiteral(record.target);
-    abruptArgs[1] = this.insertedLocs.has(record.target)
-      ? record.target
-      : t.cloneDeep(record.target);
-  } else if (record.type === "return" ||
-             record.type === "throw") {
-    if (record.value) {
-      t.assertExpression(record.value);
-      abruptArgs[1] = this.insertedLocs.has(record.value)
-        ? record.value
-        : t.cloneDeep(record.value);
-    }
-  }
-
-  this.emit(
-    t.returnStatement(
-      t.callExpression(
-        this.contextProperty("abrupt"),
-        abruptArgs
-      )
-    )
-  );
-};
-
-function isValidCompletion(record) {
-  let type = record.type;
-
-  if (type === "normal") {
-    return !hasOwn.call(record, "target");
-  }
-
-  if (type === "break" ||
-      type === "continue") {
-    return !hasOwn.call(record, "value")
-        && util.getTypes().isLiteral(record.target);
-  }
-
-  if (type === "return" ||
-      type === "throw") {
-    return hasOwn.call(record, "value")
-        && !hasOwn.call(record, "target");
-  }
-
-  return false;
-}
-
-
-// Not all offsets into emitter.listing are potential jump targets. For
-// example, execution typically falls into the beginning of a try block
-// without jumping directly there. This method returns the current offset
-// without marking it, so that a switch case will not necessarily be
-// generated for this offset (I say "not necessarily" because the same
-// location might end up being marked in the process of emitting other
-// statements). There's no logical harm in marking such locations as jump
-// targets, but minimizing the number of switch cases keeps the generated
-// code shorter.
-Ep.getUnmarkedCurrentLoc = function() {
-  return util.getTypes().numericLiteral(this.listing.length);
-};
-
-// The context.prev property takes the value of context.next whenever we
-// evaluate the switch statement discriminant, which is generally good
-// enough for tracking the last location we jumped to, but sometimes
-// context.prev needs to be more precise, such as when we fall
-// successfully out of a try block and into a finally block without
-// jumping. This method exists to update context.prev to the freshest
-// available location. If we were implementing a full interpreter, we
-// would know the location of the current instruction with complete
-// precision at all times, but we don't have that luxury here, as it would
-// be costly and verbose to set context.prev before every statement.
-Ep.updateContextPrevLoc = function(loc) {
-  const t = util.getTypes();
-  if (loc) {
-    t.assertLiteral(loc);
-
-    if (loc.value === PENDING_LOCATION) {
-      // If an uninitialized location literal was passed in, set its value
-      // to the current this.listing.length.
-      loc.value = this.listing.length;
-    } else {
-      // Otherwise assert that the location matches the current offset.
-      assert.strictEqual(loc.value, this.listing.length);
-    }
-
-  } else {
-    loc = this.getUnmarkedCurrentLoc();
-  }
-
-  // Make sure context.prev is up to date in case we fell into this try
-  // statement without jumping to it. TODO Consider avoiding this
-  // assignment when we know control must have jumped here.
-  this.emitAssign(this.contextProperty("prev"), loc);
-};
-
-
-// In order to save the rest of explodeExpression from a combinatorial
-// trainwreck of special cases, explodeViaTempVar is responsible for
-// deciding when a subexpression needs to be "exploded," which is my
-// very technical term for emitting the subexpression as an assignment
-// to a temporary variable and the substituting the temporary variable
-// for the original subexpression. Think of exploded view diagrams, not
-// Michael Bay movies. The point of exploding subexpressions is to
-// control the precise order in which the generated code realizes the
-// side effects of those subexpressions.
-Ep.explodeViaTempVar = function(tempVar, childPath, hasLeapingChildren, ignoreChildResult) {
-  assert.ok(
-    !ignoreChildResult || !tempVar,
-    "Ignoring the result of a child expression but forcing it to " +
-      "be assigned to a temporary variable?"
-  );
-  const t = util.getTypes();
-
-  let result = this.explodeExpression(childPath, ignoreChildResult);
-
-  if (ignoreChildResult) {
-    // Side effects already emitted above.
-
-  } else if (tempVar || (hasLeapingChildren &&
-                          !t.isLiteral(result))) {
-    // If tempVar was provided, then the result will always be assigned
-    // to it, even if the result does not otherwise need to be assigned
-    // to a temporary variable.  When no tempVar is provided, we have
-    // the flexibility to decide whether a temporary variable is really
-    // necessary.  Unfortunately, in general, a temporary variable is
-    // required whenever any child contains a yield expression, since it
-    // is difficult to prove (at all, let alone efficiently) whether
-    // this result would evaluate to the same value before and after the
-    // yield (see #206).  One narrow case where we can prove it doesn't
-    // matter (and thus we do not need a temporary variable) is when the
-    // result in question is a Literal value.
-    result = this.emitAssign(
-      tempVar || this.makeTempVar(),
-      result
-    );
-  }
-  return result;
-};
-
-Ep.explodeExpression = function(path, ignoreResult) {
-  const t = util.getTypes();
-  let expr = path.node;
-  if (expr) {
-    t.assertExpression(expr);
-  } else {
-    return expr;
-  }
-
-  let self = this;
-  let result; // Used optionally by several cases below.
-  let after;
-
-  function finish(expr) {
-    t.assertExpression(expr);
-    if (ignoreResult) {
-      self.emit(expr);
-    }
-    return expr;
-  }
-
-  // If the expression does not contain a leap, then we either emit the
-  // expression as a standalone statement or return it whole.
-  if (!meta.containsLeap(expr)) {
-    return finish(expr);
-  }
-
-  // If any child contains a leap (such as a yield or labeled continue or
-  // break statement), then any sibling subexpressions will almost
-  // certainly have to be exploded in order to maintain the order of their
-  // side effects relative to the leaping child(ren).
-  let hasLeapingChildren = meta.containsLeap.onlyChildren(expr);
-
-  // If ignoreResult is true, then we must take full responsibility for
-  // emitting the expression with all its side effects, and we should not
-  // return a result.
-
-  switch (expr.type) {
-  case "MemberExpression":
-    return finish(t.memberExpression(
-      self.explodeExpression(path.get("object")),
-      expr.computed
-        ? self.explodeViaTempVar(null, path.get("property"), hasLeapingChildren)
-        : expr.property,
-      expr.computed
-    ));
-
-  case "CallExpression":
-    let calleePath = path.get("callee");
-    let argsPath = path.get("arguments");
-
-    let newCallee;
-    let newArgs;
-
-    let hasLeapingArgs = argsPath.some(
-      argPath => meta.containsLeap(argPath.node)
-    );
-
-    let injectFirstArg = null;
-
-    if (t.isMemberExpression(calleePath.node)) {
-      if (hasLeapingArgs) {
-        // If the arguments of the CallExpression contained any yield
-        // expressions, then we need to be sure to evaluate the callee
-        // before evaluating the arguments, but if the callee was a member
-        // expression, then we must be careful that the object of the
-        // member expression still gets bound to `this` for the call.
-
-        let newObject = self.explodeViaTempVar(
-          // Assign the exploded callee.object expression to a temporary
-          // variable so that we can use it twice without reevaluating it.
-          self.makeTempVar(),
-          calleePath.get("object"),
-          hasLeapingChildren
-        );
-
-        let newProperty = calleePath.node.computed
-          ? self.explodeViaTempVar(null, calleePath.get("property"), hasLeapingChildren)
-          : calleePath.node.property;
-
-        injectFirstArg = newObject;
-
-        newCallee = t.memberExpression(
-          t.memberExpression(
-            t.cloneDeep(newObject),
-            newProperty,
-            calleePath.node.computed
-          ),
-          t.identifier("call"),
-          false
-        );
-
-      } else {
-        newCallee = self.explodeExpression(calleePath);
-      }
-
-    } else {
-      newCallee = self.explodeViaTempVar(null, calleePath, hasLeapingChildren);
-
-      if (t.isMemberExpression(newCallee)) {
-        // If the callee was not previously a MemberExpression, then the
-        // CallExpression was "unqualified," meaning its `this` object
-        // should be the global object. If the exploded expression has
-        // become a MemberExpression (e.g. a context property, probably a
-        // temporary variable), then we need to force it to be unqualified
-        // by using the (0, object.property)(...) trick; otherwise, it
-        // will receive the object of the MemberExpression as its `this`
-        // object.
-        newCallee = t.sequenceExpression([
-          t.numericLiteral(0),
-          t.cloneDeep(newCallee)
-        ]);
-      }
-    }
-
-    if (hasLeapingArgs) {
-      newArgs = argsPath.map(argPath => self.explodeViaTempVar(null, argPath, hasLeapingChildren));
-      if (injectFirstArg) newArgs.unshift(injectFirstArg);
-
-      newArgs = newArgs.map(arg => t.cloneDeep(arg));
-    } else {
-      newArgs = path.node.arguments;
-    }
-
-    return finish(t.callExpression(newCallee, newArgs));
-
-  case "NewExpression":
-    return finish(t.newExpression(
-     self.explodeViaTempVar(null, path.get("callee"), hasLeapingChildren),
-       path.get("arguments").map(function(argPath) {
-        return self.explodeViaTempVar(null, argPath, hasLeapingChildren);
-      })
-    ));
-
-  case "ObjectExpression":
-    return finish(t.objectExpression(
-      path.get("properties").map(function(propPath) {
-        if (propPath.isObjectProperty()) {
-          return t.objectProperty(
-            propPath.node.key,
-            self.explodeViaTempVar(null, propPath.get("value"), hasLeapingChildren),
-            propPath.node.computed
-          );
-        } else {
-          return propPath.node;
-        }
-      })
-    ));
-
-  case "ArrayExpression":
-    return finish(t.arrayExpression(
-      path.get("elements").map(function(elemPath) {
-        if (!elemPath.node) {
-          return null;
-        } if (elemPath.isSpreadElement()) {
-          return t.spreadElement(
-            self.explodeViaTempVar(null, elemPath.get("argument"), hasLeapingChildren)
-          );
-        } else {
-          return self.explodeViaTempVar(null, elemPath, hasLeapingChildren);
-        }
-      })
-    ));
-
-  case "SequenceExpression":
-    let lastIndex = expr.expressions.length - 1;
-
-    path.get("expressions").forEach(function(exprPath) {
-      if (exprPath.key === lastIndex) {
-        result = self.explodeExpression(exprPath, ignoreResult);
-      } else {
-        self.explodeExpression(exprPath, true);
-      }
-    });
-
-    return result;
-
-  case "LogicalExpression":
-    after = this.loc();
-
-    if (!ignoreResult) {
-      result = self.makeTempVar();
-    }
-
-    let left = self.explodeViaTempVar(result, path.get("left"), hasLeapingChildren);
-
-    if (expr.operator === "&&") {
-      self.jumpIfNot(left, after);
-    } else {
-      assert.strictEqual(expr.operator, "||");
-      self.jumpIf(left, after);
-    }
-
-    self.explodeViaTempVar(result, path.get("right"), hasLeapingChildren, ignoreResult);
-
-    self.mark(after);
-
-    return result;
-
-  case "ConditionalExpression":
-    let elseLoc = this.loc();
-    after = this.loc();
-    let test = self.explodeExpression(path.get("test"));
-
-    self.jumpIfNot(test, elseLoc);
-
-    if (!ignoreResult) {
-      result = self.makeTempVar();
-    }
-
-    self.explodeViaTempVar(result, path.get("consequent"), hasLeapingChildren, ignoreResult);
-    self.jump(after);
-
-    self.mark(elseLoc);
-    self.explodeViaTempVar(result, path.get("alternate"), hasLeapingChildren, ignoreResult);
-
-    self.mark(after);
-
-    return result;
-
-  case "UnaryExpression":
-    return finish(t.unaryExpression(
-      expr.operator,
-      // Can't (and don't need to) break up the syntax of the argument.
-      // Think about delete a[b].
-      self.explodeExpression(path.get("argument")),
-      !!expr.prefix
-    ));
-
-  case "BinaryExpression":
-    return finish(t.binaryExpression(
-      expr.operator,
-      self.explodeViaTempVar(null, path.get("left"), hasLeapingChildren),
-      self.explodeViaTempVar(null, path.get("right"), hasLeapingChildren)
-    ));
-
-  case "AssignmentExpression":
-    if (expr.operator === "=") {
-      // If this is a simple assignment, the left hand side does not need
-      // to be read before the right hand side is evaluated, so we can
-      // avoid the more complicated logic below.
-      return finish(t.assignmentExpression(
-        expr.operator,
-        self.explodeExpression(path.get("left")),
-        self.explodeExpression(path.get("right"))
-      ));
-    }
-
-    const lhs = self.explodeExpression(path.get("left"));
-    const temp = self.emitAssign(self.makeTempVar(), lhs);
-
-    // For example,
-    //
-    //   x += yield y
-    //
-    // becomes
-    //
-    //   context.t0 = x
-    //   x = context.t0 += yield y
-    //
-    // so that the left-hand side expression is read before the yield.
-    // Fixes https://github.com/facebook/regenerator/issues/345.
-
-    return finish(t.assignmentExpression(
-      "=",
-      t.cloneDeep(lhs),
-      t.assignmentExpression(
-        expr.operator,
-        t.cloneDeep(temp),
-        self.explodeExpression(path.get("right"))
-      )
-    ));
-
-  case "UpdateExpression":
-    return finish(t.updateExpression(
-      expr.operator,
-      self.explodeExpression(path.get("argument")),
-      expr.prefix
-    ));
-
-  case "YieldExpression":
-    after = this.loc();
-    let arg = expr.argument && self.explodeExpression(path.get("argument"));
-
-    if (arg && expr.delegate) {
-      let result = self.makeTempVar();
-
-      let ret = t.returnStatement(t.callExpression(
-        self.contextProperty("delegateYield"),
-        [
-          arg,
-          t.stringLiteral(result.property.name),
-          after
-        ]
-      ));
-      ret.loc = expr.loc;
-
-      self.emit(ret);
-      self.mark(after);
-
-      return result;
-    }
-
-    self.emitAssign(self.contextProperty("next"), after);
-
-    let ret = t.returnStatement(t.cloneDeep(arg) || null);
-    // Preserve the `yield` location so that source mappings for the statements
-    // link back to the yield properly.
-    ret.loc = expr.loc;
-    self.emit(ret);
-    self.mark(after);
-
-    return self.contextProperty("sent");
-
-  case "ClassExpression":
-    return finish(self.explodeClass(path));
-
-  default:
-    throw new Error(
-      "unknown Expression of type " +
-        JSON.stringify(expr.type));
-  }
-};
-
-Ep.explodeClass = function(path) {
-  const explodingChildren = [];
-
-  if (path.node.superClass) {
-    explodingChildren.push(path.get("superClass"));
-  }
-
-  path.get("body.body").forEach(member => {
-    if (member.node.computed) {
-      explodingChildren.push(member.get("key"));
-    }
-  });
-
-  const hasLeapingChildren = explodingChildren.some(
-    child => meta.containsLeap(child));
-
-  for (let i = 0; i < explodingChildren.length; i++) {
-    const child = explodingChildren[i];
-    const isLast = i === explodingChildren.length - 1;
-
-    if (isLast) {
-      child.replaceWith(this.explodeExpression(child));
-    } else {
-      child.replaceWith(this.explodeViaTempVar(null, child, hasLeapingChildren));
-    }
-  }
-
-  return path.node;
-};
diff --git a/node_modules/regenerator-transform/src/hoist.js b/node_modules/regenerator-transform/src/hoist.js
deleted file mode 100644
index 6fbad6de..00000000
--- a/node_modules/regenerator-transform/src/hoist.js
+++ /dev/null
@@ -1,161 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import * as util from "./util";
-let hasOwn = Object.prototype.hasOwnProperty;
-
-// The hoist function takes a FunctionExpression or FunctionDeclaration
-// and replaces any Declaration nodes in its body with assignments, then
-// returns a VariableDeclaration containing just the names of the removed
-// declarations.
-exports.hoist = function(funPath) {
-  const t = util.getTypes();
-  t.assertFunction(funPath.node);
-
-  let vars = {};
-
-  function varDeclToExpr({ node: vdec, scope }, includeIdentifiers) {
-    t.assertVariableDeclaration(vdec);
-    // TODO assert.equal(vdec.kind, "var");
-    let exprs = [];
-
-    vdec.declarations.forEach(function(dec) {
-      // Note: We duplicate 'dec.id' here to ensure that the variable declaration IDs don't
-      // have the same 'loc' value, since that can make sourcemaps and retainLines behave poorly.
-      vars[dec.id.name] = t.identifier(dec.id.name);
-
-      // Remove the binding, to avoid "duplicate declaration" errors when it will
-      // be injected again.
-      scope.removeBinding(dec.id.name);
-
-      if (dec.init) {
-        exprs.push(t.assignmentExpression(
-          "=", dec.id, dec.init
-        ));
-      } else if (includeIdentifiers) {
-        exprs.push(dec.id);
-      }
-    });
-
-    if (exprs.length === 0)
-      return null;
-
-    if (exprs.length === 1)
-      return exprs[0];
-
-    return t.sequenceExpression(exprs);
-  }
-
-  funPath.get("body").traverse({
-    VariableDeclaration: {
-      exit: function(path) {
-        let expr = varDeclToExpr(path, false);
-        if (expr === null) {
-          path.remove();
-        } else {
-          // We don't need to traverse this expression any further because
-          // there can't be any new declarations inside an expression.
-          util.replaceWithOrRemove(path, t.expressionStatement(expr));
-        }
-
-        // Since the original node has been either removed or replaced,
-        // avoid traversing it any further.
-        path.skip();
-      }
-    },
-
-    ForStatement: function(path) {
-      let init = path.get("init");
-      if (init.isVariableDeclaration()) {
-        util.replaceWithOrRemove(init, varDeclToExpr(init, false));
-      }
-    },
-
-    ForXStatement: function(path) {
-      let left = path.get("left");
-      if (left.isVariableDeclaration()) {
-        util.replaceWithOrRemove(left, varDeclToExpr(left, true));
-      }
-    },
-
-    FunctionDeclaration: function(path) {
-      let node = path.node;
-      vars[node.id.name] = node.id;
-
-      let assignment = t.expressionStatement(
-        t.assignmentExpression(
-          "=",
-          t.clone(node.id),
-          t.functionExpression(
-            path.scope.generateUidIdentifierBasedOnNode(node),
-            node.params,
-            node.body,
-            node.generator,
-            node.expression
-          )
-        )
-      );
-
-      if (path.parentPath.isBlockStatement()) {
-        // Insert the assignment form before the first statement in the
-        // enclosing block.
-        path.parentPath.unshiftContainer("body", assignment);
-
-        // Remove the function declaration now that we've inserted the
-        // equivalent assignment form at the beginning of the block.
-        path.remove();
-      } else {
-        // If the parent node is not a block statement, then we can just
-        // replace the declaration with the equivalent assignment form
-        // without worrying about hoisting it.
-        util.replaceWithOrRemove(path, assignment);
-      }
-
-      // Remove the binding, to avoid "duplicate declaration" errors when it will
-      // be injected again.
-      path.scope.removeBinding(node.id.name);
-
-      // Don't hoist variables out of inner functions.
-      path.skip();
-    },
-
-    FunctionExpression: function(path) {
-      // Don't descend into nested function expressions.
-      path.skip();
-    },
-
-    ArrowFunctionExpression: function(path) {
-      // Don't descend into nested function expressions.
-      path.skip();
-    }
-  });
-
-  let paramNames = {};
-  funPath.get("params").forEach(function(paramPath) {
-    let param = paramPath.node;
-    if (t.isIdentifier(param)) {
-      paramNames[param.name] = param;
-    } else {
-      // Variables declared by destructuring parameter patterns will be
-      // harmlessly re-declared.
-    }
-  });
-
-  let declarations = [];
-
-  Object.keys(vars).forEach(function(name) {
-    if (!hasOwn.call(paramNames, name)) {
-      declarations.push(t.variableDeclarator(vars[name], null));
-    }
-  });
-
-  if (declarations.length === 0) {
-    return null; // Be sure to handle this case!
-  }
-
-  return t.variableDeclaration("var", declarations);
-};
diff --git a/node_modules/regenerator-transform/src/index.js b/node_modules/regenerator-transform/src/index.js
deleted file mode 100644
index 2a18dffe..00000000
--- a/node_modules/regenerator-transform/src/index.js
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { getVisitor } from "./visit";
-
-export default function (context) {
-  const plugin = {
-    visitor: getVisitor(context),
-  };
-
-  // Some presets manually call child presets, but fail to pass along the
-  // context object. Out of an abundance of caution, we verify that it
-  // exists first to avoid causing unnecessary breaking changes.
-  const version = context && context.version;
-
-  // The "name" property is not allowed in older versions of Babel (6.x)
-  // and will cause the plugin validator to throw an exception.
-  if (version && parseInt(version, 10) >= 7) {
-    plugin.name = "regenerator-transform";
-  }
-
-  return plugin;
-}
diff --git a/node_modules/regenerator-transform/src/leap.js b/node_modules/regenerator-transform/src/leap.js
deleted file mode 100644
index afbcda04..00000000
--- a/node_modules/regenerator-transform/src/leap.js
+++ /dev/null
@@ -1,179 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import assert from "assert";
-import { Emitter } from "./emit";
-import { inherits } from "util";
-import { getTypes } from "./util";
-
-function Entry() {
-  assert.ok(this instanceof Entry);
-}
-
-function FunctionEntry(returnLoc) {
-  Entry.call(this);
-  getTypes().assertLiteral(returnLoc);
-  this.returnLoc = returnLoc;
-}
-
-inherits(FunctionEntry, Entry);
-exports.FunctionEntry = FunctionEntry;
-
-function LoopEntry(breakLoc, continueLoc, label) {
-  Entry.call(this);
-
-  const t = getTypes();
-
-  t.assertLiteral(breakLoc);
-  t.assertLiteral(continueLoc);
-
-  if (label) {
-    t.assertIdentifier(label);
-  } else {
-    label = null;
-  }
-
-  this.breakLoc = breakLoc;
-  this.continueLoc = continueLoc;
-  this.label = label;
-}
-
-inherits(LoopEntry, Entry);
-exports.LoopEntry = LoopEntry;
-
-function SwitchEntry(breakLoc) {
-  Entry.call(this);
-  getTypes().assertLiteral(breakLoc);
-  this.breakLoc = breakLoc;
-}
-
-inherits(SwitchEntry, Entry);
-exports.SwitchEntry = SwitchEntry;
-
-function TryEntry(firstLoc, catchEntry, finallyEntry) {
-  Entry.call(this);
-
-  const t = getTypes();
-  t.assertLiteral(firstLoc);
-
-  if (catchEntry) {
-    assert.ok(catchEntry instanceof CatchEntry);
-  } else {
-    catchEntry = null;
-  }
-
-  if (finallyEntry) {
-    assert.ok(finallyEntry instanceof FinallyEntry);
-  } else {
-    finallyEntry = null;
-  }
-
-  // Have to have one or the other (or both).
-  assert.ok(catchEntry || finallyEntry);
-
-  this.firstLoc = firstLoc;
-  this.catchEntry = catchEntry;
-  this.finallyEntry = finallyEntry;
-}
-
-inherits(TryEntry, Entry);
-exports.TryEntry = TryEntry;
-
-function CatchEntry(firstLoc, paramId) {
-  Entry.call(this);
-
-  const t = getTypes();
-
-  t.assertLiteral(firstLoc);
-  t.assertIdentifier(paramId);
-
-  this.firstLoc = firstLoc;
-  this.paramId = paramId;
-}
-
-inherits(CatchEntry, Entry);
-exports.CatchEntry = CatchEntry;
-
-function FinallyEntry(firstLoc, afterLoc) {
-  Entry.call(this);
-  const t = getTypes();
-  t.assertLiteral(firstLoc);
-  t.assertLiteral(afterLoc);
-  this.firstLoc = firstLoc;
-  this.afterLoc = afterLoc;
-}
-
-inherits(FinallyEntry, Entry);
-exports.FinallyEntry = FinallyEntry;
-
-function LabeledEntry(breakLoc, label) {
-  Entry.call(this);
-
-  const t = getTypes();
-
-  t.assertLiteral(breakLoc);
-  t.assertIdentifier(label);
-
-  this.breakLoc = breakLoc;
-  this.label = label;
-}
-
-inherits(LabeledEntry, Entry);
-exports.LabeledEntry = LabeledEntry;
-
-function LeapManager(emitter) {
-  assert.ok(this instanceof LeapManager);
-
-  assert.ok(emitter instanceof Emitter);
-
-  this.emitter = emitter;
-  this.entryStack = [new FunctionEntry(emitter.finalLoc)];
-}
-
-let LMp = LeapManager.prototype;
-exports.LeapManager = LeapManager;
-
-LMp.withEntry = function(entry, callback) {
-  assert.ok(entry instanceof Entry);
-  this.entryStack.push(entry);
-  try {
-    callback.call(this.emitter);
-  } finally {
-    let popped = this.entryStack.pop();
-    assert.strictEqual(popped, entry);
-  }
-};
-
-LMp._findLeapLocation = function(property, label) {
-  for (let i = this.entryStack.length - 1; i >= 0; --i) {
-    let entry = this.entryStack[i];
-    let loc = entry[property];
-    if (loc) {
-      if (label) {
-        if (entry.label &&
-            entry.label.name === label.name) {
-          return loc;
-        }
-      } else if (entry instanceof LabeledEntry) {
-        // Ignore LabeledEntry entries unless we are actually breaking to
-        // a label.
-      } else {
-        return loc;
-      }
-    }
-  }
-
-  return null;
-};
-
-LMp.getBreakLoc = function(label) {
-  return this._findLeapLocation("breakLoc", label);
-};
-
-LMp.getContinueLoc = function(label) {
-  return this._findLeapLocation("continueLoc", label);
-};
diff --git a/node_modules/regenerator-transform/src/meta.js b/node_modules/regenerator-transform/src/meta.js
deleted file mode 100644
index dea4c6be..00000000
--- a/node_modules/regenerator-transform/src/meta.js
+++ /dev/null
@@ -1,110 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import assert from "assert";
-import { getTypes } from "./util.js";
-
-const mMap = new WeakMap();
-function m(node) {
-  if (!mMap.has(node)) {
-    mMap.set(node, {});
-  }
-  return mMap.get(node);
-}
-
-const hasOwn = Object.prototype.hasOwnProperty;
-
-function makePredicate(propertyName, knownTypes) {
-  function onlyChildren(node) {
-    const t = getTypes();
-    t.assertNode(node);
-
-    // Assume no side effects until we find out otherwise.
-    let result = false;
-
-    function check(child) {
-      if (result) {
-        // Do nothing.
-      } else if (Array.isArray(child)) {
-        child.some(check);
-      } else if (t.isNode(child)) {
-        assert.strictEqual(result, false);
-        result = predicate(child);
-      }
-      return result;
-    }
-
-    let keys = t.VISITOR_KEYS[node.type];
-    if (keys) {
-      for (let i = 0; i < keys.length; i++) {
-        let key = keys[i];
-        let child = node[key];
-        check(child);
-      }
-    }
-
-    return result;
-  }
-
-  function predicate(node) {
-    getTypes().assertNode(node);
-
-    let meta = m(node);
-    if (hasOwn.call(meta, propertyName))
-      return meta[propertyName];
-
-    // Certain types are "opaque," which means they have no side
-    // effects or leaps and we don't care about their subexpressions.
-    if (hasOwn.call(opaqueTypes, node.type))
-      return meta[propertyName] = false;
-
-    if (hasOwn.call(knownTypes, node.type))
-      return meta[propertyName] = true;
-
-    return meta[propertyName] = onlyChildren(node);
-  }
-
-  predicate.onlyChildren = onlyChildren;
-
-  return predicate;
-}
-
-let opaqueTypes = {
-  FunctionExpression: true,
-  ArrowFunctionExpression: true
-};
-
-// These types potentially have side effects regardless of what side
-// effects their subexpressions have.
-let sideEffectTypes = {
-  CallExpression: true, // Anything could happen!
-  ForInStatement: true, // Modifies the key variable.
-  UnaryExpression: true, // Think delete.
-  BinaryExpression: true, // Might invoke .toString() or .valueOf().
-  AssignmentExpression: true, // Side-effecting by definition.
-  UpdateExpression: true, // Updates are essentially assignments.
-  NewExpression: true // Similar to CallExpression.
-};
-
-// These types are the direct cause of all leaps in control flow.
-let leapTypes = {
-  YieldExpression: true,
-  BreakStatement: true,
-  ContinueStatement: true,
-  ReturnStatement: true,
-  ThrowStatement: true
-};
-
-// All leap types are also side effect types.
-for (let type in leapTypes) {
-  if (hasOwn.call(leapTypes, type)) {
-    sideEffectTypes[type] = leapTypes[type];
-  }
-}
-
-exports.hasSideEffects = makePredicate("hasSideEffects", sideEffectTypes);
-exports.containsLeap = makePredicate("containsLeap", leapTypes);
diff --git a/node_modules/regenerator-transform/src/replaceShorthandObjectMethod.js b/node_modules/regenerator-transform/src/replaceShorthandObjectMethod.js
deleted file mode 100644
index c406c63a..00000000
--- a/node_modules/regenerator-transform/src/replaceShorthandObjectMethod.js
+++ /dev/null
@@ -1,82 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import * as util from "./util";
-
-// this function converts a shorthand object generator method into a normal
-// (non-shorthand) object property which is a generator function expression. for
-// example, this:
-//
-//  var foo = {
-//    *bar(baz) { return 5; }
-//  }
-//
-// should be replaced with:
-//
-//  var foo = {
-//    bar: function*(baz) { return 5; }
-//  }
-//
-// to do this, it clones the parameter array and the body of the object generator
-// method into a new FunctionExpression.
-//
-// this method can be passed any Function AST node path, and it will return
-// either:
-//   a) the path that was passed in (iff the path did not need to be replaced) or
-//   b) the path of the new FunctionExpression that was created as a replacement
-//     (iff the path did need to be replaced)
-//
-// In either case, though, the caller can count on the fact that the return value
-// is a Function AST node path.
-//
-// If this function is called with an AST node path that is not a Function (or with an
-// argument that isn't an AST node path), it will throw an error.
-export default function replaceShorthandObjectMethod(path) {
-  const t = util.getTypes();
-
-  if (!path.node || !t.isFunction(path.node)) {
-    throw new Error("replaceShorthandObjectMethod can only be called on Function AST node paths.");
-  }
-
-  // this function only replaces shorthand object methods (called ObjectMethod
-  // in Babel-speak).
-  if (!t.isObjectMethod(path.node)) {
-    return path;
-  }
-
-  // this function only replaces generators.
-  if (!path.node.generator) {
-    return path;
-  }
-
-  const parameters = path.node.params.map(function (param) {
-    return t.cloneDeep(param);
-  })
-
-  const functionExpression = t.functionExpression(
-    null, // id
-    parameters, // params
-    t.cloneDeep(path.node.body), // body
-    path.node.generator,
-    path.node.async
-  );
-
-  util.replaceWithOrRemove(path,
-    t.objectProperty(
-      t.cloneDeep(path.node.key), // key
-      functionExpression, //value
-      path.node.computed, // computed
-      false // shorthand
-    )
-  );
-
-  // path now refers to the ObjectProperty AST node path, but we want to return a
-  // Function AST node path for the function expression we created. we know that
-  // the FunctionExpression we just created is the value of the ObjectProperty,
-  // so return the "value" path off of this path.
-  return path.get("value");
-}
diff --git a/node_modules/regenerator-transform/src/util.js b/node_modules/regenerator-transform/src/util.js
deleted file mode 100644
index 80eea017..00000000
--- a/node_modules/regenerator-transform/src/util.js
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-let currentTypes = null;
-
-export function wrapWithTypes(types, fn) {
-  return function (...args) {
-    const oldTypes = currentTypes;
-    currentTypes = types;
-    try {
-      return fn.apply(this, args);
-    } finally {
-      currentTypes = oldTypes;
-    }
-  };
-}
-
-export function getTypes() {
-  return currentTypes;
-}
-
-export function runtimeProperty(name) {
-  const t = getTypes();
-  return t.memberExpression(
-    t.identifier("regeneratorRuntime"),
-    t.identifier(name),
-    false
-  );
-}
-
-export function isReference(path) {
-  return path.isReferenced() || path.parentPath.isAssignmentExpression({ left: path.node });
-}
-
-export function replaceWithOrRemove(path, replacement) {
-  if (replacement) {
-    path.replaceWith(replacement)
-  } else {
-    path.remove();
-  }
-}
diff --git a/node_modules/regenerator-transform/src/visit.js b/node_modules/regenerator-transform/src/visit.js
deleted file mode 100644
index a2744b38..00000000
--- a/node_modules/regenerator-transform/src/visit.js
+++ /dev/null
@@ -1,369 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-"use strict";
-
-import assert from "assert";
-import { hoist } from "./hoist";
-import { Emitter } from "./emit";
-import replaceShorthandObjectMethod from "./replaceShorthandObjectMethod";
-import * as util from "./util";
-
-exports.getVisitor = ({ types: t }) => ({
-  Method(path, state) {
-    let node = path.node;
-
-    if (!shouldRegenerate(node, state)) return;
-
-    const container = t.functionExpression(
-      null,
-      [],
-      t.cloneNode(node.body, false),
-      node.generator,
-      node.async,
-    );
-
-    path.get("body").set("body", [
-      t.returnStatement(
-        t.callExpression(container, []),
-      ),
-    ]);
-
-    // Regardless of whether or not the wrapped function is a an async method
-    // or generator the outer function should not be
-    node.async = false;
-    node.generator = false;
-
-    // Unwrap the wrapper IIFE's environment so super and this and such still work.
-    path
-      .get("body.body.0.argument.callee")
-      .unwrapFunctionEnvironment();
-  },
-  Function: {
-    exit: util.wrapWithTypes(t, function(path, state) {
-      let node = path.node;
-
-      if (!shouldRegenerate(node, state)) return;
-
-      // if this is an ObjectMethod, we need to convert it to an ObjectProperty
-      path = replaceShorthandObjectMethod(path);
-      node = path.node;
-
-      let contextId = path.scope.generateUidIdentifier("context");
-      let argsId = path.scope.generateUidIdentifier("args");
-
-      path.ensureBlock();
-      let bodyBlockPath = path.get("body");
-
-      if (node.async) {
-        bodyBlockPath.traverse(awaitVisitor);
-      }
-
-      bodyBlockPath.traverse(functionSentVisitor, {
-        context: contextId
-      });
-
-      let outerBody = [];
-      let innerBody = [];
-
-      bodyBlockPath.get("body").forEach(function(childPath) {
-        let node = childPath.node;
-        if (t.isExpressionStatement(node) &&
-            t.isStringLiteral(node.expression)) {
-          // Babylon represents directives like "use strict" as elements
-          // of a bodyBlockPath.node.directives array, but they could just
-          // as easily be represented (by other parsers) as traditional
-          // string-literal-valued expression statements, so we need to
-          // handle that here. (#248)
-          outerBody.push(node);
-        } else if (node && node._blockHoist != null) {
-          outerBody.push(node);
-        } else {
-          innerBody.push(node);
-        }
-      });
-
-      if (outerBody.length > 0) {
-        // Only replace the inner body if we actually hoisted any statements
-        // to the outer body.
-        bodyBlockPath.node.body = innerBody;
-      }
-
-      let outerFnExpr = getOuterFnExpr(path);
-      // Note that getOuterFnExpr has the side-effect of ensuring that the
-      // function has a name (so node.id will always be an Identifier), even
-      // if a temporary name has to be synthesized.
-      t.assertIdentifier(node.id);
-      let innerFnId = t.identifier(node.id.name + "$");
-
-      // Turn all declarations into vars, and replace the original
-      // declarations with equivalent assignment expressions.
-      let vars = hoist(path);
-
-      let context = {
-        usesThis: false,
-        usesArguments: false,
-        getArgsId: () => t.clone(argsId),
-      };
-      path.traverse(argumentsThisVisitor, context);
-
-      if (context.usesArguments) {
-        vars = vars || t.variableDeclaration("var", []);
-        vars.declarations.push(t.variableDeclarator(
-          t.clone(argsId),
-          t.identifier("arguments"),
-        ));
-      }
-
-      let emitter = new Emitter(contextId);
-      emitter.explode(path.get("body"));
-
-      if (vars && vars.declarations.length > 0) {
-        outerBody.push(vars);
-      }
-
-      let wrapArgs = [emitter.getContextFunction(innerFnId)];
-      let tryLocsList = emitter.getTryLocsList();
-
-      if (node.generator) {
-        wrapArgs.push(outerFnExpr);
-      } else if (context.usesThis || tryLocsList || node.async) {
-        // Async functions that are not generators don't care about the
-        // outer function because they don't need it to be marked and don't
-        // inherit from its .prototype.
-        wrapArgs.push(t.nullLiteral());
-      }
-      if (context.usesThis) {
-        wrapArgs.push(t.thisExpression());
-      } else if (tryLocsList || node.async) {
-        wrapArgs.push(t.nullLiteral());
-      }
-      if (tryLocsList) {
-        wrapArgs.push(tryLocsList);
-      } else if (node.async) {
-        wrapArgs.push(t.nullLiteral());
-      }
-
-      if (node.async) {
-        // Rename any locally declared "Promise" variable,
-        // to use the global one.
-        let currentScope = path.scope;
-        do {
-          if (currentScope.hasOwnBinding("Promise")) currentScope.rename("Promise");
-        } while (currentScope = currentScope.parent);
-
-        wrapArgs.push(t.identifier("Promise"));
-      }
-
-      let wrapCall = t.callExpression(
-        util.runtimeProperty(node.async ? "async" : "wrap"),
-        wrapArgs
-      );
-
-      outerBody.push(t.returnStatement(wrapCall));
-      node.body = t.blockStatement(outerBody);
-      // We injected a few new variable declarations (for every hoisted var),
-      // so we need to add them to the scope.
-      path.get("body.body").forEach(p => p.scope.registerDeclaration(p));
-
-      const oldDirectives = bodyBlockPath.node.directives;
-      if (oldDirectives) {
-        // Babylon represents directives like "use strict" as elements of
-        // a bodyBlockPath.node.directives array. (#248)
-        node.body.directives = oldDirectives;
-      }
-
-      let wasGeneratorFunction = node.generator;
-      if (wasGeneratorFunction) {
-        node.generator = false;
-      }
-
-      if (node.async) {
-        node.async = false;
-      }
-
-      if (wasGeneratorFunction && t.isExpression(node)) {
-        util.replaceWithOrRemove(path, t.callExpression(util.runtimeProperty("mark"), [node]))
-        path.addComment("leading", "#__PURE__");
-      }
-
-      const insertedLocs = emitter.getInsertedLocs();
-
-      path.traverse({
-        NumericLiteral(path) {
-          if (!insertedLocs.has(path.node)) {
-            return;
-          }
-
-          path.replaceWith(t.numericLiteral(path.node.value));
-        },
-      })
-
-      // Generators are processed in 'exit' handlers so that regenerator only has to run on
-      // an ES5 AST, but that means traversal will not pick up newly inserted references
-      // to things like 'regeneratorRuntime'. To avoid this, we explicitly requeue.
-      path.requeue();
-    })
-  }
-});
-
-// Check if a node should be transformed by regenerator
-function shouldRegenerate(node, state) {
-  if (node.generator) {
-    if (node.async) {
-      // Async generator
-      return state.opts.asyncGenerators !== false;
-    } else {
-      // Plain generator
-      return state.opts.generators !== false;
-    }
-  } else if (node.async) {
-    // Async function
-    return state.opts.async !== false;
-  } else {
-    // Not a generator or async function.
-    return false;
-  }
-}
-
-// Given a NodePath for a Function, return an Expression node that can be
-// used to refer reliably to the function object from inside the function.
-// This expression is essentially a replacement for arguments.callee, with
-// the key advantage that it works in strict mode.
-function getOuterFnExpr(funPath) {
-  const t = util.getTypes();
-  let node = funPath.node;
-  t.assertFunction(node);
-
-  if (!node.id) {
-    // Default-exported function declarations, and function expressions may not
-    // have a name to reference, so we explicitly add one.
-    node.id = funPath.scope.parent.generateUidIdentifier("callee");
-  }
-
-  if (node.generator && // Non-generator functions don't need to be marked.
-      t.isFunctionDeclaration(node)) {
-    // Return the identifier returned by runtime.mark(<node.id>).
-    return getMarkedFunctionId(funPath);
-  }
-
-  return t.clone(node.id);
-}
-
-const markInfo = new WeakMap();
-
-function getMarkInfo(node) {
-  if (!markInfo.has(node)) {
-    markInfo.set(node, {});
-  }
-  return markInfo.get(node);
-}
-
-function getMarkedFunctionId(funPath) {
-  const t = util.getTypes();
-  const node = funPath.node;
-  t.assertIdentifier(node.id);
-
-  const blockPath = funPath.findParent(function (path) {
-    return path.isProgram() || path.isBlockStatement();
-  });
-
-  if (!blockPath) {
-    return node.id;
-  }
-
-  const block = blockPath.node;
-  assert.ok(Array.isArray(block.body));
-
-  const info = getMarkInfo(block);
-  if (!info.decl) {
-    info.decl = t.variableDeclaration("var", []);
-    blockPath.unshiftContainer("body", info.decl);
-    info.declPath = blockPath.get("body.0");
-  }
-
-  assert.strictEqual(info.declPath.node, info.decl);
-
-  // Get a new unique identifier for our marked variable.
-  const markedId = blockPath.scope.generateUidIdentifier("marked");
-  const markCallExp = t.callExpression(
-    util.runtimeProperty("mark"),
-    [t.clone(node.id)]
-  );
-
-  const index = info.decl.declarations.push(
-    t.variableDeclarator(markedId, markCallExp)
-  ) - 1;
-
-  const markCallExpPath =
-    info.declPath.get("declarations." + index + ".init");
-
-  assert.strictEqual(markCallExpPath.node, markCallExp);
-
-  markCallExpPath.addComment("leading", "#__PURE__");
-
-  return t.clone(markedId);
-}
-
-let argumentsThisVisitor = {
-  "FunctionExpression|FunctionDeclaration|Method": function(path) {
-    path.skip();
-  },
-
-  Identifier: function(path, state) {
-    if (path.node.name === "arguments" && util.isReference(path)) {
-      util.replaceWithOrRemove(path, state.getArgsId());
-      state.usesArguments = true;
-    }
-  },
-
-  ThisExpression: function(path, state) {
-    state.usesThis = true;
-  }
-};
-
-let functionSentVisitor = {
-  MetaProperty(path) {
-    let { node } = path;
-
-    if (node.meta.name === "function" &&
-        node.property.name === "sent") {
-      const t = util.getTypes();
-      util.replaceWithOrRemove(
-        path,
-        t.memberExpression(
-          t.clone(this.context),
-          t.identifier("_sent")
-        )
-      );
-    }
-  }
-};
-
-let awaitVisitor = {
-  Function: function(path) {
-    path.skip(); // Don't descend into nested function scopes.
-  },
-
-  AwaitExpression: function(path) {
-    const t = util.getTypes();
-
-    // Convert await expressions to yield expressions.
-    let argument = path.node.argument;
-
-    // Transforming `await x` to `yield regeneratorRuntime.awrap(x)`
-    // causes the argument to be wrapped in such a way that the runtime
-    // can distinguish between awaited and merely yielded values.
-    util.replaceWithOrRemove(path, t.yieldExpression(
-      t.callExpression(
-        util.runtimeProperty("awrap"),
-        [argument]
-      ),
-      false
-    ));
-  }
-};