{

Base::finishCreation(vm);

ASSERT(inherits(info()));

putDirectWithoutTransition(vm, vm.propertyNames->toString, globalObject->arrayProtoToStringFunction(), static_cast<unsigned>(PropertyAttribute::DontEnum));

putDirectWithoutTransition(vm, vm.propertyNames->builtinNames().valuesPublicName(), globalObject->arrayProtoValuesFunction(), static_cast<unsigned>(PropertyAttribute::DontEnum));

putDirectWithoutTransition(vm, vm.propertyNames->iteratorSymbol, globalObject->arrayProtoValuesFunction(), static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->toLocaleString, arrayProtoFuncToLocaleString, static_cast<unsigned>(PropertyAttribute::DontEnum), 0, ImplementationVisibility::Public);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().concatPublicName(), arrayProtoFuncConcat, static_cast<unsigned>(PropertyAttribute::DontEnum), 1, ImplementationVisibility::Public, ArrayConcatIntrinsic);

JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->fill, arrayProtoFuncFill, static_cast<unsigned>(PropertyAttribute::DontEnum), 1, ImplementationVisibility::Public);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->join, arrayProtoFuncJoin, static_cast<unsigned>(PropertyAttribute::DontEnum), 1, ImplementationVisibility::Public, ArrayJoinIntrinsic);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION("pop"_s, arrayProtoFuncPop, static_cast<unsigned>(PropertyAttribute::DontEnum), 0, ImplementationVisibility::Public, ArrayPopIntrinsic);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().pushPublicName(), arrayProtoFuncPush, static_cast<unsigned>(PropertyAttribute::DontEnum), 1, ImplementationVisibility::Public, ArrayPushIntrinsic);

JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION("reverse"_s, arrayProtoFuncReverse, static_cast<unsigned>(PropertyAttribute::DontEnum), 0, ImplementationVisibility::Public);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().shiftPublicName(), arrayProtoFuncShift, static_cast<unsigned>(PropertyAttribute::DontEnum), 0, ImplementationVisibility::Public, ArrayShiftIntrinsic);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().shiftPrivateName(), arrayProtoFuncShift, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly, 0, ImplementationVisibility::Public, ArrayShiftIntrinsic);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->slice, arrayProtoFuncSlice, static_cast<unsigned>(PropertyAttribute::DontEnum), 2, ImplementationVisibility::Public, ArraySliceIntrinsic);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->sort, arrayProtoFuncSort, static_cast<unsigned>(PropertyAttribute::DontEnum), 1, ImplementationVisibility::Public, ArraySortIntrinsic);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION("splice"_s, arrayProtoFuncSplice, static_cast<unsigned>(PropertyAttribute::DontEnum), 2, ImplementationVisibility::Public, ArraySpliceIntrinsic);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION("unshift"_s, arrayProtoFuncUnShift, static_cast<unsigned>(PropertyAttribute::DontEnum), 1, ImplementationVisibility::Public, ArrayUnshiftIntrinsic);

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().everyPublicName(), arrayPrototypeEveryCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().forEachPublicName(), arrayPrototypeForEachCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().somePublicName(), arrayPrototypeSomeCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().indexOfPublicName(), arrayProtoFuncIndexOf, static_cast<unsigned>(PropertyAttribute::DontEnum), 1, ImplementationVisibility::Public, ArrayIndexOfIntrinsic);

JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION("lastIndexOf"_s, arrayProtoFuncLastIndexOf, static_cast<unsigned>(PropertyAttribute::DontEnum), 1, ImplementationVisibility::Public);

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().filterPublicName(), arrayPrototypeFilterCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->flat, arrayProtoFuncFlat, static_cast<unsigned>(PropertyAttribute::DontEnum), 0, ImplementationVisibility::Public);

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().flatMapPublicName(), arrayPrototypeFlatMapCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().reducePublicName(), arrayPrototypeReduceCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().reduceRightPublicName(), arrayPrototypeReduceRightCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().mapPublicName(), arrayPrototypeMapCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().keysPublicName(), arrayProtoFuncKeys, static_cast<unsigned>(PropertyAttribute::DontEnum), 0, ImplementationVisibility::Public, ArrayKeysIntrinsic);

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().entriesPublicName(), arrayProtoFuncEntries, static_cast<unsigned>(PropertyAttribute::DontEnum), 0, ImplementationVisibility::Public, ArrayEntriesIntrinsic);

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().findPublicName(), arrayPrototypeFindCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().findLastPublicName(), arrayPrototypeFindLastCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().findIndexPublicName(), arrayPrototypeFindIndexCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().findLastIndexPublicName(), arrayPrototypeFindLastIndexCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->includes, arrayProtoFuncIncludes, static_cast<unsigned>(PropertyAttribute::DontEnum), 1, ImplementationVisibility::Public, ArrayIncludesIntrinsic);

JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->copyWithin, arrayProtoFuncCopyWithin, static_cast<unsigned>(PropertyAttribute::DontEnum), 2, ImplementationVisibility::Public);

JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().atPublicName(), arrayPrototypeAtCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));

JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->toReversed, arrayProtoFuncToReversed, static_cast<unsigned>(PropertyAttribute::DontEnum), 0, ImplementationVisibility::Public);

JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->toSorted, arrayProtoFuncToSorted, static_cast<unsigned>(PropertyAttribute::DontEnum), 1, ImplementationVisibility::Public);

JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->toSpliced, arrayProtoFuncToSpliced, static_cast<unsigned>(PropertyAttribute::DontEnum), 2, ImplementationVisibility::Public);

JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->with, arrayProtoFuncWith, static_cast<unsigned>(PropertyAttribute::DontEnum), 2, ImplementationVisibility::Public);

putDirectWithoutTransition(vm, vm.propertyNames->builtinNames().entriesPrivateName(), getDirect(vm, vm.propertyNames->builtinNames().entriesPublicName()), static_cast<unsigned>(PropertyAttribute::ReadOnly));

putDirectWithoutTransition(vm, vm.propertyNames->builtinNames().forEachPrivateName(), getDirect(vm, vm.propertyNames->builtinNames().forEachPublicName()), static_cast<unsigned>(PropertyAttribute::ReadOnly));

putDirectWithoutTransition(vm, vm.propertyNames->builtinNames().includesPrivateName(), getDirect(vm, vm.propertyNames->includes), static_cast<unsigned>(PropertyAttribute::ReadOnly));

putDirectWithoutTransition(vm, vm.propertyNames->builtinNames().indexOfPrivateName(), getDirect(vm, vm.propertyNames->builtinNames().indexOfPublicName()), static_cast<unsigned>(PropertyAttribute::ReadOnly));

putDirectWithoutTransition(vm, vm.propertyNames->builtinNames().keysPrivateName(), getDirect(vm, vm.propertyNames->builtinNames().keysPublicName()), static_cast<unsigned>(PropertyAttribute::ReadOnly));

putDirectWithoutTransition(vm, vm.propertyNames->builtinNames().mapPrivateName(), getDirect(vm, vm.propertyNames->builtinNames().mapPublicName()), static_cast<unsigned>(PropertyAttribute::ReadOnly));

putDirectWithoutTransition(vm, vm.propertyNames->builtinNames().popPrivateName(), getDirect(vm, vm.propertyNames->builtinNames().popPublicName()), static_cast<unsigned>(PropertyAttribute::ReadOnly));

putDirectWithoutTransition(vm, vm.propertyNames->builtinNames().valuesPrivateName(), globalObject->arrayProtoValuesFunction(), static_cast<unsigned>(PropertyAttribute::ReadOnly));

JSObject* unscopables = constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());

unscopables->convertToDictionary(vm);

const Identifier* const unscopableNames[] = {

&vm.propertyNames->builtinNames().atPublicName(),

&vm.propertyNames->copyWithin,

&vm.propertyNames->builtinNames().entriesPublicName(),

&vm.propertyNames->fill,

&vm.propertyNames->builtinNames().findPublicName(),

&vm.propertyNames->builtinNames().findIndexPublicName(),

&vm.propertyNames->builtinNames().findLastPublicName(),

&vm.propertyNames->builtinNames().findLastIndexPublicName(),

&vm.propertyNames->flat,

&vm.propertyNames->builtinNames().flatMapPublicName(),

&vm.propertyNames->includes,

&vm.propertyNames->builtinNames().keysPublicName(),

&vm.propertyNames->toReversed,

&vm.propertyNames->toSorted,

&vm.propertyNames->toSpliced,

&vm.propertyNames->builtinNames().valuesPublicName()

};

for (const auto* unscopableName : unscopableNames) {

if (unscopableName)

unscopables->putDirect(vm, *unscopableName, jsBoolean(true));

}

putDirectWithoutTransition(vm, vm.propertyNames->unscopablesSymbol, unscopables, PropertyAttribute::DontEnum | PropertyAttribute::ReadOnly);

