tor-browser

Array.js (34402B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/* ES5 15.4.4.16. */
function ArrayEvery(callbackfn /*, thisArg*/) {
 /* Step 1. */
 var O = ToObject(this);

 /* Steps 2-3. */
 var len = ToLength(O.length);

 /* Step 4. */
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.every");
 }
 if (!IsCallable(callbackfn)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, callbackfn));
 }

 /* Step 5. */
 var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;

 /* Steps 6-7. */
 /* Steps a (implicit), and d. */
 for (var k = 0; k < len; k++) {
   /* Step b */
   if (k in O) {
     /* Step c. */
     if (!callContentFunction(callbackfn, T, O[k], k, O)) {
       return false;
     }
   }
 }

 /* Step 8. */
 return true;
}
// Inlining this enables inlining of the callback function.
SetIsInlinableLargeFunction(ArrayEvery);

/* ES5 15.4.4.17. */
function ArraySome(callbackfn /*, thisArg*/) {
 /* Step 1. */
 var O = ToObject(this);

 /* Steps 2-3. */
 var len = ToLength(O.length);

 /* Step 4. */
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.some");
 }
 if (!IsCallable(callbackfn)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, callbackfn));
 }

 /* Step 5. */
 var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;

 /* Steps 6-7. */
 /* Steps a (implicit), and d. */
 for (var k = 0; k < len; k++) {
   /* Step b */
   if (k in O) {
     /* Step c. */
     if (callContentFunction(callbackfn, T, O[k], k, O)) {
       return true;
     }
   }
 }

 /* Step 8. */
 return false;
}
// Inlining this enables inlining of the callback function.
SetIsInlinableLargeFunction(ArraySome);

/* ES5 15.4.4.18. */
function ArrayForEach(callbackfn /*, thisArg*/) {
 /* Step 1. */
 var O = ToObject(this);

 /* Steps 2-3. */
 var len = ToLength(O.length);

 /* Step 4. */
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.forEach");
 }
 if (!IsCallable(callbackfn)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, callbackfn));
 }

 /* Step 5. */
 var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;

 /* Steps 6-7. */
 /* Steps a (implicit), and d. */
 for (var k = 0; k < len; k++) {
   /* Step b */
   if (k in O) {
     /* Step c. */
     callContentFunction(callbackfn, T, O[k], k, O);
   }
 }

 /* Step 8. */
 return undefined;
}
// Inlining this enables inlining of the callback function.
SetIsInlinableLargeFunction(ArrayForEach);

/* ES 2016 draft Mar 25, 2016 22.1.3.15. */
function ArrayMap(callbackfn /*, thisArg*/) {
 /* Step 1. */
 var O = ToObject(this);

 /* Step 2. */
 var len = ToLength(O.length);

 /* Step 3. */
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.map");
 }
 if (!IsCallable(callbackfn)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, callbackfn));
 }

 /* Step 4. */
 var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;

 /* Steps 5. */
 var A = CanOptimizeArraySpecies(O) ? std_Array(len) : ArraySpeciesCreate(O, len);

 /* Steps 6-7. */
 /* Steps 7.a (implicit), and 7.d. */
 for (var k = 0; k < len; k++) {
   /* Steps 7.b-c. */
   if (k in O) {
     /* Steps 7.c.i-iii. */
     var mappedValue = callContentFunction(callbackfn, T, O[k], k, O);
     DefineDataProperty(A, k, mappedValue);
   }
 }

 /* Step 8. */
 return A;
}
// Inlining this enables inlining of the callback function.
SetIsInlinableLargeFunction(ArrayMap);

/* ES 2016 draft Mar 25, 2016 22.1.3.7 Array.prototype.filter. */
function ArrayFilter(callbackfn /*, thisArg*/) {
 /* Step 1. */
 var O = ToObject(this);

 /* Step 2. */
 var len = ToLength(O.length);

 /* Step 3. */
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.filter");
 }
 if (!IsCallable(callbackfn)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, callbackfn));
 }

 /* Step 4. */
 var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;

 /* Step 5. */
 var A = CanOptimizeArraySpecies(O) ? [] : ArraySpeciesCreate(O, 0);

 /* Steps 6-8. */
 /* Steps 8.a (implicit), and 8.d. */
 for (var k = 0, to = 0; k < len; k++) {
   /* Steps 8.b-c. */
   if (k in O) {
     /* Step 8.c.i. */
     var kValue = O[k];
     /* Steps 8.c.ii-iii. */
     if (callContentFunction(callbackfn, T, kValue, k, O)) {
       DefineDataProperty(A, to++, kValue);
     }
   }
 }

 /* Step 9. */
 return A;
}
// Inlining this enables inlining of the callback function.
SetIsInlinableLargeFunction(ArrayFilter);

