core-js 3.1.3 → 3.3.0

package/modules/es.typed-array.sort.js

@@ -2,10 +2,10 @@
 var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
 
 var aTypedArray = ArrayBufferViewCore.aTypedArray;
-var arraySort = [].sort;
+var $sort = [].sort;
 
 // `%TypedArray%.prototype.sort` method
 // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.sort
 ArrayBufferViewCore.exportProto('sort', function sort(comparefn) {
-  return arraySort.call(aTypedArray(this), comparefn);
+  return $sort.call(aTypedArray(this), comparefn);
 });

package/modules/es.typed-array.subarray.js

@@ -1,8 +1,8 @@
 'use strict';
+var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
 var toLength = require('../internals/to-length');
 var toAbsoluteIndex = require('../internals/to-absolute-index');
 var speciesConstructor = require('../internals/species-constructor');
-var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
 
 var aTypedArray = ArrayBufferViewCore.aTypedArray;
 

package/modules/es.typed-array.to-locale-string.js

@@ -1,17 +1,18 @@
 'use strict';
 var global = require('../internals/global');
-var fails = require('../internals/fails');
 var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
+var fails = require('../internals/fails');
 
 var Int8Array = global.Int8Array;
 var aTypedArray = ArrayBufferViewCore.aTypedArray;
-var arrayToLocaleString = [].toLocaleString;
-var arraySlice = [].slice;
+var $toLocaleString = [].toLocaleString;
+var $slice = [].slice;
 
 // iOS Safari 6.x fails here