{

if (value.isUndefined())

return undefinedValue;

if (value.isInt32()) [[likely]] {

int64_t indexInt64 = value.asInt32();

if (indexInt64 < 0) {

if constexpr (relativeNegativeIndex == RelativeNegativeIndex::Yes) {

indexInt64 += length;

return indexInt64 < 0 ? 0 : static_cast<uint64_t>(indexInt64);

} else

return 0;

}

uint64_t indexUInt64 = static_cast<uint64_t>(indexInt64);

return std::min(indexUInt64, length);

}

double indexDouble = value.toIntegerOrInfinity(globalObject);

if (indexDouble < 0) {

if constexpr (relativeNegativeIndex == RelativeNegativeIndex::Yes) {

indexDouble += length;

return indexDouble < 0 ? 0 : truncateDoubleToUint64(indexDouble);

} else

return 0;

}

return indexDouble > length ? length : truncateDoubleToUint64(indexDouble);

{

if (value.isUndefined())

return undefinedValue;

if (value.isInt32()) [[likely]] {

int64_t indexInt64 = value.asInt32();

if (indexInt64 < 0)

indexInt64 += length;

return indexInt64;

}

double indexDouble = value.toIntegerOrInfinity(globalObject);

if (indexDouble < 0)

indexDouble += length;

if (std::isinf(indexDouble)) [[unlikely]]

return std::signbit(indexDouble) ? std::numeric_limits<int64_t>::min() : std::numeric_limits<int64_t>::max();

return truncateDoubleToInt64(indexDouble);

{

JSGlobalObject* globalObject = thisObject->realmMayBeNull();

if (!globalObject)

return false;

if (!globalObject->arrayJoinWatchpointSet().isStillValid())

return false;

Structure* structure = thisObject->structure();

// This is the fast case. Many arrays will be an original array.

// We are doing very simple check here. If we do more complicated checks like looking into getDirect "join" of thisObject,

// it would be possible that just looking into "join" function will show the same performance.

return globalObject->isOriginalArrayStructure(structure);

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

// 5. If len is zero, return the empty String.

if (!length)

return jsEmptyString(vm);

// 6. Let element0 be Get(O, "0").

JSValue element0 = thisObject->getIndex(globalObject, 0);

RETURN_IF_EXCEPTION(scope, { });

// 7. If element0 is undefined or null, let R be the empty String; otherwise, let R be ? ToString(element0).

JSString* r = nullptr;

if (element0.isUndefinedOrNull())

r = jsEmptyString(vm);

else

r = element0.toString(globalObject);

RETURN_IF_EXCEPTION(scope, { });

// 8. Let k be 1.

// 9. Repeat, while k < len

// 9.e Increase k by 1..

for (uint64_t k = 1; k < length; ++k) {

// b. Let element be ? Get(O, ! ToString(k)).

JSValue element = thisObject->getIndex(globalObject, k);

RETURN_IF_EXCEPTION(scope, { });

// c. If element is undefined or null, let next be the empty String; otherwise, let next be ? ToString(element).

JSString* next = nullptr;

if (element.isUndefinedOrNull()) {

if (!separator->length())

continue;

next = jsEmptyString(vm);

} else

next = element.toString(globalObject);

RETURN_IF_EXCEPTION(scope, { });

// a. Let S be the String value produced by concatenating R and sep.

// d. Let R be a String value produced by concatenating S and next.

r = jsString(globalObject, r, separator, next);

RETURN_IF_EXCEPTION(scope, { });

}

// 10. Return R.

return r;

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

JSObject* thisObject = callFrame->thisValue().toThis(globalObject, ECMAMode::strict()).toObject(globalObject);

EXCEPTION_ASSERT(!!scope.exception() == !thisObject);

UNUSED_PARAM(scope);

if (!thisObject) [[unlikely]]

return encodedJSValue();

return JSValue::encode(JSArrayIterator::create(vm, globalObject->arrayIteratorStructure(), thisObject, jsNumber(static_cast<unsigned>(kind))));

{

size_t size = entries.size();

unsigned depth = all8Bit == All8Bit::Yes ? level : (level >> 1);

if (size < radixSortThreshold || level > maxRadixLevel) {

if (size < 2)

return;

std::ranges::sort(entries, [&](const auto& a, const auto& b) {

std::strong_ordering ordering = std::strong_ordering::equal;

if constexpr (all8Bit == All8Bit::Yes)

ordering = codePointCompare(a.string.span8().subspan(depth), b.string.span8().subspan(depth));

else

ordering = codePointCompare(StringView(a.string).substring(depth), StringView(b.string).substring(depth));

if (is_neq(ordering))

return is_lt(ordering);

return a.index < b.index;

});

return;

}

auto keyOf = [&](const SortEntry& entry) -> unsigned {

const String& string = entry.string;

if (depth >= string.length())

return 0;

if constexpr (all8Bit == All8Bit::Yes)

return string.span8()[depth] + 1;

else {

char16_t codeUnit = string.codeUnitAt(depth);

return ((level & 1) ? (codeUnit & 0xFF) : (codeUnit >> 8)) + 1;

}

};

std::array<unsigned, radixBucketCount> counts { };

unsigned minBucket = radixBucketCount - 1;

unsigned maxBucket = 0;

for (const auto& entry : entries) {

unsigned key = keyOf(entry);

if (!counts[key]) {

minBucket = std::min(minBucket, key);

maxBucket = std::max(maxBucket, key);

}

++counts[key];

}

if (minBucket == maxBucket) {

if (!minBucket)

return;

sortBucketSort<all8Bit>(entries, scratch, level + 1);

return;

}

std::array<unsigned, radixBucketCount> cursors;

unsigned running = 0;

for (unsigned i = minBucket; i <= maxBucket; ++i) {

cursors[i] = running;

running += counts[i];

}

for (auto& entry : entries) {

unsigned key = keyOf(entry);

scratch[cursors[key]++] = WTF::move(entry);

}

for (size_t i = 0; i < size; ++i)

entries[i] = WTF::move(scratch[i]);

unsigned offset = 0;

for (unsigned i = minBucket; i <= maxBucket; ++i) {

unsigned count = counts[i];

if (i && count > 1)

sortBucketSort<all8Bit>(entries.subspan(offset, count), scratch, level + 1);

offset += count;

}