/* ES5 15.4.4.21. */
function ArrayReduce(callbackfn /*, initialValue*/) {
 /* Step 1. */
 var O = ToObject(this);

 /* Steps 2-3. */
 var len = ToLength(O.length);

 /* Step 4. */
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.reduce");
 }
 if (!IsCallable(callbackfn)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, callbackfn));
 }

 /* Step 6. */
 var k = 0;

 /* Steps 5, 7-8. */
 var accumulator;
 if (ArgumentsLength() > 1) {
   accumulator = GetArgument(1);
 } else {
   /* Step 5. */
   // Add an explicit |throw| here and below to inform Ion that the
   // ThrowTypeError calls exit this function.
   if (len === 0) {
     throw ThrowTypeError(JSMSG_EMPTY_ARRAY_REDUCE);
   }

   // Use a |do-while| loop to let Ion know that the loop will definitely
   // be entered at least once. When Ion is then also able to inline the
   // |in| operator, it can optimize away the whole loop.
   var kPresent = false;
   do {
     if (k in O) {
       kPresent = true;
       break;
     }
   } while (++k < len);
   if (!kPresent) {
     throw ThrowTypeError(JSMSG_EMPTY_ARRAY_REDUCE);
   }

   // Moved outside of the loop to ensure the assignment is non-conditional.
   accumulator = O[k++];
 }

 /* Step 9. */
 /* Steps a (implicit), and d. */
 for (; k < len; k++) {
   /* Step b */
   if (k in O) {
     /* Step c. */
     accumulator = callContentFunction(
       callbackfn,
       undefined,
       accumulator,
       O[k],
       k,
       O
     );
   }
 }

 /* Step 10. */
 return accumulator;
}

/* ES5 15.4.4.22. */
function ArrayReduceRight(callbackfn /*, initialValue*/) {
 /* Step 1. */
 var O = ToObject(this);

 /* Steps 2-3. */
 var len = ToLength(O.length);

 /* Step 4. */
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.reduce");
 }
 if (!IsCallable(callbackfn)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, callbackfn));
 }

 /* Step 6. */
 var k = len - 1;

 /* Steps 5, 7-8. */
 var accumulator;
 if (ArgumentsLength() > 1) {
   accumulator = GetArgument(1);
 } else {
   /* Step 5. */
   // Add an explicit |throw| here and below to inform Ion that the
   // ThrowTypeError calls exit this function.
   if (len === 0) {
     throw ThrowTypeError(JSMSG_EMPTY_ARRAY_REDUCE);
   }

   // Use a |do-while| loop to let Ion know that the loop will definitely
   // be entered at least once. When Ion is then also able to inline the
   // |in| operator, it can optimize away the whole loop.
   var kPresent = false;
   do {
     if (k in O) {
       kPresent = true;
       break;
     }
   } while (--k >= 0);
   if (!kPresent) {
     throw ThrowTypeError(JSMSG_EMPTY_ARRAY_REDUCE);
   }

   // Moved outside of the loop to ensure the assignment is non-conditional.
   accumulator = O[k--];
 }

 /* Step 9. */
 /* Steps a (implicit), and d. */
 for (; k >= 0; k--) {
   /* Step b */
   if (k in O) {
     /* Step c. */
     accumulator = callContentFunction(
       callbackfn,
       undefined,
       accumulator,
       O[k],
       k,
       O
     );
   }
 }

 /* Step 10. */
 return accumulator;
}

/* ES6 draft 2013-05-14 15.4.3.23. */
function ArrayFind(predicate /*, thisArg*/) {
 /* Steps 1-2. */
 var O = ToObject(this);

 /* Steps 3-5. */
 var len = ToLength(O.length);

 /* Step 6. */
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.find");
 }
 if (!IsCallable(predicate)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, predicate));
 }

 /* Step 7. */
 var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;

 /* Steps 8-9. */
 /* Steps a (implicit), and g. */
 for (var k = 0; k < len; k++) {
   /* Steps a-c. */
   var kValue = O[k];
   /* Steps d-f. */
   if (callContentFunction(predicate, T, kValue, k, O)) {
     return kValue;
   }
 }

 /* Step 10. */
 return undefined;
}
// Inlining this enables inlining of the callback function.
SetIsInlinableLargeFunction(ArrayFind);

/* ES6 draft 2013-05-14 15.4.3.23. */
function ArrayFindIndex(predicate /*, thisArg*/) {
 /* Steps 1-2. */
 var O = ToObject(this);

 /* Steps 3-5. */
 var len = ToLength(O.length);

 /* Step 6. */
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.find");
 }
 if (!IsCallable(predicate)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, predicate));
 }

 /* Step 7. */
 var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;

 /* Steps 8-9. */
 /* Steps a (implicit), and g. */
 for (var k = 0; k < len; k++) {
   /* Steps a-f. */
   if (callContentFunction(predicate, T, O[k], k, O)) {
     return k;
   }
 }

 /* Step 10. */
 return -1;
}
// Inlining this enables inlining of the callback function.
SetIsInlinableLargeFunction(ArrayFindIndex);