-var TO_LOCALE_BUG = !!Int8Array && fails(function () {
-  arrayToLocaleString.call(new Int8Array(1));
+var TO_LOCALE_STRING_BUG = !!Int8Array && fails(function () {
+  $toLocaleString.call(new Int8Array(1));
 });
+
 var FORCED = fails(function () {
   return [1, 2].toLocaleString() != new Int8Array([1, 2]).toLocaleString();
 }) || !fails(function () {
@@ -21,5 +22,5 @@ var FORCED = fails(function () {
 // `%TypedArray%.prototype.toLocaleString` method
 // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tolocalestring
 ArrayBufferViewCore.exportProto('toLocaleString', function toLocaleString() {
-  return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(aTypedArray(this)) : aTypedArray(this), arguments);
+  return $toLocaleString.apply(TO_LOCALE_STRING_BUG ? $slice.call(aTypedArray(this)) : aTypedArray(this), arguments);
 }, FORCED);

package/modules/es.weak-map.js

@@ -14,7 +14,7 @@ var InternalWeakMap;
 
 var wrapper = function (get) {
   return function WeakMap() {
-    return get(this, arguments.length > 0 ? arguments[0] : undefined);
+    return get(this, arguments.length ? arguments[0] : undefined);
   };
 };
 

package/modules/es.weak-set.js

@@ -5,5 +5,5 @@ var collectionWeak = require('../internals/collection-weak');
 // `WeakSet` constructor
 // https://tc39.github.io/ecma262/#sec-weakset-constructor
 collection('WeakSet', function (get) {
-  return function WeakSet() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
+  return function WeakSet() { return get(this, arguments.length ? arguments[0] : undefined); };
 }, collectionWeak, false, true);

package/modules/esnext.aggregate-error.js

@@ -1,10 +1,18 @@
+'use strict';
 var $ = require('../internals/export');
+var DESCRIPTORS = require('../internals/descriptors');
 var getPrototypeOf = require('../internals/object-get-prototype-of');
 var setPrototypeOf = require('../internals/object-set-prototype-of');
 var create = require('../internals/object-create');
+var defineProperty = require('../internals/object-define-property');
 var createPropertyDescriptor = require('../internals/create-property-descriptor');
 var iterate = require('../internals/iterate');
-var hide = require('../internals/hide');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var anObject = require('../internals/an-object');
+var InternalStateModule = require('../internals/internal-state');
+
+var setInternalState = InternalStateModule.set;
+var getInternalAggregateErrorState = InternalStateModule.getterFor('AggregateError');
 
 var $AggregateError = function AggregateError(errors, message) {
   var that = this;
@@ -14,14 +22,30 @@ var $AggregateError = function AggregateError(errors, message) {
   }
   var errorsArray = [];
   iterate(errors, errorsArray.push, errorsArray);
-  that.errors = errorsArray;
-  if (message !== undefined) hide(that, 'message', String(message));
+  if (DESCRIPTORS) setInternalState(that, { errors: errorsArray, type: 'AggregateError' });
+  else that.errors = errorsArray;
+  if (message !== undefined) createNonEnumerableProperty(that, 'message', String(message));
   return that;
 };
 
 $AggregateError.prototype = create(Error.prototype, {
   constructor: createPropertyDescriptor(5, $AggregateError),
-  name: createPropertyDescriptor(5, 'AggregateError')
+  message: createPropertyDescriptor(5, ''),
+  name: createPropertyDescriptor(5, 'AggregateError'),
+  toString: createPropertyDescriptor(5, function toString() {
+    var name = anObject(this).name;
+    name = name === undefined ? 'AggregateError' : String(name);
+    var message = this.message;
+    message = message === undefined ? '' : String(message);
+    return name + ': ' + message;
+  })
+});
+
+if (DESCRIPTORS) defineProperty.f($AggregateError.prototype, 'errors', {
+  get: function () {
+    return getInternalAggregateErrorState(this).errors;
+  },
+  configurable: true
 });
 
 $({ global: true }, {

package/modules/esnext.array.is-template-object.js

@@ -0,0 +1,28 @@
+var $ = require('../internals/export');
+var isArray = require('../internals/is-array');
+
+var isFrozen = Object.isFrozen;
+
+var isFrozenStringArray = function (array, allowUndefined) {
+  if (!isFrozen || !isArray(array) || !isFrozen(array)) return false;
+  var index = 0;
+  var length = array.length;
+  var element;
+  while (index < length) {
+    element = array[index++];
+    if (!(typeof element === 'string' || (allowUndefined && typeof element === 'undefined'))) {
+      return false;
+    }
+  } return length !== 0;
+};
+
+// `Array.isTemplateObject` method
+// https://github.com/tc39/proposal-array-is-template-object
+$({ target: 'Array', stat: true }, {
+  isTemplateObject: function isTemplateObject(value) {
+    if (!isFrozenStringArray(value, true)) return false;
+    var raw = value.raw;
+    if (raw.length !== value.length || !isFrozenStringArray(raw, false)) return false;
+    return true;
+  }
+});

package/modules/esnext.async-iterator.as-indexed-pairs.js

@@ -0,0 +1,27 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var anObject = require('../internals/an-object');
+var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg, Promise) {
+  var state = this;
+  var iterator = state.iterator;
+
+  return Promise.resolve(anObject(state.next.call(iterator, arg))).then(function (step) {
+    if (anObject(step).done) {
+      state.done = true;
+      return { done: true, value: undefined };
+    }
+    return { done: false, value: [state.index++, step.value] };
+  });
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  asIndexedPairs: function asIndexedPairs() {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      index: 0
+    });
+  }
+});

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

@@ -0,0 +1,25 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var anInstance = require('../internals/an-instance');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var has = require('../internals/has');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var AsyncIteratorPrototype = require('../internals/async-iterator-prototype');
+var IS_PURE = require('../internals/is-pure');
+
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+
+var AsyncIteratorConstructor = function AsyncIterator() {
+  anInstance(this, AsyncIteratorConstructor);
+};
+
+AsyncIteratorConstructor.prototype = AsyncIteratorPrototype;
+
+if (!has(AsyncIteratorPrototype, TO_STRING_TAG)) {
+  createNonEnumerableProperty(AsyncIteratorPrototype, TO_STRING_TAG, 'AsyncIterator');
+}
+
+$({ global: true, forced: IS_PURE }, {
+  AsyncIterator: AsyncIteratorConstructor
+});

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

@@ -0,0 +1,41 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var anObject = require('../internals/an-object');
+var toPositiveInteger = require('../internals/to-positive-integer');
+var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg, Promise) {
+  var state = this;
+
+  return new Promise(function (resolve, reject) {
+    var loop = function () {
+      try {
+        Promise.resolve(
+          anObject(state.next.call(state.iterator, state.remaining ? undefined : arg))
+        ).then(function (step) {
+          try {
+            if (anObject(step).done) {
+              state.done = true;
+              resolve({ done: true, value: undefined });
+            } else if (state.remaining) {
+              state.remaining--;
+              loop();
+            } else resolve({ done: false, value: step.value });
+          } catch (err) { reject(err); }
+        }, reject);
+      } catch (error) { reject(error); }
+    };
+
+    loop();
+  });
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  drop: function drop(limit) {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      remaining: toPositiveInteger(limit)
+    });
+  }
+});

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

@@ -0,0 +1,10 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var $every = require('../internals/async-iterator-iteration').every;
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  every: function every(fn) {
+    return $every(this, fn);
+  }
+});

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

@@ -0,0 +1,42 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var aFunction = require('../internals/a-function');
+var anObject = require('../internals/an-object');
+var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg, Promise) {
+  var state = this;
+  var filterer = state.filterer;
+
+  return new Promise(function (resolve, reject) {
+    var loop = function () {
+      try {
+        Promise.resolve(anObject(state.next.call(state.iterator, arg))).then(function (step) {
+          try {
+            if (anObject(step).done) {
+              state.done = true;
+              resolve({ done: true, value: undefined });
+            } else {
+              var value = step.value;
+              Promise.resolve(filterer(value)).then(function (selected) {
+                selected ? resolve({ done: false, value: value }) : loop();
+              }, reject);
+            }
+          } catch (err) { reject(err); }
+        }, reject);
+      } catch (error) { reject(error); }
+    };
+
+    loop();
+  });
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  filter: function filter(filterer) {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      filterer: aFunction(filterer)
+    });
+  }
+});

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

