core-js 3.35.1 → 4.0.0-alpha.0

package/internals/internal-state.js

@@ -1,71 +1,32 @@
 'use strict';
-var NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');
-var global = require('../internals/global');
-var isObject = require('../internals/is-object');
-var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
-var hasOwn = require('../internals/has-own-property');
 var shared = require('../internals/shared-store');
-var sharedKey = require('../internals/shared-key');
-var hiddenKeys = require('../internals/hidden-keys');
 
-var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
-var TypeError = global.TypeError;
-var WeakMap = global.WeakMap;
-var set, get, has;
+var $TypeError = TypeError;
+var create = Object.create;
 
-var enforce = function (it) {
-  return has(it) ? get(it) : set(it, {});
+var store = shared.state || (shared.state = new WeakMap());
+/* eslint-disable no-self-assign -- prototype methods protection */
+store.get = store.get;
+store.has = store.has;
+store.set = store.set;
+/* eslint-enable no-self-assign -- prototype methods protection */
+var set = function (it, metadata) {
+  if (store.has(it)) throw new $TypeError('Object already initialized');
+  metadata.facade = it;
+  store.set(it, metadata);
+  return metadata;
 };
 
-var getterFor = function (TYPE) {
-  return function (it) {
-    var state;
-    if (!isObject(it) || (state = get(it)).type !== TYPE) {
-      throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
-    } return state;
-  };
+var get = function (it) {
+  return store.get(it) || create(null);
 };
 
-if (NATIVE_WEAK_MAP || shared.state) {
-  var store = shared.state || (shared.state = new WeakMap());
-  /* eslint-disable no-self-assign -- prototype methods protection */
-  store.get = store.get;
-  store.has = store.has;
-  store.set = store.set;
-  /* eslint-enable no-self-assign -- prototype methods protection */
-  set = function (it, metadata) {
-    if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
-    metadata.facade = it;
-    store.set(it, metadata);
-    return metadata;
-  };
-  get = function (it) {
-    return store.get(it) || {};
-  };
-  has = function (it) {
-    return store.has(it);
-  };
-} else {
-  var STATE = sharedKey('state');
-  hiddenKeys[STATE] = true;
-  set = function (it, metadata) {
-    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
-    metadata.facade = it;
-    createNonEnumerableProperty(it, STATE, metadata);
-    return metadata;
-  };
-  get = function (it) {
-    return hasOwn(it, STATE) ? it[STATE] : {};
-  };
-  has = function (it) {
-    return hasOwn(it, STATE);
-  };
-}
+var enforce = function (it) {
+  return store.has(it) ? get(it) : set(it, create(null));
+};
 
 module.exports = {
   set: set,
   get: get,
-  has: has,
   enforce: enforce,
-  getterFor: getterFor
 };

package/internals/is-array-iterator-method.js

@@ -1,11 +1,10 @@
 'use strict';
 var wellKnownSymbol = require('../internals/well-known-symbol');
-var Iterators = require('../internals/iterators');
 
 var ITERATOR = wellKnownSymbol('iterator');
 var ArrayPrototype = Array.prototype;
 
 // check on default Array iterator
 module.exports = function (it) {
-  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+  return it !== undefined && ArrayPrototype[ITERATOR] === it;
 };

package/internals/is-constructor.js

@@ -3,16 +3,16 @@ var uncurryThis = require('../internals/function-uncurry-this');
 var fails = require('../internals/fails');
 var isCallable = require('../internals/is-callable');
 var classof = require('../internals/classof');
-var getBuiltIn = require('../internals/get-built-in');
+var getBuiltInStaticMethod = require('../internals/get-built-in-static-method');
 var inspectSource = require('../internals/inspect-source');
 
 var noop = function () { /* empty */ };
-var construct = getBuiltIn('Reflect', 'construct');
+var construct = getBuiltInStaticMethod('Reflect', 'construct');
 var constructorRegExp = /^\s*(?:class|function)\b/;
 var exec = uncurryThis(constructorRegExp.exec);
 var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
 
-var isConstructorModern = function isConstructor(argument) {
+var isConstructorModern = function (argument) {
   if (!isCallable(argument)) return false;
   try {
     construct(noop, [], argument);
@@ -22,7 +22,7 @@ var isConstructorModern = function isConstructor(argument) {
   }
 };
 
-var isConstructorLegacy = function isConstructor(argument) {
+var isConstructorLegacy = function (argument) {
   if (!isCallable(argument)) return false;
   switch (classof(argument)) {
     case 'AsyncFunction':
@@ -39,8 +39,6 @@ var isConstructorLegacy = function isConstructor(argument) {
   }
 };
 
-isConstructorLegacy.sham = true;
-
 // `IsConstructor` abstract operation
 // https://tc39.es/ecma262/#sec-isconstructor
 module.exports = !construct || fails(function () {

package/internals/is-iterable.js

@@ -1,9 +1,7 @@
 'use strict';
-var classof = require('../internals/classof');
-var hasOwn = require('../internals/has-own-property');
+var classof = require('../internals/classof-raw');
 var isNullOrUndefined = require('../internals/is-null-or-undefined');
 var wellKnownSymbol = require('../internals/well-known-symbol');
-var Iterators = require('../internals/iterators');
 
 var ITERATOR = wellKnownSymbol('iterator');
 var $Object = Object;
@@ -11,7 +9,5 @@ var $Object = Object;
 module.exports = function (it) {
   if (isNullOrUndefined(it)) return false;
   var O = $Object(it);
-  return O[ITERATOR] !== undefined
-    || '@@iterator' in O
-    || hasOwn(Iterators, classof(O));
+  return O[ITERATOR] !== undefined || classof(O) === 'Arguments';
 };

package/internals/is-typed-array.js

@@ -0,0 +1,7 @@
+'use strict';
+var isObject = require('../internals/is-object');
+var getTypedArrayConstructor = require('../internals/get-typed-array-constructor');
+
+module.exports = function (it) {
+  return isObject(it) && !!getTypedArrayConstructor(it);
+};

package/internals/iterator-create-constructor.js

@@ -1,16 +1,10 @@
 'use strict';
-var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;
-var create = require('../internals/object-create');
+var IteratorPrototype = require('../internals/iterator-prototype');
 var createPropertyDescriptor = require('../internals/create-property-descriptor');
 var setToStringTag = require('../internals/set-to-string-tag');
-var Iterators = require('../internals/iterators');
-
-var returnThis = function () { return this; };
 
 module.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
-  var TO_STRING_TAG = NAME + ' Iterator';
-  IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
-  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
-  Iterators[TO_STRING_TAG] = returnThis;
+  IteratorConstructor.prototype = Object.create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
+  setToStringTag(IteratorConstructor, NAME + ' Iterator', false, true);
   return IteratorConstructor;
 };

package/internals/iterator-create-proxy.js

@@ -1,24 +1,23 @@
 'use strict';
 var call = require('../internals/function-call');
-var create = require('../internals/object-create');
 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
 var defineBuiltIns = require('../internals/define-built-ins');
 var wellKnownSymbol = require('../internals/well-known-symbol');
-var InternalStateModule = require('../internals/internal-state');
+var setInternalState = require('../internals/internal-state').set;
+var internalStateGetterFor = require('../internals/internal-state-getter-for');
 var getMethod = require('../internals/get-method');
-var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;
+var IteratorPrototype = require('../internals/iterator-prototype');
 var createIterResultObject = require('../internals/create-iter-result-object');
 var iteratorClose = require('../internals/iterator-close');
 
 var TO_STRING_TAG = wellKnownSymbol('toStringTag');
 var ITERATOR_HELPER = 'IteratorHelper';
 var WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator';
-var setInternalState = InternalStateModule.set;
 
 var createIteratorProxyPrototype = function (IS_ITERATOR) {
-  var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);
+  var getInternalState = internalStateGetterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);
 
-  return defineBuiltIns(create(IteratorPrototype), {
+  return defineBuiltIns(Object.create(IteratorPrototype), {
     next: function next() {
       var state = getInternalState(this);
       // for simplification:
@@ -33,7 +32,7 @@ var createIteratorProxyPrototype = function (IS_ITERATOR) {
         throw error;
       }
     },
-    'return': function () {
+    return: function () {
       var state = getInternalState(this);
       var iterator = state.iterator;
       state.done = true;
@@ -48,13 +47,14 @@ var createIteratorProxyPrototype = function (IS_ITERATOR) {
       }
       iteratorClose(iterator, 'normal');
       return createIterResultObject(undefined, true);
-    }
+    },
   });
 };
 
 var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
 var IteratorHelperPrototype = createIteratorProxyPrototype(false);
 
+// dependency: es.object.to-string
 createNonEnumerableProperty(IteratorHelperPrototype, TO_STRING_TAG, 'Iterator Helper');
 
 module.exports = function (nextHandler, IS_ITERATOR) {

package/internals/iterator-define.js

@@ -1,102 +1,13 @@
 'use strict';
-var $ = require('../internals/export');
-var call = require('../internals/function-call');
-var IS_PURE = require('../internals/is-pure');
-var FunctionName = require('../internals/function-name');
-var isCallable = require('../internals/is-callable');
-var createIteratorConstructor = require('../internals/iterator-create-constructor');
-var getPrototypeOf = require('../internals/object-get-prototype-of');
-var setPrototypeOf = require('../internals/object-set-prototype-of');
-var setToStringTag = require('../internals/set-to-string-tag');
-var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var globalThis = require('../internals/global-this');
 var defineBuiltIn = require('../internals/define-built-in');
 var wellKnownSymbol = require('../internals/well-known-symbol');
-var Iterators = require('../internals/iterators');
-var IteratorsCore = require('../internals/iterators-core');
 
-var PROPER_FUNCTION_NAME = FunctionName.PROPER;
-var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
-var IteratorPrototype = IteratorsCore.IteratorPrototype;
-var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
 var ITERATOR = wellKnownSymbol('iterator');
-var KEYS = 'keys';
-var VALUES = 'values';
-var ENTRIES = 'entries';
 
-var returnThis = function () { return this; };
-
-module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
-  createIteratorConstructor(IteratorConstructor, NAME, next);
-
-  var getIterationMethod = function (KIND) {
-    if (KIND === DEFAULT && defaultIterator) return defaultIterator;
-    if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];
-
-    switch (KIND) {
-      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
-      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
-      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
-    }
-
-    return function () { return new IteratorConstructor(this); };
-  };
-
-  var TO_STRING_TAG = NAME + ' Iterator';
-  var INCORRECT_VALUES_NAME = false;
-  var IterablePrototype = Iterable.prototype;
-  var nativeIterator = IterablePrototype[ITERATOR]
-    || IterablePrototype['@@iterator']
-    || DEFAULT && IterablePrototype[DEFAULT];
-  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
-  var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
-  var CurrentIteratorPrototype, methods, KEY;
-
-  // fix native
-  if (anyNativeIterator) {
-    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
-    if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
-      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
-        if (setPrototypeOf) {
-          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
-        } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {
-          defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);
-        }
-      }
-      // Set @@toStringTag to native iterators
-      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
-      if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;
-    }
+module.exports = function (iterableName, method, options) {
+  var target = globalThis[iterableName].prototype;
+  if (target[ITERATOR] !== method) {
+    defineBuiltIn(target, ITERATOR, method, options);
   }
-
-  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
-  if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {
-    if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {
-      createNonEnumerableProperty(IterablePrototype, 'name', VALUES);
-    } else {
-      INCORRECT_VALUES_NAME = true;
-      defaultIterator = function values() { return call(nativeIterator, this); };
-    }
-  }
-
-  // export additional methods
-  if (DEFAULT) {
-    methods = {
-      values: getIterationMethod(VALUES),
-      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
-      entries: getIterationMethod(ENTRIES)
-    };
-    if (FORCED) for (KEY in methods) {
-      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
-        defineBuiltIn(IterablePrototype, KEY, methods[KEY]);
-      }
-    } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
-  }
-
-  // define iterator
-  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
-    defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });
-  }
-  Iterators[NAME] = defaultIterator;
-
-  return methods;
 };

package/internals/iterator-normalize-method.js

@@ -0,0 +1,29 @@
+'use strict';
+var IS_PURE = require('../internals/is-pure');
+var IteratorPrototype = require('../internals/iterator-prototype');
+var setPrototypeOf = require('../internals/object-set-prototype-of-simple');
+var setToStringTag = require('../internals/set-to-string-tag');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+
+var ITERATOR = wellKnownSymbol('iterator');
+
+var getPrototypeOf = Object.getPrototypeOf;
+
+module.exports = function (Iterable, ITERABLE_NAME, name) {
+  var iterable = new Iterable();
+  var method = iterable[name || ITERATOR];
+  if (!method) return;
+  var CurrentIteratorPrototype = getPrototypeOf(method.call(iterable));
+  if (CurrentIteratorPrototype === Object.prototype) return;
+  // Safari 8 has buggy iterators w/o `next`
+  if (!('next' in CurrentIteratorPrototype)) return;
+  if (IS_PURE) {
+    if (!CurrentIteratorPrototype[ITERATOR]) return;
+  // Ensure `%IteratorPrototype%` in the prototype chain
+  } else if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
+    setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
+  }
+  // Ensure proper `@@toStringTag`
+  setToStringTag(CurrentIteratorPrototype, ITERABLE_NAME + ' Iterator', true, true);
+  return method;
+};