// ES2020 draft rev dc1e21c454bd316810be1c0e7af0131a2d7f38e9
// 22.1.3.3 Array.prototype.copyWithin ( target, start [ , end ] )
function ArrayCopyWithin(target, start, end = undefined) {
 // Step 1.
 var O = ToObject(this);

 // Step 2.
 var len = ToLength(O.length);

 // Step 3.
 var relativeTarget = ToInteger(target);

 // Step 4.
 var to =
   relativeTarget < 0
     ? std_Math_max(len + relativeTarget, 0)
     : std_Math_min(relativeTarget, len);

 // Step 5.
 var relativeStart = ToInteger(start);

 // Step 6.
 var from =
   relativeStart < 0
     ? std_Math_max(len + relativeStart, 0)
     : std_Math_min(relativeStart, len);

 // Step 7.
 var relativeEnd = end === undefined ? len : ToInteger(end);

 // Step 8.
 var final =
   relativeEnd < 0
     ? std_Math_max(len + relativeEnd, 0)
     : std_Math_min(relativeEnd, len);

 // Step 9.
 var count = std_Math_min(final - from, len - to);

 // Steps 10-12.
 if (from < to && to < from + count) {
   // Steps 10.b-c.
   from = from + count - 1;
   to = to + count - 1;

   // Step 12.
   while (count > 0) {
     if (from in O) {
       O[to] = O[from];
     } else {
       delete O[to];
     }

     from--;
     to--;
     count--;
   }
 } else {
   // Step 12.
   while (count > 0) {
     if (from in O) {
       O[to] = O[from];
     } else {
       delete O[to];
     }

     from++;
     to++;
     count--;
   }
 }

 // Step 13.
 return O;
}

// ES2020 draft rev dc1e21c454bd316810be1c0e7af0131a2d7f38e9
// 22.1.3.6 Array.prototype.fill ( value [ , start [ , end ] ] )
function ArrayFill(value, start = 0, end = undefined) {
 // Step 1.
 var O = ToObject(this);

 // Step 2.
 var len = ToLength(O.length);

 // Step 3.
 var relativeStart = ToInteger(start);

 // Step 4.
 var k =
   relativeStart < 0
     ? std_Math_max(len + relativeStart, 0)
     : std_Math_min(relativeStart, len);

 // Step 5.
 var relativeEnd = end === undefined ? len : ToInteger(end);

 // Step 6.
 var final =
   relativeEnd < 0
     ? std_Math_max(len + relativeEnd, 0)
     : std_Math_min(relativeEnd, len);

 // Step 7.
 for (; k < final; k++) {
   O[k] = value;
 }

 // Step 8.
 return O;
}

// ES6, 22.1.5.2.1
// http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%arrayiteratorprototype%.next
function ArrayIteratorNext() {
 // Step 1-3.
 var obj = this;
 if (!IsObject(obj) || (obj = GuardToArrayIterator(obj)) === null) {
   return callFunction(
     CallArrayIteratorMethodIfWrapped,
     this,
     "ArrayIteratorNext"
   );
 }

 // Step 4.
 var a = UnsafeGetReservedSlot(obj, ITERATOR_SLOT_TARGET);
 var result = { value: undefined, done: false };

 // Step 5.
 if (a === null) {
   result.done = true;
   return result;
 }

 // Step 6.
 // The index might not be an integer, so we have to do a generic get here.
 var index = UnsafeGetReservedSlot(obj, ITERATOR_SLOT_NEXT_INDEX);

 // Step 7.
 var itemKind = UnsafeGetInt32FromReservedSlot(obj, ARRAY_ITERATOR_SLOT_ITEM_KIND);

 // Step 8-9.
 var len;
 if (IsPossiblyWrappedTypedArray(a)) {
   len = PossiblyWrappedTypedArrayLength(a);

   // If the length is non-zero, the buffer can't be detached.
   if (len === 0) {
     if (PossiblyWrappedTypedArrayHasDetachedBuffer(a)) {
       ThrowTypeError(JSMSG_TYPED_ARRAY_DETACHED);
     }
   }
 } else {
   len = ToLength(a.length);
 }

 // Step 10.
 if (index >= len) {
   UnsafeSetReservedSlot(obj, ITERATOR_SLOT_TARGET, null);
   result.done = true;
   return result;
 }

 // Step 11.
 UnsafeSetReservedSlot(obj, ITERATOR_SLOT_NEXT_INDEX, index + 1);

 // Step 16.
 if (itemKind === ITEM_KIND_VALUE) {
   result.value = a[index];
   return result;
 }

 // Step 13.
 if (itemKind === ITEM_KIND_KEY_AND_VALUE) {
   var pair = [index, a[index]];
   result.value = pair;
   return result;
 }

 // Step 12.
 assert(itemKind === ITEM_KIND_KEY, itemKind);
 result.value = index;
 return result;
}
// We want to inline this to do scalar replacement of the result object.
SetIsInlinableLargeFunction(ArrayIteratorNext);

