update modules

node_modules/@babel/runtime/helpers/arrayLikeToArray.js

@@ -0,0 +1,11 @@
+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;
+}
+
+module.exports = _arrayLikeToArray;

node_modules/@babel/runtime/helpers/arrayWithoutHoles.js

@@ -1,11 +1,7 @@
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) {
-    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
-      arr2[i] = arr[i];
-    }
+var arrayLikeToArray = require("./arrayLikeToArray");
 
-    return arr2;
-  }
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return arrayLikeToArray(arr);
 }
 
 module.exports = _arrayWithoutHoles;

node_modules/@babel/runtime/helpers/construct.js

@@ -1,17 +1,6 @@
 var setPrototypeOf = require("./setPrototypeOf");
 
-function isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-
-  try {
-    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
+var isNativeReflectConstruct = require("./isNativeReflectConstruct");
 
 function _construct(Parent, args, Class) {
   if (isNativeReflectConstruct()) {

node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js

@@ -0,0 +1,60 @@
+var unsupportedIterableToArray = require("./unsupportedIterableToArray");
+
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it;
+
+  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+
+      var F = function F() {};
+
+      return {
+        s: F,
+        n: function n() {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function e(_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 s() {
+      it = o[Symbol.iterator]();
+    },
+    n: function n() {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function e(_e2) {
+      didErr = true;
+      err = _e2;
+    },
+    f: function f() {
+      try {
+        if (!normalCompletion && it["return"] != null) it["return"]();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+module.exports = _createForOfIteratorHelper;

node_modules/@babel/runtime/helpers/createForOfIteratorHelperLoose.js

@@ -0,0 +1,28 @@
+var unsupportedIterableToArray = require("./unsupportedIterableToArray");
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it;
+
+  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+    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);
+}
+
+module.exports = _createForOfIteratorHelperLoose;

node_modules/@babel/runtime/helpers/createSuper.js

@@ -0,0 +1,24 @@
+var getPrototypeOf = require("./getPrototypeOf");
+
+var isNativeReflectConstruct = require("./isNativeReflectConstruct");
+
+var possibleConstructorReturn = require("./possibleConstructorReturn");
+
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = isNativeReflectConstruct();
+  return function _createSuperInternal() {
+    var Super = getPrototypeOf(Derived),
+        result;
+
+    if (hasNativeReflectConstruct) {
+      var NewTarget = getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+
+    return possibleConstructorReturn(this, result);
+  };
+}
+
+module.exports = _createSuper;

node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js

@@ -0,0 +1,9 @@
+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;
+}

node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js

@@ -1,9 +1,4 @@
+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);
 }

node_modules/@babel/runtime/helpers/esm/construct.js

@@ -1,18 +1,5 @@
 import setPrototypeOf from "./setPrototypeOf";
-
-function isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-
-  try {
-    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
+import isNativeReflectConstruct from "./isNativeReflectConstruct";
 export default function _construct(Parent, args, Class) {
   if (isNativeReflectConstruct()) {
     _construct = Reflect.construct;

node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js

@@ -0,0 +1,57 @@
+import unsupportedIterableToArray from "./unsupportedIterableToArray";
+export default function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it;
+
+  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+
+      var F = function F() {};
+
+      return {
+        s: F,
+        n: function n() {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function e(_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 s() {
+      it = o[Symbol.iterator]();
+    },
+    n: function n() {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function e(_e2) {
+      didErr = true;
+      err = _e2;
+    },
+    f: function f() {
+      try {
+        if (!normalCompletion && it["return"] != null) it["return"]();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}

node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelperLoose.js

@@ -0,0 +1,25 @@
+import unsupportedIterableToArray from "./unsupportedIterableToArray";
+export default function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it;
+
+  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+    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);
+}

node_modules/@babel/runtime/helpers/esm/createSuper.js

@@ -0,0 +1,19 @@
+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) {
+      var NewTarget = getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+
+    return possibleConstructorReturn(this, result);
+  };
+}

node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js

@@ -0,0 +1,12 @@
+export default function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}

node_modules/@babel/runtime/helpers/esm/iterableToArray.js

@@ -1,3 +1,3 @@
 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);
 }

node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js

@@ -1,8 +1,5 @@
 export default function _iterableToArrayLimit(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 = [];
   var _n = true;
   var _d = false;

node_modules/@babel/runtime/helpers/esm/iterableToArrayLimitLoose.js

@@ -1,8 +1,5 @@
 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;) {

node_modules/@babel/runtime/helpers/esm/maybeArrayLike.js

@@ -0,0 +1,9 @@
+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);
+}

node_modules/@babel/runtime/helpers/esm/nonIterableRest.js

@@ -1,3 +1,3 @@
 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.");
 }

node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js

@@ -1,3 +1,3 @@
 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.");
 }

node_modules/@babel/runtime/helpers/esm/objectSpread.js

@@ -1,8 +1,8 @@
 import defineProperty from "./defineProperty";
 export default function _objectSpread(target) {
   for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    var ownKeys = Object.keys(Object(source));
+    var source = arguments[i] != null ? Object(arguments[i]) : {};
+    var ownKeys = Object.keys(source);
 
     if (typeof Object.getOwnPropertySymbols === 'function') {
       ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {

node_modules/@babel/runtime/helpers/esm/slicedToArray.js

@@ -1,6 +1,7 @@
 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();
 }

node_modules/@babel/runtime/helpers/esm/slicedToArrayLoose.js

@@ -1,6 +1,7 @@
 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();
 }

node_modules/@babel/runtime/helpers/esm/toArray.js

@@ -1,6 +1,7 @@
 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();
 }

node_modules/@babel/runtime/helpers/esm/toConsumableArray.js

@@ -1,6 +1,7 @@
 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();
 }

node_modules/@babel/runtime/helpers/esm/typeof.js

@@ -1,4 +1,6 @@
 export default function _typeof(obj) {
+  "@babel/helpers - typeof";
+
   if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
     _typeof = function _typeof(obj) {
       return typeof obj;

node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js

@@ -0,0 +1,9 @@
+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);
+}

node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js

@@ -0,0 +1,14 @@
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+module.exports = _isNativeReflectConstruct;

node_modules/@babel/runtime/helpers/iterableToArray.js

@@ -1,5 +1,5 @@
 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);
 }
 
 module.exports = _iterableToArray;