package/internals/iterator-prototype.js

@@ -0,0 +1,43 @@
+'use strict';
+var fails = require('../internals/fails');
+var isCallable = require('../internals/is-callable');
+var isObject = require('../internals/is-object');
+var defineBuiltIn = require('../internals/define-built-in');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var IS_PURE = require('../internals/is-pure');
+
+var getPrototypeOf = Object.getPrototypeOf;
+var ITERATOR = wellKnownSymbol('iterator');
+
+// `%IteratorPrototype%` object
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
+var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
+
+/* eslint-disable es/no-array-prototype-keys -- safe */
+if ([].keys) {
+  arrayIterator = [].keys();
+  // Safari 8 has buggy iterators w/o `next`
+  if ('next' in arrayIterator) {
+    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
+    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
+  }
+}
+
+var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {
+  var test = {};
+  // FF44- legacy iterators case
+  return IteratorPrototype[ITERATOR].call(test) !== test;
+});
+
+if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
+else if (IS_PURE) IteratorPrototype = Object.create(IteratorPrototype);
+
+// `%IteratorPrototype%[@@iterator]()` method
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
+if (!isCallable(IteratorPrototype[ITERATOR])) {
+  defineBuiltIn(IteratorPrototype, ITERATOR, function () {
+    return this;
+  });
+}
+
+module.exports = IteratorPrototype;