// Uncloned functions with `$` prefix are allocated as extended function
// to store the original name in `SetCanonicalName`.
function $ArrayValues() {
 RETURN_ARRAY_ITERATOR(this, ITEM_KIND_VALUE);
}
SetCanonicalName($ArrayValues, "values");

function ArrayEntries() {
 RETURN_ARRAY_ITERATOR(this, ITEM_KIND_KEY_AND_VALUE);
}

function ArrayKeys() {
 RETURN_ARRAY_ITERATOR(this, ITEM_KIND_KEY);
}

// https://tc39.es/proposal-array-from-async/
// TODO: Bug 1834560 The step numbers in this will need updating when this is merged
// into the main spec.
function ArrayFromAsync(asyncItems, mapfn = undefined, thisArg = undefined) {
 // Step 1. Let C be the this value.
 var C = this;

 // Step 2. Let promiseCapability be ! NewPromiseCapability(%Promise%).
 // Step 3. Let fromAsyncClosure be a new Abstract Closure with no parameters that captures C, mapfn, and thisArg and performs the following steps when called:
 var fromAsyncClosure = async () => {
   // Step 3.a. If mapfn is undefined, let mapping be false.
   // Step 3.b. Else,
   //     Step 3.b.i. If IsCallable(mapfn) is false, throw a TypeError exception.
   //     Step 3.b.ii. Let mapping be true.
   var mapping = mapfn !== undefined;
   if (mapping && !IsCallable(mapfn)) {
     ThrowTypeError(JSMSG_NOT_FUNCTION, ToSource(mapfn));
   }

   // Step 3.c. Let usingAsyncIterator be ? GetMethod(asyncItems, @@asyncIterator).
   var usingAsyncIterator = asyncItems[GetBuiltinSymbol("asyncIterator")];
   if (usingAsyncIterator === null) {
     usingAsyncIterator = undefined;
   }

   var usingSyncIterator = undefined;
   if (usingAsyncIterator !== undefined) {
     if (!IsCallable(usingAsyncIterator)) {
       ThrowTypeError(JSMSG_NOT_ITERABLE, ToSource(asyncItems));
     }
   } else {
     // Step 3.d. If usingAsyncIterator is undefined, then

     // Step 3.d.i. Let usingSyncIterator be ? GetMethod(asyncItems, @@iterator).
     usingSyncIterator = asyncItems[GetBuiltinSymbol("iterator")];
     if (usingSyncIterator === null) {
       usingSyncIterator = undefined;
     }

     if (usingSyncIterator !== undefined) {
       if (!IsCallable(usingSyncIterator)) {
         ThrowTypeError(JSMSG_NOT_ITERABLE, ToSource(asyncItems));
       }
     }
   }

   // Step 3.g. Let iteratorRecord be undefined.
   // Step 3.j. If iteratorRecord is not undefined, then ...
   if (usingAsyncIterator !== undefined || usingSyncIterator !== undefined) {
     // Note: The published spec as of f6acfc4f0277e625f13fd22068138aec61a12df3
     //       is incorrect. See https://github.com/tc39/proposal-array-from-async/issues/33
     //       Here we use the implementation provided by @bakkot in that bug
     //       in lieu for now; This allows to use a for-await loop below.

     // Steps 3.h-i are implicit through the for-await loop.

     // Step 3.h. If usingAsyncIterator is not undefined, then
     //     Step 3.h.i. Set iteratorRecord to ? GetIterator(asyncItems, async, usingAsyncIterator).
     // Step 3.i. Else if usingSyncIterator is not undefined, then
     //     Set iteratorRecord to ? CreateAsyncFromSyncIterator(GetIterator(asyncItems, sync, usingSyncIterator)).

     // https://github.com/tc39/proposal-array-from-async/pull/41
     // Step 3.e. If IsConstructor(C) is true, then
     //     Step 3.e.i. Let A be ? Construct(C).
     // Step 3.f. Else,
     //     Step 3.f.i. Let A be ! ArrayCreate(0).
     var A = IsConstructor(C) ? constructContentFunction(C, C) : [];

     // Step 3.j.i. Let k be 0.
     var k = 0;

     // Step 3.j.ii. Repeat,
     for await (var nextValue of allowContentIterWith(
       asyncItems,
       usingAsyncIterator,
       usingSyncIterator
     )) {
       // Following in the steps of Array.from, we don't actually implement 3.j.ii.1.
       // The comment in Array.from also applies here; we should only encounter this
       // after a huge loop around a proxy
       // Step 3.j.ii.1. If k ≥ 2**53 - 1, then
       //     Step 3.j.ii.1.a. Let error be ThrowCompletion(a newly created TypeError object).
       //     Step 3.j.ii.1.b. Return ? AsyncIteratorClose(iteratorRecord, error).
       // Step 3.j.ii.2. Let Pk be ! ToString(𝔽(k)).

       // Step 3.j.ii.3. Let next be ? Await(IteratorStep(iteratorRecord)).

       // Step 3.j.ii.5. Let nextValue be ? IteratorValue(next). (Implicit through the for-await loop).

       // Step 3.j.ii.7. Else, let mappedValue be nextValue. (Reordered)
       var mappedValue = nextValue;

       // Step 3.j.ii.6. If mapping is true, then
       if (mapping) {
         // Step 3.j.ii.6.a. Let mappedValue be Call(mapfn, thisArg, « nextValue, 𝔽(k) »).
         // Step 3.j.ii.6.b. IfAbruptCloseAsyncIterator(mappedValue, iteratorRecord).
         //   Abrupt completion will be handled by the for-await loop.
         mappedValue = callContentFunction(mapfn, thisArg, nextValue, k);

         // Step 3.j.ii.6.c. Set mappedValue to Await(mappedValue).
         // Step 3.j.ii.6.d. IfAbruptCloseAsyncIterator(mappedValue, iteratorRecord).
         mappedValue = await mappedValue;
       }

       // Step 3.j.ii.8. Let defineStatus be CreateDataPropertyOrThrow(A, Pk, mappedValue).
       // Step 3.j.ii.9. If defineStatus is an abrupt completion, return ? AsyncIteratorClose(iteratorRecord, defineStatus).
       DefineDataProperty(A, k, mappedValue);

       // Step 3.j.ii.10. Set k to k + 1.
       k = k + 1;
     }

     // Step 3.j.ii.4. If next is false, then (Reordered)

     // Step 3.j.ii.4.a. Perform ? Set(A, "length", 𝔽(k), true).
     A.length = k;

     // Step 3.j.ii.4.b. Return Completion Record { [[Type]]: return, [[Value]]: A, [[Target]]: empty }.
     return A;
   }

   // Step 3.k. Else,

   // Step 3.k.i. NOTE: asyncItems is neither an AsyncIterable nor an Iterable so assume it is an array-like object.
   // Step 3.k.ii. Let arrayLike be ! ToObject(asyncItems).
   var arrayLike = ToObject(asyncItems);

   // Step 3.k.iii. Let len be ? LengthOfArrayLike(arrayLike).
   var len = ToLength(arrayLike.length);

   // Step 3.k.iv. If IsConstructor(C) is true, then
   //     Step 3.k.iv.1. Let A be ? Construct(C, « 𝔽(len) »).
   // Step 3.k.v. Else,
   //     Step 3.k.v.1. Let A be ? ArrayCreate(len).
   var A = IsConstructor(C) ? constructContentFunction(C, C, len) : std_Array(len);

   // Step 3.k.vi. Let k be 0.
   var k = 0;

   // Step 3.k.vii. Repeat, while k < len,
   while (k < len) {
     // Step 3.k.vii.1. Let Pk be ! ToString(𝔽(k)).
     // Step 3.k.vii.2. Let kValue be ? Get(arrayLike, Pk).
     // Step 3.k.vii.3. Let kValue be ? Await(kValue).
     var kValue = await arrayLike[k];

     // Step 3.k.vii.4. If mapping is true, then
     //     Step 3.k.vii.4.a. Let mappedValue be ? Call(mapfn, thisArg, « kValue, 𝔽(k) »).
     //     Step 3.k.vii.4.b. Let mappedValue be ? Await(mappedValue).
     // Step 3.k.vii.5. Else, let mappedValue be kValue.
     var mappedValue = mapping
       ? await callContentFunction(mapfn, thisArg, kValue, k)
       : kValue;

     // Step 3.k.vii.6. Perform ? CreateDataPropertyOrThrow(A, Pk, mappedValue).
     DefineDataProperty(A, k, mappedValue);

     // Step 3.k.vii.7. Set k to k + 1.
     k = k + 1;
   }

   // Step 3.k.viii. Perform ? Set(A, "length", 𝔽(len), true).
   A.length = len;

   // Step 3.k.ix. Return Completion Record { [[Type]]: return, [[Value]]: A, [[Target]]: empty }.
   return A;
 };

 // Step 4. Perform AsyncFunctionStart(promiseCapability, fromAsyncClosure).
 // Step 5. Return promiseCapability.[[Promise]].
 return fromAsyncClosure();
}