@@ -0,0 +1,10 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var $find = require('../internals/async-iterator-iteration').find;
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  find: function find(fn) {
+    return $find(this, fn);
+  }
+});

package/modules/esnext.async-iterator.flat-map.js

@@ -0,0 +1,67 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var aFunction = require('../internals/a-function');
+var anObject = require('../internals/an-object');
+var isObject = require('../internals/is-object');
+var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
+var getAsyncIteratorMethod = require('../internals/get-async-iterator-method');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg, Promise) {
+  var state = this;
+  var mapper = state.mapper;
+  var innerIterator, iteratorMethod;
+
+  return new Promise(function (resolve, reject) {
+    var outerLoop = function () {
+      try {
+        Promise.resolve(anObject(state.next.call(state.iterator, arg))).then(function (step) {
+          try {
+            if (anObject(step).done) {
+              state.done = true;
+              resolve({ done: true, value: undefined });
+            } else {
+              Promise.resolve(mapper(step.value)).then(function (mapped) {
+                try {
+                  if (isObject(mapped) && (iteratorMethod = getAsyncIteratorMethod(mapped)) !== undefined) {
+                    state.innerIterator = innerIterator = iteratorMethod.call(mapped);
+                    state.innerNext = aFunction(innerIterator.next);
+                    return innerLoop();
+                  } resolve({ done: false, value: mapped });
+                } catch (error2) { reject(error2); }
+              }, reject);
+            }
+          } catch (error1) { reject(error1); }
+        }, reject);
+      } catch (error) { reject(error); }
+    };
+
+    var innerLoop = function () {
+      if (innerIterator = state.innerIterator) {
+        try {
+          Promise.resolve(anObject(state.innerNext.call(innerIterator))).then(function (result) {
+            try {
+              if (anObject(result).done) {
+                state.innerIterator = state.innerNext = null;
+                outerLoop();
+              } else resolve({ done: false, value: result.value });
+            } catch (error1) { reject(error1); }
+          }, reject);
+        } catch (error) { reject(error); }
+      } else outerLoop();
+    };
+
+    innerLoop();
+  });
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  flatMap: function flatMap(mapper) {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      mapper: aFunction(mapper),
+      innerIterator: null,
+      innerNext: null
+    });
+  }
+});

package/modules/esnext.async-iterator.for-each.js

@@ -0,0 +1,10 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var $forEach = require('../internals/async-iterator-iteration').forEach;
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  forEach: function forEach(fn) {
+    return $forEach(this, fn);
+  }
+});

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

@@ -0,0 +1,30 @@
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var path = require('../internals/path');
+var aFunction = require('../internals/a-function');
+var anObject = require('../internals/an-object');
+var toObject = require('../internals/to-object');
+var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
+var getAsyncIteratorMethod = require('../internals/get-async-iterator-method');
+
+var AsyncIterator = path.AsyncIterator;
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg) {
+  return anObject(this.next.call(this.iterator, arg));
+}, true);
+
+$({ target: 'AsyncIterator', stat: true }, {
+  from: function from(O) {
+    var object = toObject(O);
+    var usingIterator = getAsyncIteratorMethod(object);
+    var iterator;
+    if (usingIterator != null) {
+      iterator = aFunction(usingIterator).call(object);
+      if (iterator instanceof AsyncIterator) return iterator;
+    } else {
+      iterator = object;
+    } return new AsyncIteratorProxy({
+      iterator: iterator
+    });
+  }
+});

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

@@ -0,0 +1,30 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var aFunction = require('../internals/a-function');
+var anObject = require('../internals/an-object');
+var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg, Promise) {
+  var state = this;
+  var mapper = state.mapper;
+
+  return Promise.resolve(anObject(state.next.call(state.iterator, arg))).then(function (step) {
+    if (anObject(step).done) {
+      state.done = true;
+      return { done: true, value: undefined };
+    }
+    return Promise.resolve(mapper(step.value)).then(function (value) {
+      return { done: false, value: value };
+    });
+  });
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  map: function map(mapper) {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      mapper: aFunction(mapper)
+    });
+  }
+});

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