package/internals/iterators.js

@@ -1,2 +1 @@
-'use strict';
-module.exports = {};
+// empty

package/internals/make-built-in.js

@@ -1,51 +1,35 @@
 'use strict';
-var uncurryThis = require('../internals/function-uncurry-this');
-var fails = require('../internals/fails');
 var isCallable = require('../internals/is-callable');
 var hasOwn = require('../internals/has-own-property');
-var DESCRIPTORS = require('../internals/descriptors');
-var CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;
 var inspectSource = require('../internals/inspect-source');
 var InternalStateModule = require('../internals/internal-state');
 
 var enforceInternalState = InternalStateModule.enforce;
 var getInternalState = InternalStateModule.get;
 var $String = String;
-// eslint-disable-next-line es/no-object-defineproperty -- safe
 var defineProperty = Object.defineProperty;
-var stringSlice = uncurryThis(''.slice);
-var replace = uncurryThis(''.replace);
-var join = uncurryThis([].join);
 
-var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
-  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
-});
-
-var TEMPLATE = String(String).split('String');
+var TEMPLATE = $String($String).split('String');
 
 var makeBuiltIn = module.exports = function (value, name, options) {
-  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
-    name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
-  }
-  if (options && options.getter) name = 'get ' + name;
-  if (options && options.setter) name = 'set ' + name;
-  if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
-    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
-    else value.name = name;
-  }
-  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
+  name = $String(name);
+  if (name.slice(0, 7) === 'Symbol(') name = '[' + name.replace(/^Symbol\(([^)]*)\).*$/, '$1') + ']';
+  if (options && options.prefix) name = options.prefix + name;
+  if (!hasOwn(value, 'name') || value.name !== name) try {
+    defineProperty(value, 'name', { value: name, configurable: true });
+  } catch (error) { /* empty */ }
+  if (options && hasOwn(options, 'arity') && value.length !== options.arity) try {
     defineProperty(value, 'length', { value: options.arity });
-  }
+  } catch (error) { /* empty */ }
   try {
     if (options && hasOwn(options, 'constructor') && options.constructor) {
-      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
+      defineProperty(value, 'prototype', { writable: false });
     // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
     } else if (value.prototype) value.prototype = undefined;
   } catch (error) { /* empty */ }
   var state = enforceInternalState(value);