// ES 2017 draft 0f10dba4ad18de92d47d421f378233a2eae8f077 22.1.2.1
function ArrayFrom(items, mapfn = undefined, thisArg = undefined) {
 // Step 1.
 var C = this;

 // Steps 2-3.
 var mapping = mapfn !== undefined;
 if (mapping && !IsCallable(mapfn)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(1, mapfn));
 }
 var T = thisArg;

 // Step 4.
 // Inlined: GetMethod, steps 1-2.
 var usingIterator = items[GetBuiltinSymbol("iterator")];

 // Step 5.
 // Inlined: GetMethod, step 3.
 if (!IsNullOrUndefined(usingIterator)) {
   // Inlined: GetMethod, step 4.
   if (!IsCallable(usingIterator)) {
     ThrowTypeError(JSMSG_NOT_ITERABLE, DecompileArg(0, items));
   }

   // Steps 5.a-b.
   var A = IsConstructor(C) ? constructContentFunction(C, C) : [];

   // Step 5.d.
   var k = 0;

   // Steps 5.c, 5.e
   for (var nextValue of allowContentIterWith(items, usingIterator)) {
     // Step 5.e.i.
     // Disabled for performance reason.  We won't hit this case on
     // normal array, since DefineDataProperty will throw before it.
     // We could hit this when |A| is a proxy and it ignores
     // |DefineDataProperty|, but it happens only after too long loop.
     /*
     if (k >= 0x1fffffffffffff) {
         ThrowTypeError(JSMSG_TOO_LONG_ARRAY);
     }
     */

     // Steps 5.e.vi-vii.
     var mappedValue = mapping
       ? callContentFunction(mapfn, T, nextValue, k)
       : nextValue;

     // Steps 5.e.ii (reordered), 5.e.viii.
     DefineDataProperty(A, k++, mappedValue);
   }

   // Step 5.e.iv.
   A.length = k;
   return A;
 }

 // Step 7 is an assertion: items is not an Iterator. Testing this is
 // literally the very last thing we did, so we don't assert here.

 // Steps 8-9.
 var arrayLike = ToObject(items);

 // Steps 10-11.
 var len = ToLength(arrayLike.length);

 // Steps 12-14.
 var A = IsConstructor(C)
   ? constructContentFunction(C, C, len)
   : std_Array(len);

 // Steps 15-16.
 for (var k = 0; k < len; k++) {
   // Steps 16.a-c.
   var kValue = items[k];

   // Steps 16.d-e.
   var mappedValue = mapping
     ? callContentFunction(mapfn, T, kValue, k)
     : kValue;

   // Steps 16.f-g.
   DefineDataProperty(A, k, mappedValue);
 }

 // Steps 17-18.
 A.length = len;

 // Step 19.
 return A;
}