@@ -0,0 +1,46 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var aFunction = require('../internals/a-function');
+var anObject = require('../internals/an-object');
+var getBuiltIn = require('../internals/get-built-in');
+
+var Promise = getBuiltIn('Promise');
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  reduce: function reduce(reducer /* , initialValue */) {
+    var iterator = anObject(this);
+    var next = aFunction(iterator.next);
+    var noInitial = arguments.length < 2;
+    var accumulator = noInitial ? undefined : arguments[1];
+    aFunction(reducer);
+
+    return new Promise(function (resolve, reject) {
+      var loop = function () {
+        try {
+          Promise.resolve(anObject(next.call(iterator))).then(function (step) {
+            try {
+              if (anObject(step).done) {
+                noInitial ? reject(TypeError('Reduce of empty iterator with no initial value')) : resolve(accumulator);
+              } else {
+                var value = step.value;
+                if (noInitial) {
+                  noInitial = false;
+                  accumulator = value;
+                  loop();
+                } else {
+                  Promise.resolve(reducer(accumulator, value)).then(function (result) {
+                    accumulator = result;
+                    loop();
+                  }, reject);
+                }
+              }
+            } catch (err) { reject(err); }
+          }, reject);
+        } catch (error) { reject(error); }
+      };
+
+      loop();
+    });
+  }
+});

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

@@ -0,0 +1,10 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var $some = require('../internals/async-iterator-iteration').some;
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  some: function some(fn) {
+    return $some(this, fn);
+  }
+});

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

@@ -0,0 +1,22 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var anObject = require('../internals/an-object');
+var toPositiveInteger = require('../internals/to-positive-integer');
+var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg) {
+  if (!this.remaining--) {
+    this.done = true;
+    return { done: true, value: undefined };
+  } return this.next.call(this.iterator, arg);
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true }, {
+  take: function take(limit) {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      remaining: toPositiveInteger(limit)
+    });
+  }
+});

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

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

package/modules/esnext.global-this.js

@@ -1,6 +1,2 @@
-var $ = require('../internals/export');
-var global = require('../internals/global');
-
-// `globalThis` object
-// https://github.com/tc39/proposal-global
-$({ global: true }, { globalThis: global });
+// TODO: Remove from `core-js@4`
+require('./es.global-this');

package/modules/esnext.iterator.as-indexed-pairs.js

@@ -0,0 +1,20 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var anObject = require('../internals/an-object');
+var createIteratorProxy = require('../internals/create-iterator-proxy');
+
+var IteratorProxy = createIteratorProxy(function (arg) {
+  var result = anObject(this.next.call(this.iterator, arg));
+  var done = this.done = !!result.done;
+  if (!done) return [this.index++, result.value];
+});
+
+$({ target: 'Iterator', proto: true, real: true }, {
+  asIndexedPairs: function asIndexedPairs() {
+    return new IteratorProxy({
+      iterator: anObject(this),
+      index: 0
+    });
+  }
+});

package/modules/esnext.iterator.constructor.js

@@ -0,0 +1,39 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var anInstance = require('../internals/an-instance');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var has = require('../internals/has');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;
+var IS_PURE = require('../internals/is-pure');
+
+var ITERATOR = wellKnownSymbol('iterator');
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+
+var NativeIterator = global.Iterator;
+
+// FF56- have non-standard global helper `Iterator`
+var FORCED = IS_PURE || typeof NativeIterator != 'function' || NativeIterator.prototype !== IteratorPrototype;
+
+var IteratorConstructor = function Iterator() {
+  anInstance(this, IteratorConstructor);
+};
+
+if (IS_PURE) {
+  IteratorPrototype = {};
+  createNonEnumerableProperty(IteratorPrototype, ITERATOR, function () {
+    return this;
+  });
+}
+
+if (!has(IteratorPrototype, TO_STRING_TAG)) {
+  createNonEnumerableProperty(IteratorPrototype, TO_STRING_TAG, 'Iterator');
+}
+
+IteratorConstructor.prototype = IteratorPrototype;
+
+$({ global: true, forced: FORCED }, {
+  Iterator: IteratorConstructor
+});

package/modules/esnext.iterator.drop.js

@@ -0,0 +1,30 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var anObject = require('../internals/an-object');
+var toPositiveInteger = require('../internals/to-positive-integer');
+var createIteratorProxy = require('../internals/create-iterator-proxy');
+
+var IteratorProxy = createIteratorProxy(function (arg) {
+  var iterator = this.iterator;
+  var next = this.next;
+  var result, done;
+  while (this.remaining) {
+    this.remaining--;
+    result = anObject(next.call(iterator));
+    done = this.done = !!result.done;
+    if (done) return;
+  }
+  result = anObject(next.call(iterator, arg));
+  done = this.done = !!result.done;
+  if (!done) return result.value;
+});
+
+$({ target: 'Iterator', proto: true, real: true }, {
+  drop: function drop(limit) {
+    return new IteratorProxy({
+      iterator: anObject(this),
+      remaining: toPositiveInteger(limit)
+    });
+  }
+});