core-js 3.0.0-beta.7 → 3.0.1

package/internals/array-reduce.js

@@ -13,7 +13,7 @@ module.exports = function (that, callbackfn, argumentsLength, memo, isRight) {
   var length = toLength(O.length);
   var index = isRight ? length - 1 : 0;
   var i = isRight ? -1 : 1;
-  if (argumentsLength < 2) for (;;) {
+  if (argumentsLength < 2) while (true) {
     if (index in self) {
       memo = self[index];
       index += i;
@@ -21,7 +21,7 @@ module.exports = function (that, callbackfn, argumentsLength, memo, isRight) {
     }
     index += i;
     if (isRight ? index < 0 : length <= index) {
-      throw TypeError('Reduce of empty array with no initial value!');
+      throw TypeError('Reduce of empty array with no initial value');
     }
   }
   for (;isRight ? index >= 0 : length > index; index += i) if (index in self) {

package/internals/call-with-safe-iteration-closing.js

@@ -5,9 +5,9 @@ module.exports = function (iterator, fn, value, ENTRIES) {
   try {
     return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
   // 7.4.6 IteratorClose(iterator, completion)
-  } catch (e) {
+  } catch (error) {
     var returnMethod = iterator['return'];
     if (returnMethod !== undefined) anObject(returnMethod.call(iterator));
-    throw e;
+    throw error;
   }
 };

package/internals/check-correctness-of-iteration.js

@@ -16,7 +16,7 @@ try {
   };
   // eslint-disable-next-line no-throw-literal
   Array.from(iteratorWithReturn, function () { throw 2; });
-} catch (e) { /* empty */ }
+} catch (error) { /* empty */ }
 
 module.exports = function (exec, SKIP_CLOSING) {
   if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
@@ -31,6 +31,6 @@ module.exports = function (exec, SKIP_CLOSING) {
       };
     };
     exec(object);
-  } catch (e) { /* empty */ }
+  } catch (error) { /* empty */ }
   return ITERATION_SUPPORT;
 };

package/internals/classof.js

@@ -7,7 +7,7 @@ var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Argu
 var tryGet = function (it, key) {
   try {
     return it[key];
-  } catch (e) { /* empty */ }
+  } catch (error) { /* empty */ }
 };
 
 // getting tag from ES6+ `Object.prototype.toString`

package/internals/collection-delete-all.js

@@ -6,9 +6,9 @@ var aFunction = require('../internals/a-function');
 module.exports = function (/* ...elements */) {
   var collection = anObject(this);
   var remover = aFunction(collection['delete']);
-  var result = true;
+  var allDeleted = true;
   for (var k = 0, len = arguments.length; k < len; k++) {
-    if (!remover.call(collection, arguments[k])) result = false;
+    allDeleted = allDeleted && remover.call(collection, arguments[k]);
   }
-  return result;
+  return !!allDeleted;
 };

package/internals/collection-from.js

@@ -0,0 +1,25 @@
+'use strict';
+// https://tc39.github.io/proposal-setmap-offrom/
+var aFunction = require('../internals/a-function');
+var bind = require('../internals/bind-context');
+var iterate = require('../internals/iterate');
+
+module.exports = function from(source /* , mapFn, thisArg */) {
+  var mapFn = arguments[1];
+  var mapping, A, n, boundFunction;
+  aFunction(this);
+  mapping = mapFn !== undefined;
+  if (mapping) aFunction(mapFn);
+  if (source == undefined) return new this();
+  A = [];
+  if (mapping) {
+    n = 0;
+    boundFunction = bind(mapFn, arguments[2], 2);
+    iterate(source, function (nextItem) {
+      A.push(boundFunction(nextItem, n++));
+    });
+  } else {
+    iterate(source, A.push, A);
+  }
+  return new this(A);
+};

package/internals/collection-of.js

@@ -0,0 +1,8 @@
+'use strict';
+// https://tc39.github.io/proposal-setmap-offrom/
+module.exports = function of() {
+  var length = arguments.length;
+  var A = new Array(length);
+  while (length--) A[length] = arguments[length];
+  return new this(A);
+};

package/internals/collection-strong.js