// ES2015 22.1.3.27 Array.prototype.toString.
function ArrayToString() {
 // Steps 1-2.
 var array = ToObject(this);

 // Steps 3-4.
 var func = array.join;

 // Steps 5-6.
 if (!IsCallable(func)) {
   return callFunction(std_Object_toString, array);
 }
 return callContentFunction(func, array);
}

// ES2017 draft rev f8a9be8ea4bd97237d176907a1e3080dce20c68f
// 22.1.3.27 Array.prototype.toLocaleString ([ reserved1 [ , reserved2 ] ])
// ES2017 Intl draft rev 78bbe7d1095f5ff3760ac4017ed366026e4cb276
// 13.4.1 Array.prototype.toLocaleString ([ locales [ , options ]])
function ArrayToLocaleString(locales, options) {
 // Step 1 (ToObject already performed in native code).
 assert(IsObject(this), "|this| should be an object");
 var array = this;

 // Step 2.
 var len = ToLength(array.length);

 // Step 4.
 if (len === 0) {
   return "";
 }

 // Step 5.
 var firstElement = array[0];

 // Steps 6-7.
 var R;
 if (IsNullOrUndefined(firstElement)) {
   R = "";
 } else {
   #if JS_HAS_INTL_API
   R = ToString(
     callContentFunction(
       firstElement.toLocaleString,
       firstElement,
       locales,
       options
     )
   );
   #else
   R = ToString(
     callContentFunction(firstElement.toLocaleString, firstElement)
   );
   #endif
 }

 // Step 3 (reordered).
 // We don't (yet?) implement locale-dependent separators.
 var separator = ",";

 // Steps 8-9.
 for (var k = 1; k < len; k++) {
   // Step 9.b.
   var nextElement = array[k];

   // Steps 9.a, 9.c-e.
   R += separator;
   if (!IsNullOrUndefined(nextElement)) {
     #if JS_HAS_INTL_API
     R += ToString(
       callContentFunction(
         nextElement.toLocaleString,
         nextElement,
         locales,
         options
       )
     );
     #else
     R += ToString(
       callContentFunction(nextElement.toLocaleString, nextElement)
     );
     #endif
   }
 }

 // Step 10.
 return R;
}

// ES 2016 draft Mar 25, 2016 22.1.2.5.
function $ArraySpecies() {
 // Step 1.
 return this;
}
SetCanonicalName($ArraySpecies, "get [Symbol.species]");

