Updating NPM dependencies

node_modules/@babel/helpers/lib/helpers.js

@@ -487,10 +487,8 @@ helpers.setPrototypeOf = helper("7.0.0-beta.0")`
     return _setPrototypeOf(o, p);
   }
 `;
-helpers.construct = helper("7.0.0-beta.0")`
-  import setPrototypeOf from "setPrototypeOf";
-
-  function isNativeReflectConstruct() {
+helpers.isNativeReflectConstruct = helper("7.9.0")`
+  export default function _isNativeReflectConstruct() {
     if (typeof Reflect === "undefined" || !Reflect.construct) return false;
 
     // core-js@3
@@ -514,6 +512,10 @@ helpers.construct = helper("7.0.0-beta.0")`
       return false;
     }
   }
+`;
+helpers.construct = helper("7.0.0-beta.0")`
+  import setPrototypeOf from "setPrototypeOf";
+  import isNativeReflectConstruct from "isNativeReflectConstruct";
 
   export default function _construct(Parent, args, Class) {
     if (isNativeReflectConstruct()) {
@@ -704,6 +706,27 @@ helpers.possibleConstructorReturn = helper("7.0.0-beta.0")`
     return assertThisInitialized(self);
   }
 `;
+helpers.createSuper = helper("7.9.0")`
+  import getPrototypeOf from "getPrototypeOf";
+  import isNativeReflectConstruct from "isNativeReflectConstruct";
+  import possibleConstructorReturn from "possibleConstructorReturn";
+
+  export default function _createSuper(Derived) {
+    var hasNativeReflectConstruct = isNativeReflectConstruct();
+
+    return function _createSuperInternal() {
+      var Super = getPrototypeOf(Derived), result;
+      if (hasNativeReflectConstruct) {
+        // NOTE: This doesn't work if this.__proto__.constructor has been modified.
+        var NewTarget = getPrototypeOf(this).constructor;
+        result = Reflect.construct(Super, arguments, NewTarget);
+      } else {
+        result = Super.apply(this, arguments);
+      }
+      return possibleConstructorReturn(this, result);
+    }
+  }
+ `;
 helpers.superPropBase = helper("7.0.0-beta.0")`
   import getPrototypeOf from "getPrototypeOf";
 
@@ -812,7 +835,7 @@ helpers.taggedTemplateLiteralLoose = helper("7.0.0-beta.0")`
 `;
 helpers.readOnlyError = helper("7.0.0-beta.0")`
   export default function _readOnlyError(name) {
-    throw new Error("\\"" + name + "\\" is read-only");
+    throw new TypeError("\\"" + name + "\\" is read-only");
   }
 `;
 helpers.classNameTDZError = helper("7.0.0-beta.0")`
@@ -841,45 +864,68 @@ helpers.temporalRef = helper("7.0.0-beta.0")`
 helpers.slicedToArray = helper("7.0.0-beta.0")`
   import arrayWithHoles from "arrayWithHoles";
   import iterableToArrayLimit from "iterableToArrayLimit";
+  import unsupportedIterableToArray from "unsupportedIterableToArray";
   import nonIterableRest from "nonIterableRest";
 
   export default function _slicedToArray(arr, i) {
-    return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+    return (
+      arrayWithHoles(arr) ||
+      iterableToArrayLimit(arr, i) ||
+      unsupportedIterableToArray(arr, i) ||
+      nonIterableRest()
+    );
   }
 `;
 helpers.slicedToArrayLoose = helper("7.0.0-beta.0")`
   import arrayWithHoles from "arrayWithHoles";
   import iterableToArrayLimitLoose from "iterableToArrayLimitLoose";
+  import unsupportedIterableToArray from "unsupportedIterableToArray";
   import nonIterableRest from "nonIterableRest";
 
   export default function _slicedToArrayLoose(arr, i) {
-    return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
+    return (
+      arrayWithHoles(arr) ||
+      iterableToArrayLimitLoose(arr, i) ||
+      unsupportedIterableToArray(arr, i) ||
+      nonIterableRest()
+    );
   }
 `;
 helpers.toArray = helper("7.0.0-beta.0")`
   import arrayWithHoles from "arrayWithHoles";
   import iterableToArray from "iterableToArray";
+  import unsupportedIterableToArray from "unsupportedIterableToArray";
   import nonIterableRest from "nonIterableRest";
 
   export default function _toArray(arr) {
-    return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();
+    return (
+      arrayWithHoles(arr) ||
+      iterableToArray(arr) ||
+      unsupportedIterableToArray(arr) ||
+      nonIterableRest()
+    );
   }
 `;
 helpers.toConsumableArray = helper("7.0.0-beta.0")`
   import arrayWithoutHoles from "arrayWithoutHoles";
   import iterableToArray from "iterableToArray";
+  import unsupportedIterableToArray from "unsupportedIterableToArray";
   import nonIterableSpread from "nonIterableSpread";
 
   export default function _toConsumableArray(arr) {
-    return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+    return (
+      arrayWithoutHoles(arr) ||
+      iterableToArray(arr) ||
+      unsupportedIterableToArray(arr) ||
+      nonIterableSpread()
+    );
   }
 `;
 helpers.arrayWithoutHoles = helper("7.0.0-beta.0")`
+  import arrayLikeToArray from "arrayLikeToArray";
+
   export default function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) {
-      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
-      return arr2;
-    }
+    if (Array.isArray(arr)) return arrayLikeToArray(arr);
   }
 `;
 helpers.arrayWithHoles = helper("7.0.0-beta.0")`
@@ -887,12 +933,20 @@ helpers.arrayWithHoles = helper("7.0.0-beta.0")`
     if (Array.isArray(arr)) return arr;
   }
 `;
+helpers.maybeArrayLike = helper("7.9.0")`
+  import arrayLikeToArray from "arrayLikeToArray";
+
+  export default function _maybeArrayLike(next, arr, i) {
+    if (arr && !Array.isArray(arr) && typeof arr.length === "number") {
+      var len = arr.length;
+      return arrayLikeToArray(arr, i !== void 0 && i < len ? i : len);
+    }
+    return next(arr, i);
+  }
+`;
 helpers.iterableToArray = helper("7.0.0-beta.0")`
   export default function _iterableToArray(iter) {
-    if (
-      Symbol.iterator in Object(iter) ||
-      Object.prototype.toString.call(iter) === "[object Arguments]"
-    ) return Array.from(iter);
+    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
   }
 `;
 helpers.iterableToArrayLimit = helper("7.0.0-beta.0")`
