core-js 3.2.1 → 3.3.0

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);
-  hide(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.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,8 +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)
+    });
+  }
+});

package/modules/esnext.iterator.every.js

@@ -0,0 +1,16 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var iterate = require('../internals/iterate');
+var aFunction = require('../internals/a-function');
+var anObject = require('../internals/an-object');
+
+$({ target: 'Iterator', proto: true, real: true }, {
+  every: function every(fn) {
+    anObject(this);
+    aFunction(fn);
+    return !iterate(this, function (value) {
+      if (!fn(value)) return iterate.stop();
+    }, undefined, false, true).stopped;
+  }
+});

package/modules/esnext.iterator.filter.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 createIteratorProxy = require('../internals/create-iterator-proxy');
+var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');
+
+var IteratorProxy = createIteratorProxy(function (arg) {
+  var iterator = this.iterator;
+  var filterer = this.filterer;
+  var next = this.next;
+  var result, done, value;
+  while (true) {
+    result = anObject(next.call(iterator, arg));
+    done = this.done = !!result.done;
+    if (done) return;
+    value = result.value;
+    if (callWithSafeIterationClosing(iterator, filterer, value)) return value;
+  }
+});
+
+$({ target: 'Iterator', proto: true, real: true }, {
+  filter: function filter(filterer) {
+    return new IteratorProxy({
+      iterator: anObject(this),
+      filterer: aFunction(filterer)
+    });
+  }
+});

package/modules/esnext.iterator.find.js

@@ -0,0 +1,16 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var iterate = require('../internals/iterate');
+var aFunction = require('../internals/a-function');
+var anObject = require('../internals/an-object');
+
+$({ target: 'Iterator', proto: true, real: true }, {
+  find: function find(fn) {
+    anObject(this);
+    aFunction(fn);
+    return iterate(this, function (value) {
+      if (fn(value)) return iterate.stop(value);
+    }, undefined, false, true).result;
+  }
+});

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

@@ -0,0 +1,45 @@
+'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 getIteratorMethod = require('../internals/get-iterator-method');
+var createIteratorProxy = require('../internals/create-iterator-proxy');
+var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');
+
+var IteratorProxy = createIteratorProxy(function (arg) {
+  var iterator = this.iterator;
+  var result, mapped, iteratorMethod, innerIterator;
+
+  while (true) {
+    if (innerIterator = this.innerIterator) {
+      result = anObject(this.innerNext.call(innerIterator));
+      if (!result.done) return result.value;
+      this.innerIterator = this.innerNext = null;
+    }
+
+    result = anObject(this.next.call(iterator, arg));
+
+    if (this.done = !!result.done) return;
+
+    mapped = callWithSafeIterationClosing(iterator, this.mapper, result.value);
+
+    if (isObject(mapped) && (iteratorMethod = getIteratorMethod(mapped)) !== undefined) {
+      this.innerIterator = innerIterator = iteratorMethod.call(mapped);
+      this.innerNext = aFunction(innerIterator.next);
+      continue;
+    } return mapped;
+  }
+});
+
+$({ target: 'Iterator', proto: true, real: true }, {
+  flatMap: function flatMap(mapper) {
+    return new IteratorProxy({
+      iterator: anObject(this),
+      mapper: aFunction(mapper),
+      innerIterator: null,
+      innerNext: null
+    });
+  }
+});