// ES 2016 draft Mar 25, 2016 9.4.2.3.
function ArraySpeciesCreate(originalArray, length) {
 // Step 1.
 assert(typeof length === "number", "length should be a number");
 assert(length >= 0, "length should be a non-negative number");

 // Step 2.
 // eslint-disable-next-line no-compare-neg-zero
 if (length === -0) {
   length = 0;
 }

 // Step 4, 6.
 if (!IsArray(originalArray)) {
   return std_Array(length);
 }

 // Step 5.a.
 var originalConstructor = originalArray.constructor;
 var C = originalConstructor;

 // Step 5.b.
 if (IsConstructor(C) && IsCrossRealmArrayConstructor(C)) {
   return std_Array(length);
 }

 // Step 5.c.
 if (IsObject(C)) {
   // Step 5.c.i.
   C = C[GetBuiltinSymbol("species")];

   // Optimized path for an ordinary Array.
   if (C === GetBuiltinConstructor("Array")) {
     return std_Array(length);
   }

   // Step 5.c.ii.
   if (C === null) {
     return std_Array(length);
   }

 }

 // Step 6.
 if (C === undefined) {
   return std_Array(length);
 }

 // Step 7.
 if (!IsConstructor(C)) {
   ThrowTypeError(JSMSG_NOT_CONSTRUCTOR, "constructor property");
 }

 // Step 8.
 return constructContentFunction(C, C, length);
}

// ES2020 draft rev dc1e21c454bd316810be1c0e7af0131a2d7f38e9
// 22.1.3.11 Array.prototype.flatMap ( mapperFunction [ , thisArg ] )
function ArrayFlatMap(mapperFunction /*, thisArg*/) {
 // Step 1.
 var O = ToObject(this);

 // Step 2.
 var sourceLen = ToLength(O.length);

 // Step 3.
 if (!IsCallable(mapperFunction)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, mapperFunction));
 }

 // Step 4.
 var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;

 // Step 5.
 var A = CanOptimizeArraySpecies(O) ? [] : ArraySpeciesCreate(O, 0);

 // Step 6.
 FlattenIntoArray(A, O, sourceLen, 0, 1, mapperFunction, T);

 // Step 7.
 return A;
}

// ES2020 draft rev dc1e21c454bd316810be1c0e7af0131a2d7f38e9
// 22.1.3.10 Array.prototype.flat ( [ depth ] )
function ArrayFlat(/* depth */) {
 // Step 1.
 var O = ToObject(this);

 // Step 2.
 var sourceLen = ToLength(O.length);

 // Step 3.
 var depthNum = 1;

 // Step 4.
 if (ArgumentsLength() && GetArgument(0) !== undefined) {
   depthNum = ToInteger(GetArgument(0));
 }

 // Step 5.
 var A = CanOptimizeArraySpecies(O) ? [] : ArraySpeciesCreate(O, 0);

 // Step 6.
 FlattenIntoArray(A, O, sourceLen, 0, depthNum);

 // Step 7.
 return A;
}

// ES2020 draft rev dc1e21c454bd316810be1c0e7af0131a2d7f38e9
// 22.1.3.10.1 FlattenIntoArray ( target, source, sourceLen, start, depth [ , mapperFunction, thisArg ] )
function FlattenIntoArray(
 target,
 source,
 sourceLen,
 start,
 depth,
 mapperFunction,
 thisArg
) {
 // Step 1.
 var targetIndex = start;

 // Steps 2-3.
 for (var sourceIndex = 0; sourceIndex < sourceLen; sourceIndex++) {
   // Steps 3.a-c.
   if (sourceIndex in source) {
     // Step 3.c.i.
     var element = source[sourceIndex];

     if (mapperFunction) {
       // Step 3.c.ii.1.
       assert(ArgumentsLength() === 7, "thisArg is present");

       // Step 3.c.ii.2.
       element = callContentFunction(
         mapperFunction,
         thisArg,
         element,
         sourceIndex,
         source
       );
     }

     // Step 3.c.iii.
     var shouldFlatten = false;

     // Step 3.c.iv.
     if (depth > 0) {
       // Step 3.c.iv.1.
       shouldFlatten = IsArray(element);
     }

     // Step 3.c.v.
     if (shouldFlatten) {
       // Step 3.c.v.1.
       var elementLen = ToLength(element.length);

       // Step 3.c.v.2.
       targetIndex = FlattenIntoArray(
         target,
         element,
         elementLen,
         targetIndex,
         depth - 1
       );
     } else {
       // Step 3.c.vi.1.
       if (targetIndex >= MAX_NUMERIC_INDEX) {
         ThrowTypeError(JSMSG_TOO_LONG_ARRAY);
       }

       // Step 3.c.vi.2.
       DefineDataProperty(target, targetIndex, element);

       // Step 3.c.vi.3.
       targetIndex++;
     }
   }
 }

 // Step 4.
 return targetIndex;
}