-  if (!hasOwn(state, 'source')) {
-    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
-  } return value;
+  if (!hasOwn(state, 'source')) state.source = TEMPLATE.join(name);
+  return value;
 };
 
 // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative

package/internals/map-helpers.js

@@ -1,15 +1,14 @@
 'use strict';
 var uncurryThis = require('../internals/function-uncurry-this');
 
-// eslint-disable-next-line es/no-map -- safe
+// dependency: es.map.constructor
 var MapPrototype = Map.prototype;
 
 module.exports = {
-  // eslint-disable-next-line es/no-map -- safe
   Map: Map,
   set: uncurryThis(MapPrototype.set),
   get: uncurryThis(MapPrototype.get),
   has: uncurryThis(MapPrototype.has),
-  remove: uncurryThis(MapPrototype['delete']),
-  proto: MapPrototype
+  remove: uncurryThis(MapPrototype.delete),
+  proto: MapPrototype,
 };

package/internals/map-native.js

@@ -0,0 +1,12 @@
+'use strict';
+var uncurryThis = require('../internals/function-uncurry-this');
+
+var MapPrototype = Map.prototype;
+
+module.exports = {
+  Map: Map,
+  set: uncurryThis(MapPrototype.set),
+  get: uncurryThis(MapPrototype.get),
+  has: uncurryThis(MapPrototype.has),
+  remove: uncurryThis(MapPrototype.delete),
+};

