@babel/runtime-corejs2 - npm Package Compare versions

Comparing version 7.8.7 to 7.9.0

helpers/arrayWithoutHoles.js

 var _Array$isArray = require("../core-js/array/is-array");
 
+var arrayLikeToArray = require("./arrayLikeToArray");
+
 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);
 }
 
 module.exports = _arrayWithoutHoles;

helpers/construct.js

@@ -5,15 +5,4 @@ var _Reflect$construct = require("../core-js/reflect/construct");
 
-function isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !_Reflect$construct) return false;
-  if (_Reflect$construct.sham) return false;
-  if (typeof Proxy === "function") return true;
+var isNativeReflectConstruct = require("./isNativeReflectConstruct");
 
-  try {
-    Date.prototype.toString.call(_Reflect$construct(Date, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
 function _construct(Parent, args, Class) {
@@ -20,0 +9,0 @@ if (isNativeReflectConstruct()) {

helpers/esm/arrayWithoutHoles.js

 import _Array$isArray from "../../core-js/array/is-array";
+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/esm/construct.js

 import _Reflect$construct from "../../core-js/reflect/construct";
 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) {
@@ -18,0 +5,0 @@ if (isNativeReflectConstruct()) {

helpers/esm/iterableToArray.js

 import _Array$from from "../../core-js/array/from";
 import _isIterable from "../../core-js/is-iterable";
+import _Symbol from "../../core-js/symbol";
 export default function _iterableToArray(iter) {
-  if (_isIterable(Object(iter)) || Object.prototype.toString.call(iter) === "[object Arguments]") return _Array$from(iter);
+  if (typeof _Symbol !== "undefined" && _isIterable(Object(iter))) return _Array$from(iter);
 }

helpers/esm/iterableToArrayLimit.js

 import _getIterator from "../../core-js/get-iterator";
 import _isIterable from "../../core-js/is-iterable";
+import _Symbol from "../../core-js/symbol";
 export default function _iterableToArrayLimit(arr, i) {
-  if (!(_isIterable(Object(arr)) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
-    return;
-  }
-
+  if (typeof _Symbol === "undefined" || !_isIterable(Object(arr))) return;
   var _arr = [];
@@ -9,0 +7,0 @@ var _n = true;

helpers/esm/iterableToArrayLimitLoose.js

 import _getIterator from "../../core-js/get-iterator";
 import _isIterable from "../../core-js/is-iterable";
+import _Symbol from "../../core-js/symbol";
 export default function _iterableToArrayLimitLoose(arr, i) {
-  if (!(_isIterable(Object(arr)) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
-    return;
-  }
-
+  if (typeof _Symbol === "undefined" || !_isIterable(Object(arr))) return;
   var _arr = [];
@@ -9,0 +7,0 @@

helpers/esm/nonIterableRest.js

 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/esm/nonIterableSpread.js

 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/esm/slicedToArray.js

 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/esm/slicedToArrayLoose.js

 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/esm/toArray.js

 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/esm/toConsumableArray.js

 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/iterableToArray.js

@@ -5,6 +5,8 @@ var _Array$from = require("../core-js/array/from");
 
+var _Symbol = require("../core-js/symbol");
+
 function _iterableToArray(iter) {
-  if (_isIterable(Object(iter)) || Object.prototype.toString.call(iter) === "[object Arguments]") return _Array$from(iter);
+  if (typeof _Symbol !== "undefined" && _isIterable(Object(iter))) return _Array$from(iter);
 }
 
 module.exports = _iterableToArray;

helpers/iterableToArrayLimit.js

@@ -5,7 +5,6 @@ var _getIterator = require("../core-js/get-iterator");
 
+var _Symbol = require("../core-js/symbol");
+
 function _iterableToArrayLimit(arr, i) {
-  if (!(_isIterable(Object(arr)) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
-    return;
-  }
-
+  if (typeof _Symbol === "undefined" || !_isIterable(Object(arr))) return;
   var _arr = [];
@@ -12,0 +11,0 @@ var _n = true;

helpers/iterableToArrayLimitLoose.js

@@ -5,7 +5,6 @@ var _getIterator = require("../core-js/get-iterator");
 
+var _Symbol = require("../core-js/symbol");
+
 function _iterableToArrayLimitLoose(arr, i) {
-  if (!(_isIterable(Object(arr)) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
-    return;
-  }
-
+  if (typeof _Symbol === "undefined" || !_isIterable(Object(arr))) return;
   var _arr = [];
@@ -12,0 +11,0 @@

helpers/nonIterableRest.js

 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;

helpers/nonIterableSpread.js

 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;

helpers/slicedToArray.js

@@ -5,8 +5,10 @@ var arrayWithHoles = require("./arrayWithHoles");
 
+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;

helpers/slicedToArrayLoose.js

@@ -5,8 +5,10 @@ var arrayWithHoles = require("./arrayWithHoles");
 
+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;

helpers/toArray.js

@@ -5,8 +5,10 @@ var arrayWithHoles = require("./arrayWithHoles");
 
+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;

helpers/toConsumableArray.js

@@ -5,8 +5,10 @@ var arrayWithoutHoles = require("./arrayWithoutHoles");
 
+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;

package.json

 {
   "name": "@babel/runtime-corejs2",
-  "version": "7.8.7",
+  "version": "7.9.0",
   "description": "babel's modular runtime helpers with core-js@2 polyfilling",
@@ -16,5 +16,5 @@ "license": "MIT",
   "devDependencies": {
-    "@babel/helpers": "^7.8.4"
+    "@babel/helpers": "^7.9.0"
   },
-  "gitHead": "595f65f33b8e948e34d12be83f700cf8d070c790"
+  "gitHead": "8d5e422be27251cfaadf8dd2536b31b4a5024b02"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

115826

increased by9.09%

Number of package files

257

increased by5.33%

Lines of code

2853

increased by8.64%

No dependency changes