@@ -906,9 +960,9 @@ helpers.iterableToArrayLimit = helper("7.0.0-beta.0")`
     // _e = _iteratorError
     // _i = _iterator
     // _s = _step
-    if (!(
-      Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]"
-    )) { return }
+
+    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+
     var _arr = [];
     var _n = true;
     var _d = false;
@@ -933,9 +987,8 @@ helpers.iterableToArrayLimit = helper("7.0.0-beta.0")`
 `;
 helpers.iterableToArrayLimitLoose = helper("7.0.0-beta.0")`
   export default function _iterableToArrayLimitLoose(arr, i) {
-    if (!(
-      Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]"
-    )) { return }
+    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+
     var _arr = [];
     for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
       _arr.push(_step.value);
@@ -944,14 +997,125 @@ helpers.iterableToArrayLimitLoose = helper("7.0.0-beta.0")`
     return _arr;
   }
 `;
+helpers.unsupportedIterableToArray = helper("7.9.0")`
+  import arrayLikeToArray from "arrayLikeToArray";
+
+  export default function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return arrayLikeToArray(o, minLen);
+  }
+`;
+helpers.arrayLikeToArray = helper("7.9.0")`
+  export default function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+    return arr2;
+  }
+`;
 helpers.nonIterableSpread = helper("7.0.0-beta.0")`
   export default function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance");
+    throw new TypeError(
+      "Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
+    );
   }
 `;
 helpers.nonIterableRest = helper("7.0.0-beta.0")`
   export default function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance");
+    throw new TypeError(
+      "Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
+    );
+  }
+`;
+helpers.createForOfIteratorHelper = helper("7.9.0")`
+  import unsupportedIterableToArray from "unsupportedIterableToArray";
+
+  // s: start (create the iterator)
+  // n: next
+  // e: error (called whenever something throws)
+  // f: finish (always called at the end)
+
+  export default function _createForOfIteratorHelper(o, allowArrayLike) {
+    var it;
+    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+      // Fallback for engines without symbol support
+      if (
+        Array.isArray(o) ||
+        (it = unsupportedIterableToArray(o)) ||
+        (allowArrayLike && o && typeof o.length === "number")
+      ) {
+        if (it) o = it;
+        var i = 0;
+        var F = function(){};
+        return {
+          s: F,
+          n: function() {
+            if (i >= o.length) return { done: true };
+            return { done: false, value: o[i++] };
+          },
+          e: function(e) { throw e; },
+          f: F,
+        };
+      }
+
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+
+    var normalCompletion = true, didErr = false, err;
+
+    return {
+      s: function() {
+        it = o[Symbol.iterator]();
+      },
+      n: function() {
+        var step = it.next();
+        normalCompletion = step.done;
+        return step;
+      },
+      e: function(e) {
+        didErr = true;
+        err = e;
+      },
+      f: function() {
+        try {
+          if (!normalCompletion && it.return != null) it.return();
+        } finally {
+          if (didErr) throw err;
+        }
+      }
+    };
+  }
+`;
+helpers.createForOfIteratorHelperLoose = helper("7.9.0")`
+  import unsupportedIterableToArray from "unsupportedIterableToArray";
+
+  export default function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+    var it;
+
+    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+      // Fallback for engines without symbol support
+      if (
+        Array.isArray(o) ||
+        (it = unsupportedIterableToArray(o)) ||
+        (allowArrayLike && o && typeof o.length === "number")
+      ) {
+        if (it) o = it;
+        var i = 0;
+        return function() {
+          if (i >= o.length) return { done: true };
+          return { done: false, value: o[i++] };
+        }
+      }
+
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+
+    it = o[Symbol.iterator]();
+    return it.next.bind(it);
   }
 `;
 helpers.skipFirstGeneratorNext = helper("7.0.0-beta.0")`
@@ -1028,8 +1192,6 @@ helpers.applyDecoratedDescriptor = helper("7.0.0-beta.0")`
         }
 
         if (desc.initializer === void 0){
-            // This is a hack to avoid this being processed by 'transform-runtime'.
-            // See issue #9.
             Object.defineProperty(target, property, desc);
             desc = null;
         }