core-js 3.26.0 → 3.27.0

package/internals/set-is-superset-of.js

@@ -0,0 +1,17 @@
+'use strict';
+var aSet = require('../internals/a-set');
+var has = require('../internals/set-helpers').has;
+var size = require('../internals/set-size');
+var getSetRecord = require('../internals/get-set-record');
+var iterateSimple = require('../internals/iterate-simple');
+
+// `Set.prototype.isSupersetOf` method
+// https://tc39.github.io/proposal-set-methods/#Set.prototype.isSupersetOf
+module.exports = function isSupersetOf(other) {
+  var O = aSet(this);
+  var otherRec = getSetRecord(other);
+  if (size(O) < otherRec.size) return false;
+  return iterateSimple(otherRec.getIterator(), function (e) {
+    if (has(O, e) === false) return false;
+  }) !== false;
+};

package/internals/set-iterate.js

@@ -0,0 +1,13 @@
+var uncurryThis = require('../internals/function-uncurry-this');
+var iterateSimple = require('../internals/iterate-simple');
+var SetHelpers = require('../internals/set-helpers');
+
+var Set = SetHelpers.Set;
+var SetPrototype = SetHelpers.proto;
+var forEach = uncurryThis(SetPrototype.forEach);
+var keys = uncurryThis(SetPrototype.keys);
+var next = keys(new Set()).next;
+
+module.exports = function (set, fn, interruptible) {
+  return interruptible ? iterateSimple(keys(set), fn, next) : forEach(set, fn);
+};

package/internals/set-method-accept-set-like.js

@@ -0,0 +1,27 @@
+var getBuiltIn = require('../internals/get-built-in');
+
+var createEmptySetLike = function () {
+  return {
+    size: 0,
+    has: function () {
+      return false;
+    },
+    keys: function () {
+      return {
+        next: function () {
+          return { done: true };
+        }
+      };
+    }
+  };
+};
+
+module.exports = function (name) {
+  try {
+    var Set = getBuiltIn('Set');
+    new Set()[name](createEmptySetLike());
+    return true;
+  } catch (error) {
+    return false;
+  }
+};

package/internals/set-size.js

@@ -0,0 +1,8 @@
+var DESCRIPTORS = require('../internals/descriptors');
+var uncurryThis = require('../internals/function-uncurry-this');
+var SetHelpers = require('../internals/set-helpers');
+
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+module.exports = DESCRIPTORS ? uncurryThis(Object.getOwnPropertyDescriptor(SetHelpers.proto, 'size').get) : function (set) {
+  return set.size;
+};

package/internals/set-symmetric-difference.js

@@ -0,0 +1,23 @@
+'use strict';
+var aSet = require('../internals/a-set');
+var SetHelpers = require('../internals/set-helpers');
+var clone = require('../internals/set-clone');
+var getSetRecord = require('../internals/get-set-record');
+var iterateSimple = require('../internals/iterate-simple');
+
+var add = SetHelpers.add;
+var has = SetHelpers.has;
+var remove = SetHelpers.remove;
+
+// `Set.prototype.symmetricDifference` method
+// https://github.com/tc39/proposal-set-methods
+module.exports = function symmetricDifference(other) {
+  var O = aSet(this);
+  var keysIter = getSetRecord(other).getIterator();
+  var result = clone(O);
+  iterateSimple(keysIter, function (e) {
+    if (has(O, e)) remove(result, e);
+    else add(result, e);
+  });
+  return result;
+};

package/internals/set-union.js

@@ -0,0 +1,18 @@
+'use strict';
+var aSet = require('../internals/a-set');
+var add = require('../internals/set-helpers').add;
+var clone = require('../internals/set-clone');
+var getSetRecord = require('../internals/get-set-record');
+var iterateSimple = require('../internals/iterate-simple');
+
+// `Set.prototype.union` method
+// https://github.com/tc39/proposal-set-methods
+module.exports = function union(other) {
+  var O = aSet(this);
+  var keysIter = getSetRecord(other).getIterator();
+  var result = clone(O);
+  iterateSimple(keysIter, function (it) {
+    add(result, it);
+  });
+  return result;
+};

package/internals/shared.js