node_modules/@babel/runtime/helpers/iterableToArrayLimit.js

@@ -1,8 +1,5 @@
 function _iterableToArrayLimit(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 = [];
   var _n = true;
   var _d = false;

node_modules/@babel/runtime/helpers/iterableToArrayLimitLoose.js

@@ -1,8 +1,5 @@
 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;) {

node_modules/@babel/runtime/helpers/maybeArrayLike.js

@@ -0,0 +1,12 @@
+var arrayLikeToArray = require("./arrayLikeToArray");
+
+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);
+}
+
+module.exports = _maybeArrayLike;

node_modules/@babel/runtime/helpers/nonIterableRest.js

@@ -1,5 +1,5 @@
 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.");
 }
 
 module.exports = _nonIterableRest;

node_modules/@babel/runtime/helpers/nonIterableSpread.js

@@ -1,5 +1,5 @@
 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.");
 }
 
 module.exports = _nonIterableSpread;

node_modules/@babel/runtime/helpers/objectSpread.js

@@ -2,8 +2,8 @@ var defineProperty = require("./defineProperty");
 
 function _objectSpread(target) {
   for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    var ownKeys = Object.keys(Object(source));
+    var source = arguments[i] != null ? Object(arguments[i]) : {};
+    var ownKeys = Object.keys(source);
 
     if (typeof Object.getOwnPropertySymbols === 'function') {
       ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {

node_modules/@babel/runtime/helpers/slicedToArray.js

@@ -2,10 +2,12 @@ var arrayWithHoles = require("./arrayWithHoles");
 
 var iterableToArrayLimit = require("./iterableToArrayLimit");
 
+var unsupportedIterableToArray = require("./unsupportedIterableToArray");
+
 var nonIterableRest = require("./nonIterableRest");
 
 function _slicedToArray(arr, i) {
-  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
 }
 
 module.exports = _slicedToArray;

node_modules/@babel/runtime/helpers/slicedToArrayLoose.js

@@ -2,10 +2,12 @@ var arrayWithHoles = require("./arrayWithHoles");
 
 var iterableToArrayLimitLoose = require("./iterableToArrayLimitLoose");
 
+var unsupportedIterableToArray = require("./unsupportedIterableToArray");
+
 var nonIterableRest = require("./nonIterableRest");
 
 function _slicedToArrayLoose(arr, i) {
-  return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
+  return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
 }
 
 module.exports = _slicedToArrayLoose;

node_modules/@babel/runtime/helpers/toArray.js

@@ -2,10 +2,12 @@ var arrayWithHoles = require("./arrayWithHoles");
 
 var iterableToArray = require("./iterableToArray");
 
+var unsupportedIterableToArray = require("./unsupportedIterableToArray");
+
 var nonIterableRest = require("./nonIterableRest");
 
 function _toArray(arr) {
-  return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();
+  return arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest();
 }
 
 module.exports = _toArray;

node_modules/@babel/runtime/helpers/toConsumableArray.js

@@ -2,10 +2,12 @@ var arrayWithoutHoles = require("./arrayWithoutHoles");
 
 var iterableToArray = require("./iterableToArray");
 
+var unsupportedIterableToArray = require("./unsupportedIterableToArray");
+
 var nonIterableSpread = require("./nonIterableSpread");
 
 function _toConsumableArray(arr) {
-  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
 }
 
 module.exports = _toConsumableArray;

node_modules/@babel/runtime/helpers/typeof.js

@@ -1,4 +1,6 @@
 function _typeof(obj) {
+  "@babel/helpers - typeof";
+
   if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
     module.exports = _typeof = function _typeof(obj) {
       return typeof obj;

node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js

@@ -0,0 +1,12 @@
+var arrayLikeToArray = require("./arrayLikeToArray");
+
+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);
+}
+
+module.exports = _unsupportedIterableToArray;

node_modules/@babel/runtime/package.json

@@ -1,33 +1,30 @@
 {
-  "_args": [
-    [
-      "@babel/runtime@7.7.7",
-      "D:\\Projects\\siag\\vanillajs-seed"
-    ]
-  ],
-  "_from": "@babel/runtime@7.7.7",
-  "_id": "@babel/runtime@7.7.7",
+  "_from": "@babel/runtime@^7.3.1",
+  "_id": "@babel/runtime@7.10.2",
   "_inBundle": false,
-  "_integrity": "sha512-uCnC2JEVAu8AKB5do1WRIsvrdJ0flYx/A/9f/6chdacnEZ7LmavjdsDXr5ksYBegxtuTPR5Va9/+13QF/kFkCA==",
+  "_integrity": "sha512-6sF3uQw2ivImfVIl62RZ7MXhO2tap69WeWK57vAaimT6AZbE4FbqjdEJIN1UqoD6wI6B+1n9UiagafH1sxjOtg==",
   "_location": "/@babel/runtime",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "@babel/runtime@7.7.7",
+    "raw": "@babel/runtime@^7.3.1",
     "name": "@babel/runtime",
     "escapedName": "@babel%2fruntime",
     "scope": "@babel",
-    "rawSpec": "7.7.7",
+    "rawSpec": "^7.3.1",
     "saveSpec": null,
-    "fetchSpec": "7.7.7"
+    "fetchSpec": "^7.3.1"
   },
   "_requiredBy": [
-    "/i18next"
+    "/i18next",
+    "/i18next-browser-languagedetector",
+    "/i18next-xhr-backend"
   ],
-  "_resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.7.7.tgz",
-  "_spec": "7.7.7",
-  "_where": "D:\\Projects\\siag\\vanillajs-seed",
+  "_resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.10.2.tgz",
+  "_shasum": "d103f21f2602497d38348a32e008637d506db839",
+  "_spec": "@babel/runtime@^7.3.1",
+  "_where": "D:\\Projects\\vanillajs-seed\\node_modules\\i18next",
   "author": {
     "name": "Sebastian McKenzie",
     "email": "sebmck@gmail.com"
@@ -35,14 +32,16 @@
   "bugs": {
     "url": "https://github.com/babel/babel/issues"
   },
+  "bundleDependencies": false,
   "dependencies": {
-    "regenerator-runtime": "^0.13.2"
+    "regenerator-runtime": "^0.13.4"
   },
+  "deprecated": false,
   "description": "babel's modular runtime helpers",
   "devDependencies": {
-    "@babel/helpers": "^7.7.4"
+    "@babel/helpers": "^7.10.1"
   },
-  "gitHead": "12da0941c898987ae30045a9da90ed5bf58ecaf9",
+  "gitHead": "b0350e5b1e86bd2d53b4a25705e39eb380ec65a2",
   "homepage": "https://babeljs.io/docs/en/next/babel-runtime",
   "license": "MIT",
   "name": "@babel/runtime",
@@ -54,5 +53,5 @@
     "url": "git+https://github.com/babel/babel.git",
     "directory": "packages/babel-runtime"
   },
-  "version": "7.7.7"
+  "version": "7.10.2"
 }