package/internals/math-f16round.js

@@ -1,12 +1,30 @@
 'use strict';
-var floatRound = require('../internals/math-float-round');
+var sign = require('../internals/math-sign');
 
+var abs = Math.abs;
+
+var EPSILON = 2.220446049250313e-16; // Number.EPSILON
 var FLOAT16_EPSILON = 0.0009765625;
 var FLOAT16_MAX_VALUE = 65504;
 var FLOAT16_MIN_VALUE = 6.103515625e-05;
+var INVERSE_EPSILON = 1 / EPSILON;
+
+var roundTiesToEven = function (n) {
+  return n + INVERSE_EPSILON - INVERSE_EPSILON;
+};
 
 // `Math.f16round` method implementation
 // https://github.com/tc39/proposal-float16array
 module.exports = Math.f16round || function f16round(x) {
-  return floatRound(x, FLOAT16_EPSILON, FLOAT16_MAX_VALUE, FLOAT16_MIN_VALUE);
+  var n = +x;
+  var absolute = abs(n);
+  var s = sign(n);
+  if (absolute < FLOAT16_MIN_VALUE) {
+    return s * roundTiesToEven(absolute / FLOAT16_MIN_VALUE / FLOAT16_EPSILON) * FLOAT16_MIN_VALUE * FLOAT16_EPSILON;
+  }
+  var a = (1 + FLOAT16_EPSILON / EPSILON) * absolute;
+  var result = a - (a - absolute);
+  // eslint-disable-next-line no-self-compare -- NaN check
+  if (result > FLOAT16_MAX_VALUE || result !== result) return s * Infinity;
+  return s * result;
 };

