core-js-pure 3.19.2 → 3.20.2

package/modules/es.string.at-alternative.js

@@ -9,7 +9,7 @@ var fails = require('../internals/fails');
 var charAt = uncurryThis(''.charAt);
 
 var FORCED = fails(function () {
-  return '𠮷'.at(0) !== '\uD842';
+  return '𠮷'.at(-2) !== '\uD842';
 });
 
 // `String.prototype.at` method

package/modules/es.symbol.js

@@ -28,6 +28,7 @@ var getOwnPropertyNamesExternal = require('../internals/object-get-own-property-
 var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');
 var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
 var definePropertyModule = require('../internals/object-define-property');
+var definePropertiesModule = require('../internals/object-define-properties');
 var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');
 var arraySlice = require('../internals/array-slice');
 var redefine = require('../internals/redefine');
@@ -194,6 +195,7 @@ if (!NATIVE_SYMBOL) {
 
   propertyIsEnumerableModule.f = $propertyIsEnumerable;
   definePropertyModule.f = $defineProperty;
+  definePropertiesModule.f = $defineProperties;
   getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor;
   getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames;
   getOwnPropertySymbolsModule.f = $getOwnPropertySymbols;

package/modules/es.weak-map.js

@@ -7,7 +7,7 @@ var collection = require('../internals/collection');
 var collectionWeak = require('../internals/collection-weak');
 var isObject = require('../internals/is-object');
 var isExtensible = require('../internals/object-is-extensible');
-var enforceIternalState = require('../internals/internal-state').enforce;
+var enforceInternalState = require('../internals/internal-state').enforce;
 var NATIVE_WEAK_MAP = require('../internals/native-weak-map');
 
 var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;
@@ -37,28 +37,28 @@ if (NATIVE_WEAK_MAP && IS_IE11) {
   redefineAll(WeakMapPrototype, {
     'delete': function (key) {
       if (isObject(key) && !isExtensible(key)) {
-        var state = enforceIternalState(this);
+        var state = enforceInternalState(this);
         if (!state.frozen) state.frozen = new InternalWeakMap();
         return nativeDelete(this, key) || state.frozen['delete'](key);
       } return nativeDelete(this, key);
     },
     has: function has(key) {
       if (isObject(key) && !isExtensible(key)) {
-        var state = enforceIternalState(this);
+        var state = enforceInternalState(this);
         if (!state.frozen) state.frozen = new InternalWeakMap();
         return nativeHas(this, key) || state.frozen.has(key);
       } return nativeHas(this, key);
     },
     get: function get(key) {
       if (isObject(key) && !isExtensible(key)) {
-        var state = enforceIternalState(this);
+        var state = enforceInternalState(this);
         if (!state.frozen) state.frozen = new InternalWeakMap();
         return nativeHas(this, key) ? nativeGet(this, key) : state.frozen.get(key);
       } return nativeGet(this, key);
     },
     set: function set(key, value) {
       if (isObject(key) && !isExtensible(key)) {
-        var state = enforceIternalState(this);
+        var state = enforceInternalState(this);
         if (!state.frozen) state.frozen = new InternalWeakMap();
         nativeHas(this, key) ? nativeSet(this, key, value) : state.frozen.set(key, value);
       } else nativeSet(this, key, value);

package/modules/esnext.array.group-by-to-map.js

@@ -0,0 +1,38 @@
+'use strict';
+var $ = require('../internals/export');
+var getBuiltIn = require('../internals/get-built-in');
+var bind = require('../internals/function-bind-context');
+var uncurryThis = require('../internals/function-uncurry-this');
+var IndexedObject = require('../internals/indexed-object');
+var toObject = require('../internals/to-object');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
+var addToUnscopables = require('../internals/add-to-unscopables');
+
+var Map = getBuiltIn('Map');
+var MapPrototype = Map.prototype;
+var mapGet = uncurryThis(MapPrototype.get);
+var mapHas = uncurryThis(MapPrototype.has);
+var mapSet = uncurryThis(MapPrototype.set);
+var push = uncurryThis([].push);
+
+// `Array.prototype.groupByToMap` method
+// https://github.com/tc39/proposal-array-grouping
+$({ target: 'Array', proto: true }, {
+  groupByToMap: function groupByToMap(callbackfn /* , thisArg */) {
+    var O = toObject(this);
+    var self = IndexedObject(O);
+    var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+    var map = new Map();
+    var length = lengthOfArrayLike(self);
+    var index = 0;
+    var key, value;
+    for (;length > index; index++) {
+      value = self[index];
+      key = boundFunction(value, index, O);
+      if (mapHas(map, key)) push(mapGet(map, key), value);
+      else mapSet(map, key, [value]);
+    } return map;
+  }
+});
+
+addToUnscopables('groupByToMap');

package/modules/esnext.array.group-by.js

@@ -1,7 +1,6 @@
 'use strict';
 var $ = require('../internals/export');
 var $groupBy = require('../internals/array-group-by');
-var arraySpeciesConstructor = require('../internals/array-species-constructor');
 var addToUnscopables = require('../internals/add-to-unscopables');
 
 // `Array.prototype.groupBy` method
@@ -9,7 +8,7 @@ var addToUnscopables = require('../internals/add-to-unscopables');
 $({ target: 'Array', proto: true }, {
   groupBy: function groupBy(callbackfn /* , thisArg */) {
     var thisArg = arguments.length > 1 ? arguments[1] : undefined;
-    return $groupBy(this, callbackfn, thisArg, arraySpeciesConstructor);
+    return $groupBy(this, callbackfn, thisArg);
   }
 });
 

package/modules/esnext.array.to-reversed.js

@@ -0,0 +1,18 @@
+'use strict';
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var arrayToReversed = require('../internals/array-to-reversed');
+var toIndexedObject = require('../internals/to-indexed-object');
+var addToUnscopables = require('../internals/add-to-unscopables');
+
+var Array = global.Array;
+
+// `Array.prototype.toReversed` method
+// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.toReversed
+$({ target: 'Array', proto: true }, {
+  toReversed: function toReversed() {
+    return arrayToReversed(toIndexedObject(this), Array);
+  }
+});
+
+addToUnscopables('toReversed');

package/modules/esnext.array.to-sorted.js

@@ -0,0 +1,25 @@
+'use strict';
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var uncurryThis = require('../internals/function-uncurry-this');
+var aCallable = require('../internals/a-callable');
+var toIndexedObject = require('../internals/to-indexed-object');
+var arrayFromConstructorAndList = require('../internals/array-from-constructor-and-list');
+var getVirtual = require('../internals/entry-virtual');
+var addToUnscopables = require('../internals/add-to-unscopables');
+
+var Array = global.Array;
+var sort = uncurryThis(getVirtual('Array').sort);
+
+// `Array.prototype.toSorted` method
+// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.toSorted
+$({ target: 'Array', proto: true }, {
+  toSorted: function toSorted(compareFn) {
+    if (compareFn !== undefined) aCallable(compareFn);
+    var O = toIndexedObject(this);
+    var A = arrayFromConstructorAndList(Array, O);
+    return sort(A, compareFn);
+  }
+});
+
+addToUnscopables('toSorted');

package/modules/esnext.array.to-spliced.js

@@ -0,0 +1,20 @@
+'use strict';
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var toIndexedObject = require('../internals/to-indexed-object');
+var arraySlice = require('../internals/array-slice');
+var arrayToSpliced = require('../internals/array-to-spliced');
+var addToUnscopables = require('../internals/add-to-unscopables');
+
+var Array = global.Array;
+
+// `Array.prototype.toSpliced` method
+// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.toSpliced
+$({ target: 'Array', proto: true }, {
+  // eslint-disable-next-line no-unused-vars -- required for .length
+  toSpliced: function toSpliced(start, deleteCount /* , ...items */) {
+    return arrayToSpliced(toIndexedObject(this), Array, arraySlice(arguments));
+  }
+});
+
+addToUnscopables('toSpliced');

package/modules/esnext.array.with.js

@@ -0,0 +1,15 @@
+'use strict';
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var arrayWith = require('../internals/array-with');
+var toIndexedObject = require('../internals/to-indexed-object');
+
+var Array = global.Array;
+
+// `Array.prototype.with` method
+// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.with
+$({ target: 'Array', proto: true }, {
+  'with': function (index, value) {
+    return arrayWith(toIndexedObject(this), Array, index, value);
+  }
+});

package/modules/esnext.function.is-callable.js

@@ -0,0 +1,29 @@
+var $ = require('../internals/export');
+var uncurryThis = require('../internals/function-uncurry-this');
+var $isCallable = require('../internals/is-callable');
+var inspectSource = require('../internals/inspect-source');
+var hasOwn = require('../internals/has-own-property');
+var DESCRIPTORS = require('../internals/descriptors');
+
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var classRegExp = /^\s*class\b/;
+var exec = uncurryThis(classRegExp.exec);
+
+var isClassConstructor = function (argument) {
+  try {
+    // `Function#toString` throws on some built-it function in some legacy engines
+    // (for example, `DOMQuad` and similar in FF41-)
+    if (!DESCRIPTORS || !exec(classRegExp, inspectSource(argument))) return false;
+  } catch (error) { /* empty */ }
+  var prototype = getOwnPropertyDescriptor(argument, 'prototype');
+  return !!prototype && hasOwn(prototype, 'writable') && !prototype.writable;
+};
+
+// `Function.isCallable` method
+// https://github.com/caitp/TC39-Proposals/blob/trunk/tc39-reflect-isconstructor-iscallable.md
+$({ target: 'Function', stat: true, sham: true }, {
+  isCallable: function isCallable(argument) {
+    return $isCallable(argument) && !isClassConstructor(argument);
+  }
+});

package/modules/esnext.function.is-constructor.js

@@ -0,0 +1,8 @@
+var $ = require('../internals/export');
+var isConstructor = require('../internals/is-constructor');
+
+// `Function.isConstructor` method
+// https://github.com/caitp/TC39-Proposals/blob/trunk/tc39-reflect-isconstructor-iscallable.md
+$({ target: 'Function', stat: true }, {
+  isConstructor: isConstructor
+});

package/modules/esnext.function.un-this.js

@@ -0,0 +1,11 @@
+var $ = require('../internals/export');
+var uncurryThis = require('../internals/function-uncurry-this');
+var aCallable = require('../internals/a-callable');
+
+// `Function.prototype.unThis` method
+// https://github.com/js-choi/proposal-function-un-this
+$({ target: 'Function', proto: true }, {
+  unThis: function unThis() {
+    return uncurryThis(aCallable(this));
+  }
+});

package/modules/esnext.iterator.to-async.js

@@ -0,0 +1,10 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var AsyncFromSyncIterator = require('../internals/async-from-sync-iterator');
+
+$({ target: 'Iterator', proto: true, real: true }, {
+  toAsync: function toAsync() {
+    return new AsyncFromSyncIterator(this);
+  }
+});

package/modules/esnext.map.merge.js

@@ -9,7 +9,7 @@ var iterate = require('../internals/iterate');
 // https://github.com/tc39/proposal-collection-methods
 $({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
   // eslint-disable-next-line no-unused-vars -- required for `.length`
-  merge: function merge(iterable /* ...iterbles */) {
+  merge: function merge(iterable /* ...iterables */) {
     var map = anObject(this);
     var setter = aCallable(map.set);
     var argumentsLength = arguments.length;

package/modules/esnext.observable.js

@@ -21,42 +21,51 @@ var hostReportErrors = require('../internals/host-report-errors');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 var InternalStateModule = require('../internals/internal-state');
 
-var OBSERVABLE = wellKnownSymbol('observable');
-var getInternalState = InternalStateModule.get;
+var $$OBSERVABLE = wellKnownSymbol('observable');
+var OBSERVABLE = 'Observable';
+var SUBSCRIPTION = 'Subscription';
+var SUBSCRIPTION_OBSERVER = 'SubscriptionObserver';
+var getterFor = InternalStateModule.getterFor;
 var setInternalState = InternalStateModule.set;
+var getObservableInternalState = getterFor(OBSERVABLE);
+var getSubscriptionInternalState = getterFor(SUBSCRIPTION);
+var getSubscriptionObserverInternalState = getterFor(SUBSCRIPTION_OBSERVER);
 var Array = global.Array;
 
-var cleanupSubscription = function (subscriptionState) {
-  var cleanup = subscriptionState.cleanup;
-  if (cleanup) {
-    subscriptionState.cleanup = undefined;
-    try {
-      cleanup();
-    } catch (error) {
-      hostReportErrors(error);
-    }
-  }
-};
-
-var subscriptionClosed = function (subscriptionState) {
-  return subscriptionState.observer === undefined;
+var SubscriptionState = function (observer) {
+  this.observer = anObject(observer);
+  this.cleanup = undefined;
+  this.subscriptionObserver = undefined;
 };
 
-var close = function (subscriptionState) {
-  var subscription = subscriptionState.facade;
-  if (!DESCRIPTORS) {
-    subscription.closed = true;
-    var subscriptionObserver = subscriptionState.subscriptionObserver;
-    if (subscriptionObserver) subscriptionObserver.closed = true;
-  } subscriptionState.observer = undefined;
+SubscriptionState.prototype = {
+  type: SUBSCRIPTION,
+  clean: function () {
+    var cleanup = this.cleanup;
+    if (cleanup) {
+      this.cleanup = undefined;
+      try {
+        cleanup();
+      } catch (error) {
+        hostReportErrors(error);
+      }
+    }
+  },
+  close: function () {
+    if (!DESCRIPTORS) {
+      var subscription = this.facade;
+      var subscriptionObserver = this.subscriptionObserver;
+      subscription.closed = true;
+      if (subscriptionObserver) subscriptionObserver.closed = true;
+    } this.observer = undefined;
+  },
+  isClosed: function () {
+    return this.observer === undefined;
+  }
 };
 
 var Subscription = function (observer, subscriber) {
-  var subscriptionState = setInternalState(this, {
-    cleanup: undefined,
-    observer: anObject(observer),
-    subscriptionObserver: undefined
-  });
+  var subscriptionState = setInternalState(this, new SubscriptionState(observer));
   var start;
   if (!DESCRIPTORS) this.closed = false;
   try {
@@ -64,8 +73,8 @@ var Subscription = function (observer, subscriber) {
   } catch (error) {
     hostReportErrors(error);
   }
-  if (subscriptionClosed(subscriptionState)) return;
-  var subscriptionObserver = subscriptionState.subscriptionObserver = new SubscriptionObserver(this);
+  if (subscriptionState.isClosed()) return;
+  var subscriptionObserver = subscriptionState.subscriptionObserver = new SubscriptionObserver(subscriptionState);
   try {
     var cleanup = subscriber(subscriptionObserver);
     var subscription = cleanup;
@@ -75,15 +84,15 @@ var Subscription = function (observer, subscriber) {
   } catch (error) {
     subscriptionObserver.error(error);
     return;
-  } if (subscriptionClosed(subscriptionState)) cleanupSubscription(subscriptionState);
+  } if (subscriptionState.isClosed()) subscriptionState.clean();
 };
 
 Subscription.prototype = redefineAll({}, {
   unsubscribe: function unsubscribe() {
-    var subscriptionState = getInternalState(this);
-    if (!subscriptionClosed(subscriptionState)) {
-      close(subscriptionState);
-      cleanupSubscription(subscriptionState);
+    var subscriptionState = getSubscriptionInternalState(this);
+    if (!subscriptionState.isClosed()) {
+      subscriptionState.close();
+      subscriptionState.clean();
     }
   }
 });
@@ -91,19 +100,22 @@ Subscription.prototype = redefineAll({}, {
 if (DESCRIPTORS) defineProperty(Subscription.prototype, 'closed', {
   configurable: true,
   get: function () {
-    return subscriptionClosed(getInternalState(this));
+    return getSubscriptionInternalState(this).isClosed();
   }
 });
 
-var SubscriptionObserver = function (subscription) {
-  setInternalState(this, { subscription: subscription });
+var SubscriptionObserver = function (subscriptionState) {
+  setInternalState(this, {
+    type: SUBSCRIPTION_OBSERVER,
+    subscriptionState: subscriptionState
+  });
   if (!DESCRIPTORS) this.closed = false;
 };
 
 SubscriptionObserver.prototype = redefineAll({}, {
   next: function next(value) {
-    var subscriptionState = getInternalState(getInternalState(this).subscription);
-    if (!subscriptionClosed(subscriptionState)) {
+    var subscriptionState = getSubscriptionObserverInternalState(this).subscriptionState;
+    if (!subscriptionState.isClosed()) {
       var observer = subscriptionState.observer;
       try {
         var nextMethod = getMethod(observer, 'next');
@@ -114,30 +126,30 @@ SubscriptionObserver.prototype = redefineAll({}, {
     }
   },
   error: function error(value) {
-    var subscriptionState = getInternalState(getInternalState(this).subscription);
-    if (!subscriptionClosed(subscriptionState)) {
+    var subscriptionState = getSubscriptionObserverInternalState(this).subscriptionState;
+    if (!subscriptionState.isClosed()) {
       var observer = subscriptionState.observer;
-      close(subscriptionState);
+      subscriptionState.close();
       try {
         var errorMethod = getMethod(observer, 'error');
         if (errorMethod) call(errorMethod, observer, value);
         else hostReportErrors(value);
       } catch (err) {
         hostReportErrors(err);
-      } cleanupSubscription(subscriptionState);
+      } subscriptionState.clean();
     }
   },
   complete: function complete() {
-    var subscriptionState = getInternalState(getInternalState(this).subscription);
-    if (!subscriptionClosed(subscriptionState)) {
+    var subscriptionState = getSubscriptionObserverInternalState(this).subscriptionState;
+    if (!subscriptionState.isClosed()) {
       var observer = subscriptionState.observer;
-      close(subscriptionState);
+      subscriptionState.close();
       try {
         var completeMethod = getMethod(observer, 'complete');
         if (completeMethod) call(completeMethod, observer);
       } catch (error) {
         hostReportErrors(error);
-      } cleanupSubscription(subscriptionState);
+      } subscriptionState.clean();
     }
   }
 });
@@ -145,13 +157,16 @@ SubscriptionObserver.prototype = redefineAll({}, {
 if (DESCRIPTORS) defineProperty(SubscriptionObserver.prototype, 'closed', {
   configurable: true,
   get: function () {
-    return subscriptionClosed(getInternalState(getInternalState(this).subscription));
+    return getSubscriptionObserverInternalState(this).subscriptionState.isClosed();
   }
 });
 
 var $Observable = function Observable(subscriber) {
   anInstance(this, ObservablePrototype);
-  setInternalState(this, { subscriber: aCallable(subscriber) });
+  setInternalState(this, {
+    type: OBSERVABLE,
+    subscriber: aCallable(subscriber)
+  });
 };
 
 var ObservablePrototype = $Observable.prototype;
@@ -163,14 +178,14 @@ redefineAll(ObservablePrototype, {
       next: observer,
       error: length > 1 ? arguments[1] : undefined,
       complete: length > 2 ? arguments[2] : undefined
-    } : isObject(observer) ? observer : {}, getInternalState(this).subscriber);
+    } : isObject(observer) ? observer : {}, getObservableInternalState(this).subscriber);
   }
 });
 
 redefineAll($Observable, {
   from: function from(x) {
     var C = isConstructor(this) ? this : $Observable;
-    var observableMethod = getMethod(anObject(x), OBSERVABLE);
+    var observableMethod = getMethod(anObject(x), $$OBSERVABLE);
     if (observableMethod) {
       var observable = anObject(call(observableMethod, x));
       return observable.constructor === C ? observable : new C(function (observer) {
@@ -201,10 +216,10 @@ redefineAll($Observable, {
   }
 });
 
-redefine(ObservablePrototype, OBSERVABLE, function () { return this; });
+redefine(ObservablePrototype, $$OBSERVABLE, function () { return this; });
 
 $({ global: true }, {
   Observable: $Observable
 });
 
-setSpecies('Observable');
+setSpecies(OBSERVABLE);

package/modules/esnext.string.at.js

@@ -2,15 +2,22 @@
 var $ = require('../internals/export');
 var charAt = require('../internals/string-multibyte').charAt;
 var fails = require('../internals/fails');
+var requireObjectCoercible = require('../internals/require-object-coercible');
+var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');
+var toString = require('../internals/to-string');
 
 var FORCED = fails(function () {
-  return '𠮷'.at(0) !== '𠮷';
+  return '𠮷'.at(-2) !== '𠮷';
 });
 
 // `String.prototype.at` method
 // https://github.com/mathiasbynens/String.prototype.at
 $({ target: 'String', proto: true, forced: FORCED }, {
-  at: function at(pos) {
-    return charAt(this, pos);
+  at: function at(index) {
+    var S = toString(requireObjectCoercible(this));
+    var len = S.length;
+    var relativeIndex = toIntegerOrInfinity(index);
+    var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
+    return (k < 0 || k >= len) ? undefined : charAt(S, k);
   }
 });

package/modules/esnext.string.cooked.js

@@ -0,0 +1,30 @@
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var uncurryThis = require('../internals/function-uncurry-this');
+var toIndexedObject = require('../internals/to-indexed-object');
+var toString = require('../internals/to-string');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
+
+var TypeError = global.TypeError;
+var ArrayPrototype = Array.prototype;
+var push = uncurryThis(ArrayPrototype.push);
+var join = uncurryThis(ArrayPrototype.join);
+
+// `String.cooked` method
+// https://github.com/tc39/proposal-string-cooked
+$({ target: 'String', stat: true }, {
+  cooked: function cooked(template /* , ...substitutions */) {
+    var cookedTemplate = toIndexedObject(template);
+    var literalSegments = lengthOfArrayLike(cookedTemplate);
+    var argumentsLength = arguments.length;
+    var elements = [];
+    var i = 0;
+    while (literalSegments > i) {
+      var nextVal = cookedTemplate[i++];
+      if (nextVal === undefined) throw TypeError('Incorrect template');
+      push(elements, toString(nextVal));
+      if (i === literalSegments) return join(elements, '');
+      if (i < argumentsLength) push(elements, toString(arguments[i]));
+    }
+  }
+});

package/modules/esnext.typed-array.to-reversed.js

@@ -0,0 +1 @@
+// empty

package/modules/esnext.typed-array.to-sorted.js

@@ -0,0 +1 @@
+// empty

package/modules/esnext.typed-array.to-spliced.js

@@ -0,0 +1 @@
+// empty

package/modules/esnext.typed-array.with.js

@@ -0,0 +1 @@
+// empty