@@ -4,9 +4,9 @@ var store = require('../internals/shared-store');
 (module.exports = function (key, value) {
   return store[key] || (store[key] = value !== undefined ? value : {});
 })('versions', []).push({
-  version: '3.26.0',
+  version: '3.27.0',
   mode: IS_PURE ? 'pure' : 'global',
   copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)',
-  license: 'https://github.com/zloirock/core-js/blob/v3.26.0/LICENSE',
+  license: 'https://github.com/zloirock/core-js/blob/v3.27.0/LICENSE',
   source: 'https://github.com/zloirock/core-js'
 });

package/internals/string-cooked.js

@@ -0,0 +1,23 @@
+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 = TypeError;
+var push = uncurryThis([].push);
+var join = uncurryThis([].join);
+
+module.exports = function cooked(template /* , ...substitutions */) {
+  var cookedTemplate = toIndexedObject(template);
+  var literalSegments = lengthOfArrayLike(cookedTemplate);
+  var argumentsLength = arguments.length;
+  var elements = [];
+  var i = 0;
+  while (true) {
+    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/internals/string-parse.js

@@ -0,0 +1,118 @@
+// adapted from https://github.com/jridgewell/string-dedent
+var getBuiltIn = require('../internals/get-built-in');
+var uncurryThis = require('../internals/function-uncurry-this');
+
+var fromCharCode = String.fromCharCode;
+var fromCodePoint = getBuiltIn('String', 'fromCodePoint');
+var charAt = uncurryThis(''.charAt);
+var charCodeAt = uncurryThis(''.charCodeAt);
+var stringIndexOf = uncurryThis(''.indexOf);
+var stringSlice = uncurryThis(''.slice);
+
+var ZERO_CODE = 48;
+var NINE_CODE = 57;
+var LOWER_A_CODE = 97;
+var LOWER_F_CODE = 102;
+var UPPER_A_CODE = 65;
+var UPPER_F_CODE = 70;
+
+var isDigit = function (str, index) {
+  var c = charCodeAt(str, index);
+  return c >= ZERO_CODE && c <= NINE_CODE;
+};
+
+var parseHex = function (str, index, end) {
+  if (end >= str.length) return -1;
+  var n = 0;
+  for (; index < end; index++) {
+    var c = hexToInt(charCodeAt(str, index));
+    if (c === -1) return -1;
+    n = n * 16 + c;
+  }
+  return n;
+};
+
+var hexToInt = function (c) {
+  if (c >= ZERO_CODE && c <= NINE_CODE) return c - ZERO_CODE;
+  if (c >= LOWER_A_CODE && c <= LOWER_F_CODE) return c - LOWER_A_CODE + 10;
+  if (c >= UPPER_A_CODE && c <= UPPER_F_CODE) return c - UPPER_A_CODE + 10;
+  return -1;
+};
+
+module.exports = function (raw) {
+  var out = '';
+  var start = 0;
+  // We need to find every backslash escape sequence, and cook the escape into a real char.
+  var i = 0;
+  var n;
+  while ((i = stringIndexOf(raw, '\\', i)) > -1) {
+    out += stringSlice(raw, start, i);
+    // If the backslash is the last char of the string, then it was an invalid sequence.
+    // This can't actually happen in a tagged template literal, but could happen if you manually
+    // invoked the tag with an array.
+    if (++i === raw.length) return;
+    var next = charAt(raw, i++);
+    switch (next) {
+      // Escaped control codes need to be individually processed.
+      case 'b':
+        out += '\b';
+        break;
+      case 't':
+        out += '\t';
+        break;
+      case 'n':
+        out += '\n';
+        break;
+      case 'v':
+        out += '\v';
+        break;
+      case 'f':
+        out += '\f';
+        break;
+      case 'r':
+        out += '\r';
+        break;
+      // Escaped line terminators just skip the char.
+      case '\r':
+        // Treat `\r\n` as a single terminator.
+        if (i < raw.length && charAt(raw, i) === '\n') ++i;
+      // break omitted
+      case '\n':
+      case '\u2028':
+      case '\u2029':
+        break;
+      // `\0` is a null control char, but `\0` followed by another digit is an illegal octal escape.
+      case '0':
+        if (isDigit(raw, i)) return;
+        out += '\0';
+        break;
+      // Hex escapes must contain 2 hex chars.
+      case 'x':
+        n = parseHex(raw, i, i + 2);
+        if (n === -1) return;
+        i += 2;
+        out += fromCharCode(n);
+        break;
+      // Unicode escapes contain either 4 chars, or an unlimited number between `{` and `}`.
+      // The hex value must not overflow 0x10FFFF.
+      case 'u':
+        if (i < raw.length && charAt(raw, i) === '{') {
+          var end = stringIndexOf(raw, '}', ++i);
+          if (end === -1) return;
+          n = parseHex(raw, i, end);
+          i = end + 1;
+        } else {
+          n = parseHex(raw, i, i + 4);
+          i += 4;
+        }
+        if (n === -1 || n > 0x10FFFF) return;
+        out += fromCodePoint(n);
+        break;
+      default:
+        if (isDigit(next, 0)) return;
+        out += next;
+    }
+    start = i;
+  }
+  return out + stringSlice(raw, start);
+};

package/internals/to-set-like.js

@@ -0,0 +1,19 @@
+var getBuiltIn = require('../internals/get-built-in');
+var isCallable = require('../internals/is-callable');
+var isIterable = require('../internals/is-iterable');
+var isObject = require('../internals/is-object');
+
+var Set = getBuiltIn('Set');
+
+var isSetLike = function (it) {
+  return isObject(it)
+    && typeof it.size == 'number'
+    && isCallable(it.has)
+    && isCallable(it.keys);
+};
+
+// fallback old -> new set methods proposal arguments
+module.exports = function (it) {
+  if (isSetLike(it)) return it;
+  if (isIterable(it)) return new Set(it);
+};

package/internals/weak-map-helpers.js

@@ -0,0 +1,13 @@
+var uncurryThis = require('../internals/function-uncurry-this');
+
+// eslint-disable-next-line es/no-weak-map -- safe
+var WeakMapPrototype = WeakMap.prototype;
+
+module.exports = {
+  // eslint-disable-next-line es/no-weak-map -- safe
+  WeakMap: WeakMap,
+  set: uncurryThis(WeakMapPrototype.set),
+  get: uncurryThis(WeakMapPrototype.get),
+  has: uncurryThis(WeakMapPrototype.has),
+  remove: uncurryThis(WeakMapPrototype['delete'])
+};

package/internals/weak-set-helpers.js

@@ -0,0 +1,12 @@
+var uncurryThis = require('../internals/function-uncurry-this');
+
+// eslint-disable-next-line es/no-weak-set -- safe
+var WeakSetPrototype = WeakSet.prototype;
+
+module.exports = {
+  // eslint-disable-next-line es/no-weak-set -- safe
+  WeakSet: WeakSet,
+  add: uncurryThis(WeakSetPrototype.add),
+  has: uncurryThis(WeakSetPrototype.has),
+  remove: uncurryThis(WeakSetPrototype['delete'])
+};

package/modules/es.array-buffer.slice.js

@@ -1,6 +1,6 @@
 'use strict';
 var $ = require('../internals/export');
-var uncurryThis = require('../internals/function-uncurry-this');
+var uncurryThis = require('../internals/function-uncurry-this-clause');
 var fails = require('../internals/fails');
 var ArrayBufferModule = require('../internals/array-buffer');
 var anObject = require('../internals/an-object');

package/modules/es.array.index-of.js

@@ -1,7 +1,7 @@
 'use strict';
 /* eslint-disable es/no-array-prototype-indexof -- required for testing */
 var $ = require('../internals/export');
-var uncurryThis = require('../internals/function-uncurry-this');
+var uncurryThis = require('../internals/function-uncurry-this-clause');
 var $indexOf = require('../internals/array-includes').indexOf;
 var arrayMethodIsStrict = require('../internals/array-method-is-strict');
 

package/modules/es.number.constructor.js

@@ -1,9 +1,11 @@
 'use strict';
+var $ = require('../internals/export');
+var IS_PURE = require('../internals/is-pure');
 var DESCRIPTORS = require('../internals/descriptors');
 var global = require('../internals/global');
+var path = require('../internals/path');
 var uncurryThis = require('../internals/function-uncurry-this');
 var isForced = require('../internals/is-forced');
-var defineBuiltIn = require('../internals/define-built-in');
 var hasOwn = require('../internals/has-own-property');
 var inheritIfRequired = require('../internals/inherit-if-required');
 var isPrototypeOf = require('../internals/object-is-prototype-of');
@@ -18,9 +20,10 @@ var trim = require('../internals/string-trim').trim;
 
 var NUMBER = 'Number';
 var NativeNumber = global[NUMBER];
+var PureNumberNamespace = path[NUMBER];
 var NumberPrototype = NativeNumber.prototype;
 var TypeError = global.TypeError;
-var arraySlice = uncurryThis(''.slice);
+var stringSlice = uncurryThis(''.slice);
 var charCodeAt = uncurryThis(''.charCodeAt);
 
 // `ToNumeric` abstract operation
@@ -48,7 +51,7 @@ var toNumber = function (argument) {
         case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i
         default: return +it;
       }
-      digits = arraySlice(it, 2);
+      digits = stringSlice(it, 2);
       length = digits.length;
       for (index = 0; index < length; index++) {
         code = charCodeAt(digits, index);
@@ -60,17 +63,30 @@ var toNumber = function (argument) {
   } return +it;
 };
 
+var FORCED = isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'));
+
+var calledWithNew = function (dummy) {
+  // includes check on 1..constructor(foo) case
+  return isPrototypeOf(NumberPrototype, dummy) && fails(function () { thisNumberValue(dummy); });
+};
+
 // `Number` constructor
 // https://tc39.es/ecma262/#sec-number-constructor
-if (isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) {
-  var NumberWrapper = function Number(value) {
-    var n = arguments.length < 1 ? 0 : NativeNumber(toNumeric(value));
-    var dummy = this;
-    // check on 1..constructor(foo) case
-    return isPrototypeOf(NumberPrototype, dummy) && fails(function () { thisNumberValue(dummy); })
-      ? inheritIfRequired(Object(n), dummy, NumberWrapper) : n;
-  };
-  for (var keys = DESCRIPTORS ? getOwnPropertyNames(NativeNumber) : (
+var NumberWrapper = function Number(value) {
+  var n = arguments.length < 1 ? 0 : NativeNumber(toNumeric(value));
+  return calledWithNew(this) ? inheritIfRequired(Object(n), this, NumberWrapper) : n;
+};
+
+NumberWrapper.prototype = NumberPrototype;
+if (FORCED && !IS_PURE) NumberPrototype.constructor = NumberWrapper;
+
+$({ global: true, constructor: true, wrap: true, forced: FORCED }, {
+  Number: NumberWrapper
+});
+
+// Use `internal/copy-constructor-properties` helper in `core-js@4`
+var copyConstructorProperties = function (target, source) {
+  for (var keys = DESCRIPTORS ? getOwnPropertyNames(source) : (
     // ES3:
     'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
     // ES2015 (in case, if modules with ES2015 Number statics required before):
@@ -78,11 +94,11 @@ if (isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumb
     // ESNext
     'fromString,range'
   ).split(','), j = 0, key; keys.length > j; j++) {
-    if (hasOwn(NativeNumber, key = keys[j]) && !hasOwn(NumberWrapper, key)) {
-      defineProperty(NumberWrapper, key, getOwnPropertyDescriptor(NativeNumber, key));
+    if (hasOwn(source, key = keys[j]) && !hasOwn(target, key)) {
+      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
     }
   }
-  NumberWrapper.prototype = NumberPrototype;
-  NumberPrototype.constructor = NumberWrapper;
-  defineBuiltIn(global, NUMBER, NumberWrapper, { constructor: true });
-}
+};
+
+if (IS_PURE && PureNumberNamespace) copyConstructorProperties(path[NUMBER], PureNumberNamespace);
+if (FORCED || IS_PURE) copyConstructorProperties(path[NUMBER], NativeNumber);

package/modules/es.string.ends-with.js

@@ -1,6 +1,6 @@
 'use strict';
 var $ = require('../internals/export');
-var uncurryThis = require('../internals/function-uncurry-this');
+var uncurryThis = require('../internals/function-uncurry-this-clause');
 var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
 var toLength = require('../internals/to-length');
 var toString = require('../internals/to-string');

package/modules/es.string.match-all.js

@@ -2,7 +2,7 @@
 /* eslint-disable es/no-string-prototype-matchall -- safe */
 var $ = require('../internals/export');
 var call = require('../internals/function-call');
-var uncurryThis = require('../internals/function-uncurry-this');
+var uncurryThis = require('../internals/function-uncurry-this-clause');
 var createIteratorConstructor = require('../internals/iterator-create-constructor');
 var createIterResultObject = require('../internals/create-iter-result-object');
 var requireObjectCoercible = require('../internals/require-object-coercible');

package/modules/es.string.starts-with.js

@@ -1,6 +1,6 @@
 'use strict';
 var $ = require('../internals/export');
-var uncurryThis = require('../internals/function-uncurry-this');
+var uncurryThis = require('../internals/function-uncurry-this-clause');
 var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
 var toLength = require('../internals/to-length');
 var toString = require('../internals/to-string');

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

@@ -1,6 +1,6 @@
 'use strict';
 var global = require('../internals/global');
-var uncurryThis = require('../internals/function-uncurry-this');
+var uncurryThis = require('../internals/function-uncurry-this-clause');
 var fails = require('../internals/fails');
 var aCallable = require('../internals/a-callable');
 var internalSort = require('../internals/array-sort');

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

@@ -3,6 +3,6 @@ var fromAsync = require('../internals/array-from-async');
 
 // `Array.fromAsync` method
 // https://github.com/tc39/proposal-array-from-async
-$({ target: 'Array', stat: true, forced: true }, {
+$({ target: 'Array', stat: true }, {
   fromAsync: fromAsync
 });

package/modules/esnext.async-disposable-stack.constructor.js

@@ -0,0 +1,137 @@
+'use strict';
+// https://github.com/tc39/proposal-async-explicit-resource-management
+var $ = require('../internals/export');
+var DESCRIPTORS = require('../internals/descriptors');
+var getBuiltIn = require('../internals/get-built-in');
+var aCallable = require('../internals/a-callable');
+var anObject = require('../internals/an-object');
+var anInstance = require('../internals/an-instance');
+var isNullOrUndefined = require('../internals/is-null-or-undefined');
+var defineBuiltIn = require('../internals/define-built-in');
+var defineBuiltIns = require('../internals/define-built-ins');
+var defineBuiltInAccessor = require('../internals/define-built-in-accessor');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var InternalStateModule = require('../internals/internal-state');
+var DisposableStackHelpers = require('../internals/disposable-stack-helpers');
+
+var Promise = getBuiltIn('Promise');
+var SuppressedError = getBuiltIn('SuppressedError');
+var $ReferenceError = ReferenceError;
+
+var ASYNC_DISPOSE = wellKnownSymbol('asyncDispose');
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+
+var getDisposeMethod = DisposableStackHelpers.getDisposeMethod;
+var addDisposableResource = DisposableStackHelpers.addDisposableResource;
+
+var ASYNC_DISPOSABLE_STACK = 'AsyncDisposableStack';
+var setInternalState = InternalStateModule.set;
+var getAsyncDisposableStackInternalState = InternalStateModule.getterFor(ASYNC_DISPOSABLE_STACK);
+
+var HINT = 'async-dispose';
+var DISPOSED = 'disposed';
+var PENDING = 'pending';
+
+var ALREADY_DISPOSED = ASYNC_DISPOSABLE_STACK + ' already disposed';
+
+var $AsyncDisposableStack = function AsyncDisposableStack() {
+  setInternalState(anInstance(this, AsyncDisposableStackPrototype), {
+    type: ASYNC_DISPOSABLE_STACK,
+    state: PENDING,
+    stack: []
+  });
+
+  if (!DESCRIPTORS) this.disposed = false;
+};
+
+var AsyncDisposableStackPrototype = $AsyncDisposableStack.prototype;
+
+defineBuiltIns(AsyncDisposableStackPrototype, {
+  disposeAsync: function disposeAsync() {
+    var asyncDisposableStack = this;
+    return new Promise(function (resolve, reject) {
+      var internalState = getAsyncDisposableStackInternalState(asyncDisposableStack);
+      if (internalState.state == DISPOSED) return resolve(undefined);
+      internalState.state = DISPOSED;
+      if (!DESCRIPTORS) asyncDisposableStack.disposed = true;
+      var stack = internalState.stack;
+      var i = stack.length;
+      var thrown = false;
+      var suppressed;
+
+      var handleError = function (result) {
+        if (thrown) {
+          suppressed = new SuppressedError(result, suppressed);
+        } else {
+          thrown = true;
+          suppressed = result;
+        }
+
+        loop();
+      };
+
+      var loop = function () {
+        if (i) {
+          var disposeMethod = stack[--i];
+          stack[i] = null;
+          try {
+            Promise.resolve(disposeMethod()).then(loop, handleError);
+          } catch (error) {
+            handleError(error);
+          }
+        } else {
+          internalState.stack = null;
+          thrown ? reject(suppressed) : resolve(undefined);
+        }
+      };
+
+      loop();
+    });
+  },
+  use: function use(value) {
+    var internalState = getAsyncDisposableStackInternalState(this);
+    if (internalState.state == DISPOSED) throw $ReferenceError(ALREADY_DISPOSED);
+    if (!isNullOrUndefined(value)) {
+      anObject(value);
+      var method = aCallable(getDisposeMethod(value, HINT));
+      addDisposableResource(internalState, value, HINT, method);
+    } return value;
+  },
+  adopt: function adopt(value, onDispose) {
+    var internalState = getAsyncDisposableStackInternalState(this);
+    if (internalState.state == DISPOSED) throw $ReferenceError(ALREADY_DISPOSED);
+    aCallable(onDispose);
+    addDisposableResource(internalState, undefined, HINT, function () {
+      onDispose(value);
+    });
+    return value;
+  },
+  defer: function defer(onDispose) {
+    var internalState = getAsyncDisposableStackInternalState(this);
+    if (internalState.state == DISPOSED) throw $ReferenceError(ALREADY_DISPOSED);
+    aCallable(onDispose);
+    addDisposableResource(internalState, undefined, HINT, onDispose);
+  },
+  move: function move() {
+    var internalState = getAsyncDisposableStackInternalState(this);
+    if (internalState.state == DISPOSED) throw $ReferenceError(ALREADY_DISPOSED);
+    var newAsyncDisposableStack = new $AsyncDisposableStack();
+    getAsyncDisposableStackInternalState(newAsyncDisposableStack).stack = internalState.stack;
+    internalState.stack = [];
+    return newAsyncDisposableStack;
+  }
+});
+
+if (DESCRIPTORS) defineBuiltInAccessor(AsyncDisposableStackPrototype, 'disposed', {
+  configurable: true,
+  get: function disposed() {
+    return getAsyncDisposableStackInternalState(this).state == DISPOSED;
+  }
+});
+
+defineBuiltIn(AsyncDisposableStackPrototype, ASYNC_DISPOSE, AsyncDisposableStackPrototype.disposeAsync, { name: 'disposeAsync' });
+defineBuiltIn(AsyncDisposableStackPrototype, TO_STRING_TAG, ASYNC_DISPOSABLE_STACK, { nonWritable: true });
+
+$({ global: true, constructor: true, forced: true }, {
+  AsyncDisposableStack: $AsyncDisposableStack
+});

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

@@ -1,8 +1,9 @@
 // TODO: Remove from `core-js@4`
-// https://github.com/tc39/proposal-iterator-helpers
 var $ = require('../internals/export');
 var indexed = require('../internals/async-iterator-indexed');
 
+// `AsyncIterator.prototype.asIndexedPairs` method
+// https://github.com/tc39/proposal-iterator-helpers
 $({ target: 'AsyncIterator', name: 'indexed', proto: true, real: true, forced: true }, {
   asIndexedPairs: indexed
 });

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

@@ -0,0 +1,26 @@
+'use strict';
+// https://github.com/tc39/proposal-async-explicit-resource-management
+var call = require('../internals/function-call');
+var defineBuiltIn = require('../internals/define-built-in');
+var getBuiltIn = require('../internals/get-built-in');
+var getMethod = require('../internals/get-method');
+var hasOwn = require('../internals/has-own-property');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var AsyncIteratorPrototype = require('../internals/async-iterator-prototype');
+
+var ASYNC_DISPOSE = wellKnownSymbol('asyncDispose');
+var Promise = getBuiltIn('Promise');
+
+if (!hasOwn(AsyncIteratorPrototype, ASYNC_DISPOSE)) {
+  defineBuiltIn(AsyncIteratorPrototype, ASYNC_DISPOSE, function () {
+    var O = this;
+    return new Promise(function (resolve, reject) {
+      var $return = getMethod(O, 'return');
+      if ($return) {
+        Promise.resolve(call($return, O)).then(function () {
+          resolve(undefined);
+        }, reject);
+      } else resolve(undefined);
+    });
+  });
+}