package/internals/microtask.js

@@ -1,7 +1,6 @@
 'use strict';
-var global = require('../internals/global');
+var globalThis = require('../internals/global-this');
 var safeGetBuiltIn = require('../internals/safe-get-built-in');
-var bind = require('../internals/function-bind-context');
 var macrotask = require('../internals/task').set;
 var Queue = require('../internals/queue');
 var IS_IOS = require('../internals/engine-is-ios');
@@ -9,10 +8,10 @@ var IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');
 var IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');
 var IS_NODE = require('../internals/engine-is-node');
 
-var MutationObserver = global.MutationObserver || global.WebKitMutationObserver;
-var document = global.document;
-var process = global.process;
-var Promise = global.Promise;
+var MutationObserver = globalThis.MutationObserver || globalThis.WebKitMutationObserver;
+var document = globalThis.document;
+var process = globalThis.process;
+var Promise = globalThis.Promise;
 var microtask = safeGetBuiltIn('queueMicrotask');
 var notify, toggle, node, promise, then;
 
@@ -47,7 +46,7 @@ if (!microtask) {
     promise = Promise.resolve(undefined);
     // workaround of WebKit ~ iOS Safari 10.1 bug
     promise.constructor = Promise;
-    then = bind(promise.then, promise);
+    then = promise.then.bind(promise);
     notify = function () {
       then(flush);
     };
@@ -60,11 +59,10 @@ if (!microtask) {
   // - setImmediate
   // - MessageChannel
   // - window.postMessage
-  // - onreadystatechange
   // - setTimeout
   } else {
-    // `webpack` dev server bug on IE global methods - use bind(fn, global)
-    macrotask = bind(macrotask, global);
+    // `webpack` dev server bug on IE global methods - use macrotask.bind(globalThis)
+    macrotask = macrotask.bind(globalThis);
     notify = function () {
       macrotask(flush);
     };

package/internals/native-raw-json.js

@@ -1,5 +1,4 @@
 'use strict';
-/* eslint-disable es/no-json -- safe */
 var fails = require('../internals/fails');
 
 module.exports = !fails(function () {

package/internals/number-is-finite.js

@@ -1,7 +1,7 @@
 'use strict';
-var global = require('../internals/global');
+var globalThis = require('../internals/global-this');
 
-var globalIsFinite = global.isFinite;
+var globalIsFinite = globalThis.isFinite;
 
 // `Number.isFinite` method
 // https://tc39.es/ecma262/#sec-number.isfinite

package/internals/object-define-properties.js

@@ -1,21 +1,2 @@
 'use strict';
-var DESCRIPTORS = require('../internals/descriptors');
-var V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');
-var definePropertyModule = require('../internals/object-define-property');
-var anObject = require('../internals/an-object');
-var toIndexedObject = require('../internals/to-indexed-object');
-var objectKeys = require('../internals/object-keys');
-
-// `Object.defineProperties` method
-// https://tc39.es/ecma262/#sec-object.defineproperties
-// eslint-disable-next-line es/no-object-defineproperties -- safe
-exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
-  anObject(O);
-  var props = toIndexedObject(Properties);
-  var keys = objectKeys(Properties);
-  var length = keys.length;
-  var index = 0;
-  var key;
-  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
-  return O;
-};
+exports.f = Object.defineProperties;