// https://github.com/tc39/proposal-relative-indexing-method
// Array.prototype.at ( index )
function ArrayAt(index) {
 // Step 1.
 var O = ToObject(this);

 // Step 2.
 var len = ToLength(O.length);

 // Step 3.
 var relativeIndex = ToInteger(index);

 // Steps 4-5.
 var k;
 if (relativeIndex >= 0) {
   k = relativeIndex;
 } else {
   k = len + relativeIndex;
 }

 // Step 6.
 if (k < 0 || k >= len) {
   return undefined;
 }

 // Step 7.
 return O[k];
}
// This function is only barely too long for normal inlining.
SetIsInlinableLargeFunction(ArrayAt);

// https://github.com/tc39/proposal-change-array-by-copy
// Array.prototype.toReversed()
function ArrayToReversed() {
 // Step 1. Let O be ? ToObject(this value).
 var O = ToObject(this);

 // Step 2. Let len be ? LengthOfArrayLike(O).
 var len = ToLength(O.length);

 // Step 3. Let A be ArrayCreate(𝔽(len)).
 var A = std_Array(len);

 // Step 4. Let k be 0.
 // Step 5. Repeat, while k < len,
 for (var k = 0; k < len; k++) {
   // Step 5.a. Let from be ! ToString(𝔽(len - k - 1)).
   var from = len - k - 1;

   // Skip Step 5.b. Let Pk be ToString(𝔽(k)).
   // k is coerced into a string through the property access.

   // Step 5.c. Let fromValue be ? Get(O, from).
   var fromValue = O[from];

   // Step 5.d. Perform ! CreateDataPropertyOrThrow(A, 𝔽(k), fromValue).
   DefineDataProperty(A, k, fromValue);
 }

 // Step 6. Return A.
 return A;
}

// https://github.com/tc39/proposal-change-array-by-copy
// Array.prototype.toSorted()
function ArrayToSorted(comparefn) {
 // Step 1.  If comparefn is not undefined and IsCallable(comparefn) is
 // false, throw a TypeError exception.
 if (comparefn !== undefined && !IsCallable(comparefn)) {
   ThrowTypeError(JSMSG_BAD_TOSORTED_ARG);
 }

 // Step 2. Let O be ? ToObject(this value).
 var O = ToObject(this);

 // Step 3. Let len be ? LengthOfArrayLike(O).
 var len = ToLength(O.length);

 // Step 4. Let A be ? ArrayCreate(𝔽(len)).
 var items = std_Array(len);

 // We depart from steps 5-8 of the spec for performance reasons, as
 // following the spec would require copying the input array twice.
 // Instead, we create a new array that replaces holes with undefined,
 // and sort this array.
 for (var k = 0; k < len; k++) {
   DefineDataProperty(items, k, O[k]);
 }

 // Arrays with less than two elements remain unchanged when sorted.
 if (len <= 1) {
   return items;
 }

 // Steps 5-9.
 return callFunction(std_Array_sort, items, comparefn);
}

// https://github.com/tc39/proposal-array-find-from-last
// Array.prototype.findLast ( predicate, thisArg )
function ArrayFindLast(predicate /*, thisArg*/) {
 // Step 1.
 var O = ToObject(this);

 // Step 2.
 var len = ToLength(O.length);

 // Step 3.
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.findLast");
 }
 if (!IsCallable(predicate)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, predicate));
 }

 var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;

 // Steps 4-5.
 for (var k = len - 1; k >= 0; k--) {
   // Steps 5.a-b.
   var kValue = O[k];

   // Steps 5.c-d.
   if (callContentFunction(predicate, thisArg, kValue, k, O)) {
     return kValue;
   }
 }

 // Step 6.
 return undefined;
}
// Inlining this enables inlining of the callback function.
SetIsInlinableLargeFunction(ArrayFindLast);

// https://github.com/tc39/proposal-array-find-from-last
// Array.prototype.findLastIndex ( predicate, thisArg )
function ArrayFindLastIndex(predicate /*, thisArg*/) {
 // Step 1.
 var O = ToObject(this);

 // Steps 2.
 var len = ToLength(O.length);

 // Step 3.
 if (ArgumentsLength() === 0) {
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.findLastIndex");
 }
 if (!IsCallable(predicate)) {
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, predicate));
 }

 var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;

 // Steps 4-5.
 for (var k = len - 1; k >= 0; k--) {
   // Steps 5.a-d.
   if (callContentFunction(predicate, thisArg, O[k], k, O)) {
     return k;
   }
 }

 // Step 6.
 return -1;
}
// Inlining this enables inlining of the callback function.
SetIsInlinableLargeFunction(ArrayFindLastIndex);