@@ -14,11 +14,11 @@ var setInternalState = InternalStateModule.set;
 var internalStateGetterFor = InternalStateModule.getterFor;
 
 module.exports = {
-  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
+  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {
     var C = wrapper(function (that, iterable) {
-      anInstance(that, C, NAME);
+      anInstance(that, C, CONSTRUCTOR_NAME);
       setInternalState(that, {
-        type: NAME,
+        type: CONSTRUCTOR_NAME,
         index: create(null),
         first: undefined,
         last: undefined,
@@ -28,7 +28,7 @@ module.exports = {
       if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP);
     });
 
-    var getInternalState = internalStateGetterFor(NAME);
+    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);
 
     var define = function (that, key, value) {
       var state = getInternalState(that);
@@ -147,13 +147,13 @@ module.exports = {
     });
     return C;
   },
-  setStrong: function (C, NAME, IS_MAP) {
-    var ITERATOR_NAME = NAME + ' Iterator';
-    var getInternalCollectionState = internalStateGetterFor(NAME);
+  setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) {
+    var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';
+    var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);
     var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);
     // add .keys, .values, .entries, [@@iterator]
     // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
-    defineIterator(C, NAME, function (iterated, kind) {
+    defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) {
       setInternalState(this, {
         type: ITERATOR_NAME,
         target: iterated,
@@ -180,6 +180,6 @@ module.exports = {
     }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
 
     // add [@@species], 23.1.2.2, 23.2.2.2
-    setSpecies(NAME);
+    setSpecies(CONSTRUCTOR_NAME);
   }
 };

package/internals/collection-weak.js

@@ -52,18 +52,18 @@ UncaughtFrozenStore.prototype = {
 };
 
 module.exports = {
-  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
+  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {
     var C = wrapper(function (that, iterable) {
-      anInstance(that, C, NAME);
+      anInstance(that, C, CONSTRUCTOR_NAME);
       setInternalState(that, {
-        type: NAME,
+        type: CONSTRUCTOR_NAME,
         id: id++,
         frozen: undefined
       });
       if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP);
     });
 
-    var getInternalState = internalStateGetterFor(NAME);
+    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);
 
     var define = function (that, key, value) {
       var state = getInternalState(that);

package/internals/collection.js

@@ -12,8 +12,8 @@ var checkCorrectnessOfIteration = require('../internals/check-correctness-of-ite
 var setToStringTag = require('../internals/set-to-string-tag');
 var inheritIfRequired = require('../internals/inherit-if-required');
 
-module.exports = function (NAME, wrapper, common, IS_MAP, IS_WEAK) {
-  var NativeConstructor = global[NAME];
+module.exports = function (CONSTRUCTOR_NAME, wrapper, common, IS_MAP, IS_WEAK) {
+  var NativeConstructor = global[CONSTRUCTOR_NAME];
   var NativePrototype = NativeConstructor && NativeConstructor.prototype;
   var Constructor = NativeConstructor;
   var ADDER = IS_MAP ? 'set' : 'add';
@@ -39,13 +39,13 @@ module.exports = function (NAME, wrapper, common, IS_MAP, IS_WEAK) {
   };
 
   // eslint-disable-next-line max-len
-  if (isForced(NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () {
+  if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () {
     new NativeConstructor().entries().next();
   })))) {
     // create collection constructor
-    Constructor = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
+    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);
     InternalMetadataModule.REQUIRED = true;
-  } else if (isForced(NAME, true)) {
+  } else if (isForced(CONSTRUCTOR_NAME, true)) {
     var instance = new Constructor();
     // early implementations not supports chaining
     var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
@@ -65,7 +65,7 @@ module.exports = function (NAME, wrapper, common, IS_MAP, IS_WEAK) {
 
     if (!ACCEPT_ITERABLES) {
       Constructor = wrapper(function (target, iterable) {
-        anInstance(target, Constructor, NAME);
+        anInstance(target, Constructor, CONSTRUCTOR_NAME);
         var that = inheritIfRequired(new NativeConstructor(), target, Constructor);
         if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP);
         return that;
@@ -86,12 +86,12 @@ module.exports = function (NAME, wrapper, common, IS_MAP, IS_WEAK) {
     if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;
   }
 
-  exported[NAME] = Constructor;
+  exported[CONSTRUCTOR_NAME] = Constructor;
   $export({ global: true, forced: Constructor != NativeConstructor }, exported);
 
-  setToStringTag(Constructor, NAME);
+  setToStringTag(Constructor, CONSTRUCTOR_NAME);
 
-  if (!IS_WEAK) common.setStrong(Constructor, NAME, IS_MAP);
+  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);
 
   return Constructor;
 };

package/internals/create-html.js

@@ -0,0 +1,11 @@
+var requireObjectCoercible = require('../internals/require-object-coercible');
+var quot = /"/g;
+
+// B.2.3.2.1 CreateHTML(string, tag, attribute, value)
+// https://tc39.github.io/ecma262/#sec-createhtml
+module.exports = function (string, tag, attribute, value) {
+  var S = String(requireObjectCoercible(string));
+  var p1 = '<' + tag;
+  if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '&quot;') + '"';
+  return p1 + '>' + S + '</' + tag + '>';
+};

package/internals/date-to-primitive.js

@@ -3,6 +3,7 @@ var anObject = require('../internals/an-object');
 var toPrimitive = require('../internals/to-primitive');
 
 module.exports = function (hint) {
-  if (hint !== 'string' && hint !== 'number' && hint !== 'default') throw TypeError('Incorrect hint');
-  return toPrimitive(anObject(this), hint !== 'number');
+  if (hint !== 'string' && hint !== 'number' && hint !== 'default') {
+    throw TypeError('Incorrect hint');
+  } return toPrimitive(anObject(this), hint !== 'number');
 };

package/internals/export.js

@@ -1,4 +1,5 @@
 var global = require('../internals/global');
+var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
 var hide = require('../internals/hide');
 var redefine = require('../internals/redefine');
 var setGlobal = require('../internals/set-global');
@@ -6,23 +7,24 @@ var copyConstructorProperties = require('../internals/copy-constructor-propertie
 var isForced = require('../internals/is-forced');
 
 /*
-  options.target     - name of the target object
-  options.global     - target is the global object
-  options.stat       - export as static methods of target
-  options.proto      - export as prototype methods of target
-  options.real       - real prototype method for the `pure` version
-  options.forced     - export even if the native feature is available
-  options.bind       - bind methods to the target, required for the `pure` version
-  options.wrap       - wrap constructors to preventing global pollution, required for the `pure` version
-  options.unsafe     - use the simple assignment of property instead of delete + defineProperty
-  options.sham       - add a flag to not completely full polyfills
-  options.enumerable - export as enumerable property
+  options.target      - name of the target object
+  options.global      - target is the global object
+  options.stat        - export as static methods of target
+  options.proto       - export as prototype methods of target
+  options.real        - real prototype method for the `pure` version
+  options.forced      - export even if the native feature is available
+  options.bind        - bind methods to the target, required for the `pure` version
+  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
+  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
+  options.sham        - add a flag to not completely full polyfills
+  options.enumerable  - export as enumerable property
+  options.noTargetGet - prevent calling a getter on target
 */
 module.exports = function (options, source) {
   var TARGET = options.target;
   var GLOBAL = options.global;
   var STATIC = options.stat;
-  var FORCED, target, key, targetProperty, sourceProperty;
+  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
   if (GLOBAL) {
     target = global;
   } else if (STATIC) {
@@ -31,8 +33,11 @@ module.exports = function (options, source) {
     target = (global[TARGET] || {}).prototype;
   }
   if (target) for (key in source) {
-    targetProperty = target[key];
     sourceProperty = source[key];
+    if (options.noTargetGet) {
+      descriptor = getOwnPropertyDescriptor(target, key);
+      targetProperty = descriptor && descriptor.value;
+    } else targetProperty = target[key];
     FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
     // contained in target
     if (!FORCED && targetProperty !== undefined) {

package/internals/fails.js

@@ -1,7 +1,7 @@
 module.exports = function (exec) {
   try {
     return !!exec();
-  } catch (e) {
+  } catch (error) {
     return true;
   }
 };

package/internals/fix-regexp-well-known-symbol-logic.js

@@ -2,7 +2,6 @@
 var hide = require('../internals/hide');
 var redefine = require('../internals/redefine');
 var fails = require('../internals/fails');
-var requireObjectCoercible = require('../internals/require-object-coercible');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 var regexpExec = require('../internals/regexp-exec');
 
@@ -21,14 +20,15 @@ var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
   return ''.replace(re, '$<a>') !== '7';
 });
 
-var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = (function () {
-  // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
+// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
+// Weex JS has frozen built-in prototypes, so use try / catch wrapper
+var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
   var re = /(?:)/;
   var originalExec = re.exec;
   re.exec = function () { return originalExec.apply(this, arguments); };
   var result = 'ab'.split(re);
-  return result.length === 2 && result[0] === 'a' && result[1] === 'b';
-})();
+  return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
+});
 
 module.exports = function (KEY, length, exec, sham) {
   var SYMBOL = wellKnownSymbol(KEY);
@@ -40,7 +40,7 @@ module.exports = function (KEY, length, exec, sham) {
     return ''[KEY](O) != 7;
   });
 
-  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL ? !fails(function () {
+  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {
     // Symbol-named RegExp methods call .exec
     var execCalled = false;
     var re = /a/;
@@ -55,7 +55,7 @@ module.exports = function (KEY, length, exec, sham) {
 
     re[SYMBOL]('');
     return !execCalled;
-  }) : undefined;
+  });
 
   if (
     !DELEGATES_TO_SYMBOL ||
@@ -64,23 +64,18 @@ module.exports = function (KEY, length, exec, sham) {
     (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)
   ) {
     var nativeRegExpMethod = /./[SYMBOL];
-    var methods = exec(
-      requireObjectCoercible,
-      SYMBOL,
-      ''[KEY],
-      function (nativeMethod, regexp, str, arg2, forceStringMethod) {
-        if (regexp.exec === regexpExec) {
-          if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
-            // The native String method already delegates to @@method (this
-            // polyfilled function), leasing to infinite recursion.
-            // We avoid it by directly calling the native @@method method.
-            return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };
-          }
-          return { done: true, value: nativeMethod.call(str, regexp, arg2) };
+    var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
+      if (regexp.exec === regexpExec) {
+        if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
+          // The native String method already delegates to @@method (this
+          // polyfilled function), leasing to infinite recursion.
+          // We avoid it by directly calling the native @@method method.
+          return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };
         }
-        return { done: false };
+        return { done: true, value: nativeMethod.call(str, regexp, arg2) };
       }
-    );
+      return { done: false };
+    });
     var stringMethod = methods[0];
     var regexMethod = methods[1];
 

package/internals/flatten-into-array.js

@@ -18,7 +18,7 @@ var flattenIntoArray = function (target, original, source, sourceLen, start, dep
       if (depth > 0 && isArray(element)) {
         targetIndex = flattenIntoArray(target, original, element, toLength(element.length), targetIndex, depth - 1) - 1;
       } else {
-        if (targetIndex >= 0x1fffffffffffff) throw TypeError();
+        if (targetIndex >= 0x1FFFFFFFFFFFFF) throw TypeError('Exceed the acceptable array length');
         target[targetIndex] = element;
       }
 

package/internals/{object-forced-pam.js → forced-object-prototype-accessors-methods.js}

@@ -1,9 +1,9 @@
 'use strict';
-// Forced replacement prototype accessors methods
+// Forced replacement object prototype accessors methods
 module.exports = require('../internals/is-pure') || !require('../internals/fails')(function () {
-  var K = Math.random();
+  var key = Math.random();
   // In FF throws only define methods
   // eslint-disable-next-line no-undef, no-useless-call
-  __defineSetter__.call(null, K, function () { /* empty */ });
-  delete require('../internals/global')[K];
+  __defineSetter__.call(null, key, function () { /* empty */ });
+  delete require('../internals/global')[key];
 });

package/internals/forced-string-html-method.js

@@ -0,0 +1,10 @@
+var fails = require('../internals/fails');
+
+// check the existence of a method, lowercase
+// of a tag and escaping quotes in arguments
+module.exports = function (METHOD_NAME) {
+  return fails(function () {
+    var test = ''[METHOD_NAME]('"');
+    return test !== test.toLowerCase() || test.split('"').length > 3;
+  });
+};

package/internals/forced-string-trim-method.js

@@ -0,0 +1,11 @@
+var fails = require('../internals/fails');
+var whitespaces = require('../internals/whitespaces');
+var non = '\u200B\u0085\u180E';
+
+// check that a method works with the correct list
+// of whitespaces and has a correct name
+module.exports = function (METHOD_NAME) {
+  return fails(function () {
+    return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME;
+  });
+};

package/internals/function-bind.js

@@ -4,12 +4,12 @@ var isObject = require('../internals/is-object');
 var arraySlice = [].slice;
 var factories = {};
 
-var construct = function (F, len, args) {
-  if (!(len in factories)) {
-    for (var n = [], i = 0; i < len; i++) n[i] = 'a[' + i + ']';
+var construct = function (C, argsLength, args) {
+  if (!(argsLength in factories)) {
+    for (var list = [], i = 0; i < argsLength; i++) list[i] = 'a[' + i + ']';
     // eslint-disable-next-line no-new-func
-    factories[len] = Function('F,a', 'return new F(' + n.join(',') + ')');
-  } return factories[len](F, args);
+    factories[argsLength] = Function('C,a', 'return new C(' + list.join(',') + ')');
+  } return factories[argsLength](C, args);
 };
 
 // `Function.prototype.bind` method implementation

package/internals/get-built-in.js

@@ -0,0 +1,11 @@
+var path = require('../internals/path');
+var global = require('../internals/global');
+
+var aFunction = function (variable) {
+  return typeof variable == 'function' ? variable : undefined;
+};
+
+module.exports = function (namespace, method) {
+  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])
+    : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];
+};

package/internals/get-iterator.js

@@ -3,6 +3,7 @@ var getIteratorMethod = require('../internals/get-iterator-method');
 
 module.exports = function (it) {
   var iteratorMethod = getIteratorMethod(it);
-  if (typeof iteratorMethod != 'function') throw TypeError(it + ' is not iterable!');
-  return anObject(iteratorMethod.call(it));
+  if (typeof iteratorMethod != 'function') {
+    throw TypeError(String(it) + ' is not iterable');
+  } return anObject(iteratorMethod.call(it));
 };

package/internals/get-map-iterator.js

@@ -1,7 +1,7 @@
 var IS_PURE = require('../internals/is-pure');
 var getIterator = require('../internals/get-iterator');
 
-module.exports = function (it) {
+module.exports = IS_PURE ? getIterator : function (it) {
   // eslint-disable-next-line no-undef
-  return IS_PURE ? getIterator(it) : Map.prototype.entries.call(it);
+  return Map.prototype.entries.call(it);
 };

package/internals/get-set-iterator.js

@@ -1,7 +1,7 @@
 var IS_PURE = require('../internals/is-pure');
 var getIterator = require('../internals/get-iterator');
 
-module.exports = function (it) {
+module.exports = IS_PURE ? getIterator : function (it) {
   // eslint-disable-next-line no-undef
-  return IS_PURE ? getIterator(it) : Set.prototype.values.call(it);
+  return Set.prototype.values.call(it);
 };

package/internals/global.js

@@ -1,5 +1,5 @@
 // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
-module.exports = typeof window != 'undefined' && window.Math == Math
-  ? window : typeof self != 'undefined' && self.Math == Math ? self
+module.exports = typeof window == 'object' && window && window.Math == Math ? window
+  : typeof self == 'object' && self && self.Math == Math ? self
   // eslint-disable-next-line no-new-func
   : Function('return this')();

package/internals/internal-state.js

@@ -1,11 +1,10 @@
-var global = require('../internals/global');
-var nativeFunctionToString = require('../internals/function-to-string');
+var NATIVE_WEAK_MAP = require('../internals/native-weak-map');
 var isObject = require('../internals/is-object');
 var hide = require('../internals/hide');
 var objectHas = require('../internals/has');
 var sharedKey = require('../internals/shared-key');
 var hiddenKeys = require('../internals/hidden-keys');
-var WeakMap = global.WeakMap;
+var WeakMap = require('../internals/global').WeakMap;
 var set, get, has;
 
 var enforce = function (it) {
@@ -16,12 +15,12 @@ var getterFor = function (TYPE) {
   return function (it) {
     var state;
     if (!isObject(it) || (state = get(it)).type !== TYPE) {
-      throw TypeError('Incompatible receiver, ' + TYPE + ' required!');
+      throw TypeError('Incompatible receiver, ' + TYPE + ' required');
     } return state;
   };
 };
 
-if (typeof WeakMap == 'function' && /native code/.test(nativeFunctionToString.call(WeakMap))) {
+if (NATIVE_WEAK_MAP) {
   var store = new WeakMap();
   var wmget = store.get;
   var wmhas = store.has;

package/internals/iterate.js

@@ -14,7 +14,7 @@ var exports = module.exports = function (iterable, fn, that, ENTRIES, ITERATOR)
     iterator = iterable;
   } else {
     iterFn = getIteratorMethod(iterable);
-    if (typeof iterFn != 'function') throw TypeError('Target is not iterable!');
+    if (typeof iterFn != 'function') throw TypeError('Target is not iterable');
     // optimisation for array iterators
     if (isArrayIteratorMethod(iterFn)) {
       for (index = 0, length = toLength(iterable.length); length > index; index++) {

package/internals/math-scale.js

@@ -3,16 +3,13 @@
 module.exports = Math.scale || function scale(x, inLow, inHigh, outLow, outHigh) {
   if (
     arguments.length === 0
-      // eslint-disable-next-line no-self-compare
+      /* eslint-disable no-self-compare */
       || x != x
-      // eslint-disable-next-line no-self-compare
       || inLow != inLow
-      // eslint-disable-next-line no-self-compare
       || inHigh != inHigh
-      // eslint-disable-next-line no-self-compare
       || outLow != outLow
-      // eslint-disable-next-line no-self-compare
       || outHigh != outHigh
+      /* eslint-enable no-self-compare */
   ) return NaN;
   if (x === Infinity || x === -Infinity) return x;
   return (x - inLow) * (outHigh - outLow) / (inHigh - inLow) + outLow;