Generated file
Copy as Markdown
Other Tools
function GetMethod(V, P) {
;;
var func = V[P];
if (IsNullOrUndefined(func)) {
return undefined;
}
if (!IsCallable(func)) {
ThrowTypeError(12, typeof func);
}
return func;
}
function IsPropertyKey(argument) {
var type = typeof argument;
return type === "string" || type === "symbol";
}
function SpeciesConstructor(obj, defaultConstructor) {
;;
var ctor = obj.constructor;
if (ctor === undefined) {
return defaultConstructor;
}
if (!IsObject(ctor)) {
ThrowTypeError(56, "object's 'constructor' property");
}
var s = ctor[GetBuiltinSymbol("species")];
if (IsNullOrUndefined(s)) {
return defaultConstructor;
}
if (IsConstructor(s)) {
return s;
}
ThrowTypeError(
14,
"@@species property of object's constructor"
);
}
function GetTypeError(...args) {
try {
callFunction(std_Function_apply, ThrowTypeError, undefined, args);
} catch (e) {
return e;
}
;;
}
function GetAggregateError(...args) {
try {
callFunction(std_Function_apply, ThrowAggregateError, undefined, args);
} catch (e) {
return e;
}
;;
}
function GetInternalError(...args) {
try {
callFunction(std_Function_apply, ThrowInternalError, undefined, args);
} catch (e) {
return e;
}
;;
}
function NullFunction() {}
function CopyDataProperties(target, source, excludedItems) {
;;
;;
if (IsNullOrUndefined(source)) {
return;
}
var from = ToObject(source);
var keys = CopyDataPropertiesOrGetOwnKeys(target, from, excludedItems);
if (keys === null) {
return;
}
for (var index = 0; index < keys.length; index++) {
var key = keys[index];
if (
!hasOwn(key, excludedItems) &&
callFunction(std_Object_propertyIsEnumerable, from, key)
) {
DefineDataProperty(target, key, from[key]);
}
}
}
function CopyDataPropertiesUnfiltered(target, source) {
;;
if (IsNullOrUndefined(source)) {
return;
}
var from = ToObject(source);
var keys = CopyDataPropertiesOrGetOwnKeys(target, from, null);
if (keys === null) {
return;
}
for (var index = 0; index < keys.length; index++) {
var key = keys[index];
if (callFunction(std_Object_propertyIsEnumerable, from, key)) {
DefineDataProperty(target, key, from[key]);
}
}
}
function outer() {
return function inner() {
return "foo";
};
}
function ArrayEvery(callbackfn ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.every");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = 0; k < len; k++) {
if (k in O) {
if (!callContentFunction(callbackfn, T, O[k], k, O)) {
return false;
}
}
}
return true;
}
SetIsInlinableLargeFunction(ArrayEvery);
function ArraySome(callbackfn ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.some");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = 0; k < len; k++) {
if (k in O) {
if (callContentFunction(callbackfn, T, O[k], k, O)) {
return true;
}
}
}
return false;
}
SetIsInlinableLargeFunction(ArraySome);
function ArrayForEach(callbackfn ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.forEach");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = 0; k < len; k++) {
if (k in O) {
callContentFunction(callbackfn, T, O[k], k, O);
}
}
return undefined;
}
SetIsInlinableLargeFunction(ArrayForEach);
function ArrayMap(callbackfn ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.map");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
var A = CanOptimizeArraySpecies(O) ? std_Array(len) : ArraySpeciesCreate(O, len);
for (var k = 0; k < len; k++) {
if (k in O) {
var mappedValue = callContentFunction(callbackfn, T, O[k], k, O);
DefineDataProperty(A, k, mappedValue);
}
}
return A;
}
SetIsInlinableLargeFunction(ArrayMap);
function ArrayFilter(callbackfn ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.filter");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
var A = CanOptimizeArraySpecies(O) ? [] : ArraySpeciesCreate(O, 0);
for (var k = 0, to = 0; k < len; k++) {
if (k in O) {
var kValue = O[k];
if (callContentFunction(callbackfn, T, kValue, k, O)) {
DefineDataProperty(A, to++, kValue);
}
}
}
return A;
}
SetIsInlinableLargeFunction(ArrayFilter);
function ArrayReduce(callbackfn ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.reduce");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var k = 0;
var accumulator;
if (ArgumentsLength() > 1) {
accumulator = GetArgument(1);
} else {
if (len === 0) {
throw ThrowTypeError(52);
}
var kPresent = false;
do {
if (k in O) {
kPresent = true;
break;
}
} while (++k < len);
if (!kPresent) {
throw ThrowTypeError(52);
}
accumulator = O[k++];
}
for (; k < len; k++) {
if (k in O) {
accumulator = callContentFunction(
callbackfn,
undefined,
accumulator,
O[k],
k,
O
);
}
}
return accumulator;
}
function ArrayReduceRight(callbackfn ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.reduce");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var k = len - 1;
var accumulator;
if (ArgumentsLength() > 1) {
accumulator = GetArgument(1);
} else {
if (len === 0) {
throw ThrowTypeError(52);
}
var kPresent = false;
do {
if (k in O) {
kPresent = true;
break;
}
} while (--k >= 0);
if (!kPresent) {
throw ThrowTypeError(52);
}
accumulator = O[k--];
}
for (; k >= 0; k--) {
if (k in O) {
accumulator = callContentFunction(
callbackfn,
undefined,
accumulator,
O[k],
k,
O
);
}
}
return accumulator;
}
function ArrayFind(predicate ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.find");
}
if (!IsCallable(predicate)) {
ThrowTypeError(12, DecompileArg(0, predicate));
}
var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = 0; k < len; k++) {
var kValue = O[k];
if (callContentFunction(predicate, T, kValue, k, O)) {
return kValue;
}
}
return undefined;
}
SetIsInlinableLargeFunction(ArrayFind);
function ArrayFindIndex(predicate ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.find");
}
if (!IsCallable(predicate)) {
ThrowTypeError(12, DecompileArg(0, predicate));
}
var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = 0; k < len; k++) {
if (callContentFunction(predicate, T, O[k], k, O)) {
return k;
}
}
return -1;
}
SetIsInlinableLargeFunction(ArrayFindIndex);
function ArrayCopyWithin(target, start, end = undefined) {
var O = ToObject(this);
var len = ToLength(O.length);
var relativeTarget = ToInteger(target);
var to =
relativeTarget < 0
? std_Math_max(len + relativeTarget, 0)
: std_Math_min(relativeTarget, len);
var relativeStart = ToInteger(start);
var from =
relativeStart < 0
? std_Math_max(len + relativeStart, 0)
: std_Math_min(relativeStart, len);
var relativeEnd = end === undefined ? len : ToInteger(end);
var final =
relativeEnd < 0
? std_Math_max(len + relativeEnd, 0)
: std_Math_min(relativeEnd, len);
var count = std_Math_min(final - from, len - to);
if (from < to && to < from + count) {
from = from + count - 1;
to = to + count - 1;
while (count > 0) {
if (from in O) {
O[to] = O[from];
} else {
delete O[to];
}
from--;
to--;
count--;
}
} else {
while (count > 0) {
if (from in O) {
O[to] = O[from];
} else {
delete O[to];
}
from++;
to++;
count--;
}
}
return O;
}
function ArrayFill(value, start = 0, end = undefined) {
var O = ToObject(this);
var len = ToLength(O.length);
var relativeStart = ToInteger(start);
var k =
relativeStart < 0
? std_Math_max(len + relativeStart, 0)
: std_Math_min(relativeStart, len);
var relativeEnd = end === undefined ? len : ToInteger(end);
var final =
relativeEnd < 0
? std_Math_max(len + relativeEnd, 0)
: std_Math_min(relativeEnd, len);
for (; k < final; k++) {
O[k] = value;
}
return O;
}
function ArrayIteratorNext() {
var obj = this;
if (!IsObject(obj) || (obj = GuardToArrayIterator(obj)) === null) {
return callFunction(
CallArrayIteratorMethodIfWrapped,
this,
"ArrayIteratorNext"
);
}
var a = UnsafeGetReservedSlot(obj, 0);
var result = { value: undefined, done: false };
if (a === null) {
result.done = true;
return result;
}
var index = UnsafeGetReservedSlot(obj, 1);
var itemKind = UnsafeGetInt32FromReservedSlot(obj, 2);
var len;
if (IsPossiblyWrappedTypedArray(a)) {
len = PossiblyWrappedTypedArrayLength(a);
if (len === 0) {
if (PossiblyWrappedTypedArrayHasDetachedBuffer(a)) {
ThrowTypeError(598);
}
}
} else {
len = ToLength(a.length);
}
if (index >= len) {
UnsafeSetReservedSlot(obj, 0, null);
result.done = true;
return result;
}
UnsafeSetReservedSlot(obj, 1, index + 1);
if (itemKind === 1) {
result.value = a[index];
return result;
}
if (itemKind === 2) {
var pair = [index, a[index]];
result.value = pair;
return result;
}
;;
result.value = index;
return result;
}
SetIsInlinableLargeFunction(ArrayIteratorNext);
function $ArrayValues() {
var iteratedObject = ToObject(this); var iterator = NewArrayIterator(); UnsafeSetReservedSlot(iterator, 0, iteratedObject); UnsafeSetReservedSlot(iterator, 1, 0); UnsafeSetReservedSlot(iterator, 2, 1); return iterator;
}
SetCanonicalName($ArrayValues, "values");
function ArrayEntries() {
var iteratedObject = ToObject(this); var iterator = NewArrayIterator(); UnsafeSetReservedSlot(iterator, 0, iteratedObject); UnsafeSetReservedSlot(iterator, 1, 0); UnsafeSetReservedSlot(iterator, 2, 2); return iterator;
}
function ArrayKeys() {
var iteratedObject = ToObject(this); var iterator = NewArrayIterator(); UnsafeSetReservedSlot(iterator, 0, iteratedObject); UnsafeSetReservedSlot(iterator, 1, 0); UnsafeSetReservedSlot(iterator, 2, 0); return iterator;
}
function ArrayFromAsync(asyncItems, mapfn = undefined, thisArg = undefined) {
var C = this;
var fromAsyncClosure = async () => {
var mapping = mapfn !== undefined;
if (mapping && !IsCallable(mapfn)) {
ThrowTypeError(12, ToSource(mapfn));
}
var usingAsyncIterator = asyncItems[GetBuiltinSymbol("asyncIterator")];
if (usingAsyncIterator === null) {
usingAsyncIterator = undefined;
}
var usingSyncIterator = undefined;
if (usingAsyncIterator !== undefined) {
if (!IsCallable(usingAsyncIterator)) {
ThrowTypeError(71, ToSource(asyncItems));
}
} else {
usingSyncIterator = asyncItems[GetBuiltinSymbol("iterator")];
if (usingSyncIterator === null) {
usingSyncIterator = undefined;
}
if (usingSyncIterator !== undefined) {
if (!IsCallable(usingSyncIterator)) {
ThrowTypeError(71, ToSource(asyncItems));
}
}
}
if (usingAsyncIterator !== undefined || usingSyncIterator !== undefined) {
var A = IsConstructor(C) ? constructContentFunction(C, C) : [];
var k = 0;
for await (var nextValue of allowContentIterWith(
asyncItems,
usingAsyncIterator,
usingSyncIterator
)) {
var mappedValue = nextValue;
if (mapping) {
mappedValue = callContentFunction(mapfn, thisArg, nextValue, k);
mappedValue = await mappedValue;
}
DefineDataProperty(A, k, mappedValue);
k = k + 1;
}
A.length = k;
return A;
}
var arrayLike = ToObject(asyncItems);
var len = ToLength(arrayLike.length);
var A = IsConstructor(C) ? constructContentFunction(C, C, len) : std_Array(len);
var k = 0;
while (k < len) {
var kValue = await arrayLike[k];
var mappedValue = mapping
? await callContentFunction(mapfn, thisArg, kValue, k)
: kValue;
DefineDataProperty(A, k, mappedValue);
k = k + 1;
}
A.length = len;
return A;
};
return fromAsyncClosure();
}
function ArrayFrom(items, mapfn = undefined, thisArg = undefined) {
var C = this;
var mapping = mapfn !== undefined;
if (mapping && !IsCallable(mapfn)) {
ThrowTypeError(12, DecompileArg(1, mapfn));
}
var T = thisArg;
var usingIterator = items[GetBuiltinSymbol("iterator")];
if (!IsNullOrUndefined(usingIterator)) {
if (!IsCallable(usingIterator)) {
ThrowTypeError(71, DecompileArg(0, items));
}
var A = IsConstructor(C) ? constructContentFunction(C, C) : [];
var k = 0;
for (var nextValue of allowContentIterWith(items, usingIterator)) {
var mappedValue = mapping
? callContentFunction(mapfn, T, nextValue, k)
: nextValue;
DefineDataProperty(A, k++, mappedValue);
}
A.length = k;
return A;
}
var arrayLike = ToObject(items);
var len = ToLength(arrayLike.length);
var A = IsConstructor(C)
? constructContentFunction(C, C, len)
: std_Array(len);
for (var k = 0; k < len; k++) {
var kValue = items[k];
var mappedValue = mapping
? callContentFunction(mapfn, T, kValue, k)
: kValue;
DefineDataProperty(A, k, mappedValue);
}
A.length = len;
return A;
}
function ArrayToString() {
var array = ToObject(this);
var func = array.join;
if (!IsCallable(func)) {
return callFunction(std_Object_toString, array);
}
return callContentFunction(func, array);
}
function ArrayToLocaleString(locales, options) {
;;
var array = this;
var len = ToLength(array.length);
if (len === 0) {
return "";
}
var firstElement = array[0];
var R;
if (IsNullOrUndefined(firstElement)) {
R = "";
} else {
R = ToString(
callContentFunction(
firstElement.toLocaleString,
firstElement,
locales,
options
)
);
}
var separator = ",";
for (var k = 1; k < len; k++) {
var nextElement = array[k];
R += separator;
if (!IsNullOrUndefined(nextElement)) {
R += ToString(
callContentFunction(
nextElement.toLocaleString,
nextElement,
locales,
options
)
);
}
}
return R;
}
function $ArraySpecies() {
return this;
}
SetCanonicalName($ArraySpecies, "get [Symbol.species]");
function ArraySpeciesCreate(originalArray, length) {
;;
;;
if (length === -0) {
length = 0;
}
if (!IsArray(originalArray)) {
return std_Array(length);
}
var originalConstructor = originalArray.constructor;
var C = originalConstructor;
if (IsConstructor(C) && IsCrossRealmArrayConstructor(C)) {
return std_Array(length);
}
if (IsObject(C)) {
C = C[GetBuiltinSymbol("species")];
if (C === GetBuiltinConstructor("Array")) {
return std_Array(length);
}
if (C === null) {
return std_Array(length);
}
}
if (C === undefined) {
return std_Array(length);
}
if (!IsConstructor(C)) {
ThrowTypeError(14, "constructor property");
}
return constructContentFunction(C, C, length);
}
function ArrayFlatMap(mapperFunction ) {
var O = ToObject(this);
var sourceLen = ToLength(O.length);
if (!IsCallable(mapperFunction)) {
ThrowTypeError(12, DecompileArg(0, mapperFunction));
}
var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
var A = CanOptimizeArraySpecies(O) ? [] : ArraySpeciesCreate(O, 0);
FlattenIntoArray(A, O, sourceLen, 0, 1, mapperFunction, T);
return A;
}
function ArrayFlat( ) {
var O = ToObject(this);
var sourceLen = ToLength(O.length);
var depthNum = 1;
if (ArgumentsLength() && GetArgument(0) !== undefined) {
depthNum = ToInteger(GetArgument(0));
}
var A = CanOptimizeArraySpecies(O) ? [] : ArraySpeciesCreate(O, 0);
FlattenIntoArray(A, O, sourceLen, 0, depthNum);
return A;
}
function FlattenIntoArray(
target,
source,
sourceLen,
start,
depth,
mapperFunction,
thisArg
) {
var targetIndex = start;
for (var sourceIndex = 0; sourceIndex < sourceLen; sourceIndex++) {
if (sourceIndex in source) {
var element = source[sourceIndex];
if (mapperFunction) {
;;
element = callContentFunction(
mapperFunction,
thisArg,
element,
sourceIndex,
source
);
}
var shouldFlatten = false;
if (depth > 0) {
shouldFlatten = IsArray(element);
}
if (shouldFlatten) {
var elementLen = ToLength(element.length);
targetIndex = FlattenIntoArray(
target,
element,
elementLen,
targetIndex,
depth - 1
);
} else {
if (targetIndex >= 0x1fffffffffffff) {
ThrowTypeError(591);
}
DefineDataProperty(target, targetIndex, element);
targetIndex++;
}
}
}
return targetIndex;
}
function ArrayAt(index) {
var O = ToObject(this);
var len = ToLength(O.length);
var relativeIndex = ToInteger(index);
var k;
if (relativeIndex >= 0) {
k = relativeIndex;
} else {
k = len + relativeIndex;
}
if (k < 0 || k >= len) {
return undefined;
}
return O[k];
}
SetIsInlinableLargeFunction(ArrayAt);
function ArrayToReversed() {
var O = ToObject(this);
var len = ToLength(O.length);
var A = std_Array(len);
for (var k = 0; k < len; k++) {
var from = len - k - 1;
var fromValue = O[from];
DefineDataProperty(A, k, fromValue);
}
return A;
}
function ArrayToSorted(comparefn) {
if (comparefn !== undefined && !IsCallable(comparefn)) {
ThrowTypeError(7);
}
var O = ToObject(this);
var len = ToLength(O.length);
var items = std_Array(len);
for (var k = 0; k < len; k++) {
DefineDataProperty(items, k, O[k]);
}
if (len <= 1) {
return items;
}
return callFunction(std_Array_sort, items, comparefn);
}
function ArrayFindLast(predicate ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.findLast");
}
if (!IsCallable(predicate)) {
ThrowTypeError(12, DecompileArg(0, predicate));
}
var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = len - 1; k >= 0; k--) {
var kValue = O[k];
if (callContentFunction(predicate, thisArg, kValue, k, O)) {
return kValue;
}
}
return undefined;
}
SetIsInlinableLargeFunction(ArrayFindLast);
function ArrayFindLastIndex(predicate ) {
var O = ToObject(this);
var len = ToLength(O.length);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "Array.prototype.findLastIndex");
}
if (!IsCallable(predicate)) {
ThrowTypeError(12, DecompileArg(0, predicate));
}
var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = len - 1; k >= 0; k--) {
if (callContentFunction(predicate, thisArg, O[k], k, O)) {
return k;
}
}
return -1;
}
SetIsInlinableLargeFunction(ArrayFindLastIndex);
function AsyncFunctionNext(val) {
;;
return resumeGenerator(this, val, "next");
}
function AsyncFunctionThrow(val) {
;;
return resumeGenerator(this, val, "throw");
}
function AsyncIteratorIdentity() {
return this;
}
function AsyncGeneratorNext(val) {
;;
return resumeGenerator(this, val, "next");
}
function AsyncGeneratorThrow(val) {
;;
return resumeGenerator(this, val, "throw");
}
function AsyncGeneratorReturn(val) {
;;
return resumeGenerator(this, val, "return");
}
async function AsyncIteratorClose(iteratorRecord, value) {
var iterator = iteratorRecord.iterator;
var returnMethod = iterator.return;
if (!IsNullOrUndefined(returnMethod)) {
var result = await callContentFunction(returnMethod, iterator);
if (!IsObject(result)) {
ThrowTypeError(56, DecompileArg(0, result));
}
}
return value;
}
function GetIteratorDirect(obj) {
if (!IsObject(obj)) {
ThrowTypeError(56, DecompileArg(0, obj));
}
var nextMethod = obj.next;
if (!IsCallable(nextMethod)) {
ThrowTypeError(12, DecompileArg(0, nextMethod));
}
return {
iterator: obj,
nextMethod,
done: false,
};
}
function GetAsyncIteratorDirectWrapper(obj) {
if (!IsObject(obj)) {
ThrowTypeError(56, obj);
}
var nextMethod = obj.next;
if (!IsCallable(nextMethod)) {
ThrowTypeError(12, nextMethod);
}
return {
[GetBuiltinSymbol("asyncIterator")]: function AsyncIteratorMethod() {
return this;
},
next(value) {
return callContentFunction(nextMethod, obj, value);
},
async return(value) {
var returnMethod = obj.return;
if (!IsNullOrUndefined(returnMethod)) {
return callContentFunction(returnMethod, obj, value);
}
return { done: true, value };
},
};
}
function AsyncIteratorHelperNext(value) {
var O = this;
if (!IsObject(O) || (O = GuardToAsyncIteratorHelper(O)) === null) {
return callFunction(
CallAsyncIteratorHelperMethodIfWrapped,
this,
value,
"AsyncIteratorHelperNext"
);
}
var generator = UnsafeGetReservedSlot(
O,
0
);
return callFunction(IntrinsicAsyncGeneratorNext, generator, value);
}
function AsyncIteratorHelperReturn(value) {
var O = this;
if (!IsObject(O) || (O = GuardToAsyncIteratorHelper(O)) === null) {
return callFunction(
CallAsyncIteratorHelperMethodIfWrapped,
this,
value,
"AsyncIteratorHelperReturn"
);
}
var generator = UnsafeGetReservedSlot(
O,
0
);
return callFunction(IntrinsicAsyncGeneratorReturn, generator, value);
}
function AsyncIteratorHelperThrow(value) {
var O = this;
if (!IsObject(O) || (O = GuardToAsyncIteratorHelper(O)) === null) {
return callFunction(
CallAsyncIteratorHelperMethodIfWrapped,
this,
value,
"AsyncIteratorHelperThrow"
);
}
var generator = UnsafeGetReservedSlot(
O,
0
);
return callFunction(IntrinsicAsyncGeneratorThrow, generator, value);
}
function AsyncIteratorMap(mapper) {
var iterated = GetIteratorDirect(this);
if (!IsCallable(mapper)) {
ThrowTypeError(12, DecompileArg(0, mapper));
}
var iteratorHelper = NewAsyncIteratorHelper();
var generator = AsyncIteratorMapGenerator(iterated, mapper);
callFunction(IntrinsicAsyncGeneratorNext, generator);
UnsafeSetReservedSlot(
iteratorHelper,
0,
generator
);
return iteratorHelper;
}
async function* AsyncIteratorMapGenerator(iterated, mapper) {
var lastValue;
var needClose = true;
try {
yield;
needClose = false;
for (
var next = await IteratorNext(iterated, lastValue);
!next.done;
next = await IteratorNext(iterated, lastValue)
) {
var value = next.value;
needClose = true;
lastValue = yield callContentFunction(mapper, undefined, value);
needClose = false;
}
} finally {
if (needClose) {
AsyncIteratorClose(iterated);
}
}
}
function AsyncIteratorFilter(filterer) {
var iterated = GetIteratorDirect(this);
if (!IsCallable(filterer)) {
ThrowTypeError(12, DecompileArg(0, filterer));
}
var iteratorHelper = NewAsyncIteratorHelper();
var generator = AsyncIteratorFilterGenerator(iterated, filterer);
callFunction(IntrinsicAsyncGeneratorNext, generator);
UnsafeSetReservedSlot(
iteratorHelper,
0,
generator
);
return iteratorHelper;
}
async function* AsyncIteratorFilterGenerator(iterated, filterer) {
var lastValue;
var needClose = true;
try {
yield;
needClose = false;
for (
var next = await IteratorNext(iterated, lastValue);
!next.done;
next = await IteratorNext(iterated, lastValue)
) {
var value = next.value;
needClose = true;
if (await callContentFunction(filterer, undefined, value)) {
lastValue = yield value;
}
needClose = false;
}
} finally {
if (needClose) {
AsyncIteratorClose(iterated);
}
}
}
function AsyncIteratorTake(limit) {
var iterated = GetIteratorDirect(this);
var remaining = ToInteger(limit);
if (remaining < 0) {
ThrowRangeError(696);
}
var iteratorHelper = NewAsyncIteratorHelper();
var generator = AsyncIteratorTakeGenerator(iterated, remaining);
callFunction(IntrinsicAsyncGeneratorNext, generator);
UnsafeSetReservedSlot(
iteratorHelper,
0,
generator
);
return iteratorHelper;
}
async function* AsyncIteratorTakeGenerator(iterated, remaining) {
var lastValue;
var needClose = true;
try {
yield;
needClose = false;
for (; remaining > 0; remaining--) {
var next = await IteratorNext(iterated, lastValue);
if (next.done) {
return undefined;
}
var value = next.value;
needClose = true;
lastValue = yield value;
needClose = false;
}
} finally {
if (needClose) {
AsyncIteratorClose(iterated, undefined);
}
}
return AsyncIteratorClose(iterated, undefined);
}
function AsyncIteratorDrop(limit) {
var iterated = GetIteratorDirect(this);
var remaining = ToInteger(limit);
if (remaining < 0) {
ThrowRangeError(696);
}
var iteratorHelper = NewAsyncIteratorHelper();
var generator = AsyncIteratorDropGenerator(iterated, remaining);
callFunction(IntrinsicAsyncGeneratorNext, generator);
UnsafeSetReservedSlot(
iteratorHelper,
0,
generator
);
return iteratorHelper;
}
async function* AsyncIteratorDropGenerator(iterated, remaining) {
var needClose = true;
try {
yield;
needClose = false;
for (; remaining > 0; remaining--) {
var next = await IteratorNext(iterated);
if (next.done) {
return;
}
}
var lastValue;
for (
var next = await IteratorNext(iterated, lastValue);
!next.done;
next = await IteratorNext(iterated, lastValue)
) {
var value = next.value;
needClose = true;
lastValue = yield value;
needClose = false;
}
} finally {
if (needClose) {
AsyncIteratorClose(iterated);
}
}
}
function AsyncIteratorAsIndexedPairs() {
var iterated = GetIteratorDirect(this);
var iteratorHelper = NewAsyncIteratorHelper();
var generator = AsyncIteratorAsIndexedPairsGenerator(iterated);
callFunction(IntrinsicAsyncGeneratorNext, generator);
UnsafeSetReservedSlot(
iteratorHelper,
0,
generator
);
return iteratorHelper;
}
async function* AsyncIteratorAsIndexedPairsGenerator(iterated) {
var needClose = true;
try {
yield;
needClose = false;
var lastValue;
for (
var next = await IteratorNext(iterated, lastValue), index = 0;
!next.done;
next = await IteratorNext(iterated, lastValue), index++
) {
var value = next.value;
needClose = true;
lastValue = yield [index, value];
needClose = false;
}
} finally {
if (needClose) {
AsyncIteratorClose(iterated);
}
}
}
function AsyncIteratorFlatMap(mapper) {
var iterated = GetIteratorDirect(this);
if (!IsCallable(mapper)) {
ThrowTypeError(12, DecompileArg(0, mapper));
}
var iteratorHelper = NewAsyncIteratorHelper();
var generator = AsyncIteratorFlatMapGenerator(iterated, mapper);
callFunction(IntrinsicAsyncGeneratorNext, generator);
UnsafeSetReservedSlot(
iteratorHelper,
0,
generator
);
return iteratorHelper;
}
async function* AsyncIteratorFlatMapGenerator(iterated, mapper) {
var needClose = true;
try {
yield;
needClose = false;
for (
var next = await IteratorNext(iterated);
!next.done;
next = await IteratorNext(iterated)
) {
var value = next.value;
needClose = true;
var mapped = await callContentFunction(mapper, undefined, value);
for await (var innerValue of allowContentIter(mapped)) {
yield innerValue;
}
needClose = false;
}
} finally {
if (needClose) {
AsyncIteratorClose(iterated);
}
}
}
async function AsyncIteratorReduce(reducer ) {
var iterated = GetAsyncIteratorDirectWrapper(this);
if (!IsCallable(reducer)) {
ThrowTypeError(12, DecompileArg(0, reducer));
}
var accumulator;
if (ArgumentsLength() === 1) {
var next = await callContentFunction(iterated.next, iterated);
if (!IsObject(next)) {
ThrowTypeError(56, DecompileArg(0, next));
}
if (next.done) {
ThrowTypeError(53);
}
accumulator = next.value;
} else {
accumulator = GetArgument(1);
}
for await (var value of allowContentIter(iterated)) {
accumulator = await callContentFunction(
reducer,
undefined,
accumulator,
value
);
}
return accumulator;
}
async function AsyncIteratorToArray() {
var iterated = { [GetBuiltinSymbol("asyncIterator")]: () => this };
var items = [];
var index = 0;
for await (var value of allowContentIter(iterated)) {
DefineDataProperty(items, index++, value);
}
return items;
}
async function AsyncIteratorForEach(fn) {
var iterated = GetAsyncIteratorDirectWrapper(this);
if (!IsCallable(fn)) {
ThrowTypeError(12, DecompileArg(0, fn));
}
for await (var value of allowContentIter(iterated)) {
await callContentFunction(fn, undefined, value);
}
}
async function AsyncIteratorSome(fn) {
var iterated = GetAsyncIteratorDirectWrapper(this);
if (!IsCallable(fn)) {
ThrowTypeError(12, DecompileArg(0, fn));
}
for await (var value of allowContentIter(iterated)) {
if (await callContentFunction(fn, undefined, value)) {
return true;
}
}
return false;
}
async function AsyncIteratorEvery(fn) {
var iterated = GetAsyncIteratorDirectWrapper(this);
if (!IsCallable(fn)) {
ThrowTypeError(12, DecompileArg(0, fn));
}
for await (var value of allowContentIter(iterated)) {
if (!(await callContentFunction(fn, undefined, value))) {
return false;
}
}
return true;
}
async function AsyncIteratorFind(fn) {
var iterated = GetAsyncIteratorDirectWrapper(this);
if (!IsCallable(fn)) {
ThrowTypeError(12, DecompileArg(0, fn));
}
for await (var value of allowContentIter(iterated)) {
if (await callContentFunction(fn, undefined, value)) {
return value;
}
}
}
function ErrorToString() {
var obj = this;
if (!IsObject(obj)) {
ThrowTypeError(3, "Error", "toString", "value");
}
var name = obj.name;
name = name === undefined ? "Error" : ToString(name);
var msg = obj.message;
msg = msg === undefined ? "" : ToString(msg);
if (name === "") {
return msg;
}
if (msg === "") {
return name;
}
return name + ": " + msg;
}
function ErrorToStringWithTrailingNewline() {
return callFunction(std_Function_apply, ErrorToString, this, []) + "\n";
}
function GeneratorNext(val) {
if (!IsSuspendedGenerator(this)) {
if (!IsObject(this) || !IsGeneratorObject(this)) {
return callFunction(
CallGeneratorMethodIfWrapped,
this,
val,
"GeneratorNext"
);
}
if (GeneratorObjectIsClosed(this)) {
return { value: undefined, done: true };
}
if (GeneratorIsRunning(this)) {
ThrowTypeError(46);
}
}
try {
return resumeGenerator(this, val, "next");
} catch (e) {
if (!GeneratorObjectIsClosed(this)) {
GeneratorSetClosed(this);
}
throw e;
}
}
function GeneratorThrow(val) {
if (!IsSuspendedGenerator(this)) {
if (!IsObject(this) || !IsGeneratorObject(this)) {
return callFunction(
CallGeneratorMethodIfWrapped,
this,
val,
"GeneratorThrow"
);
}
if (GeneratorObjectIsClosed(this)) {
throw val;
}
if (GeneratorIsRunning(this)) {
ThrowTypeError(46);
}
}
try {
return resumeGenerator(this, val, "throw");
} catch (e) {
if (!GeneratorObjectIsClosed(this)) {
GeneratorSetClosed(this);
}
throw e;
}
}
function GeneratorReturn(val) {
if (!IsSuspendedGenerator(this)) {
if (!IsObject(this) || !IsGeneratorObject(this)) {
return callFunction(
CallGeneratorMethodIfWrapped,
this,
val,
"GeneratorReturn"
);
}
if (GeneratorObjectIsClosed(this)) {
return { value: val, done: true };
}
if (GeneratorIsRunning(this)) {
ThrowTypeError(46);
}
}
try {
var rval = { value: val, done: true };
return resumeGenerator(this, rval, "return");
} catch (e) {
if (!GeneratorObjectIsClosed(this)) {
GeneratorSetClosed(this);
}
throw e;
}
}
function InterpretGeneratorResume(gen, val, kind) {
forceInterpreter();
if (kind === "next") {
return resumeGenerator(gen, val, "next");
}
if (kind === "throw") {
return resumeGenerator(gen, val, "throw");
}
;;
return resumeGenerator(gen, val, "return");
}
function IteratorIdentity() {
return this;
}
function IteratorNext(iteratorRecord, value) {
var result =
ArgumentsLength() < 2
? callContentFunction(iteratorRecord.nextMethod, iteratorRecord.iterator)
: callContentFunction(
iteratorRecord.nextMethod,
iteratorRecord.iterator,
value
);
if (!IsObject(result)) {
ThrowTypeError(56, result);
}
return result;
}
function GetIterator(obj, isAsync, method) {
if (!method) {
if (isAsync) {
method = GetMethod(obj, GetBuiltinSymbol("asyncIterator"));
if (!method) {
var syncMethod = GetMethod(obj, GetBuiltinSymbol("iterator"));
var syncIteratorRecord = GetIterator(obj, false, syncMethod);
return CreateAsyncFromSyncIterator(syncIteratorRecord.iterator, syncIteratorRecord.nextMethod);
}
} else {
method = GetMethod(obj, GetBuiltinSymbol("iterator"));
}
}
var iterator = callContentFunction(method, obj);
if (!IsObject(iterator)) {
ThrowTypeError(71, obj === null ? "null" : typeof obj);
}
var nextMethod = iterator.next;
var iteratorRecord = {
__proto__: null,
iterator,
nextMethod,
done: false,
};
return iteratorRecord;
}
function GetIteratorFlattenable(obj, rejectStrings) {
;;
if (!IsObject(obj)) {
if (rejectStrings || typeof obj !== "string") {
ThrowTypeError(56, obj === null ? "null" : typeof obj);
}
}
var method = obj[GetBuiltinSymbol("iterator")];
var iterator;
if (IsNullOrUndefined(method)) {
iterator = obj;
} else {
iterator = callContentFunction(method, obj);
}
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
return iterator;
}
function IteratorFrom(O) {
var iterator = GetIteratorFlattenable(O, false);
var nextMethod = iterator.next;
var hasInstance = callFunction(
std_Object_isPrototypeOf,
GetBuiltinPrototype("Iterator"),
iterator
);
if (hasInstance) {
return iterator;
}
var wrapper = NewWrapForValidIterator();
UnsafeSetReservedSlot(
wrapper,
0,
iterator
);
UnsafeSetReservedSlot(
wrapper,
1,
nextMethod
);
return wrapper;
}
function WrapForValidIteratorNext() {
var O = this;
if (!IsObject(O) || (O = GuardToWrapForValidIterator(O)) === null) {
return callFunction(
CallWrapForValidIteratorMethodIfWrapped,
this,
"WrapForValidIteratorNext"
);
}
var iterator = UnsafeGetReservedSlot(O, 0);
var nextMethod = UnsafeGetReservedSlot(O, 1);
return callContentFunction(nextMethod, iterator);
}
function WrapForValidIteratorReturn() {
var O = this;
if (!IsObject(O) || (O = GuardToWrapForValidIterator(O)) === null) {
return callFunction(
CallWrapForValidIteratorMethodIfWrapped,
this,
"WrapForValidIteratorReturn"
);
}
var iterator = UnsafeGetReservedSlot(O, 0);
;;
var returnMethod = iterator.return;
if (IsNullOrUndefined(returnMethod)) {
return {
value: undefined,
done: true,
};
}
return callContentFunction(returnMethod, iterator);
}
function IteratorDispose() {
var O = this;
var returnMethod = GetMethod(O, "return");
if (returnMethod !== undefined) {
callContentFunction(returnMethod, O);
}
}
function IteratorHelperNext() {
var O = this;
if (!IsObject(O) || (O = GuardToIteratorHelper(O)) === null) {
return callFunction(
CallIteratorHelperMethodIfWrapped,
this,
"IteratorHelperNext"
);
}
var generator = UnsafeGetReservedSlot(O, 0);
return callFunction(GeneratorNext, generator, undefined);
}
function IteratorHelperReturn() {
var O = this;
if (!IsObject(O) || (O = GuardToIteratorHelper(O)) === null) {
return callFunction(
CallIteratorHelperMethodIfWrapped,
this,
"IteratorHelperReturn"
);
}
var generator = UnsafeGetReservedSlot(O, 0);
var resumeIndex = UnsafeGetReservedSlot(generator, 4);
;;
var isSuspendedStart = resumeIndex === 0;
;;
var result = callFunction(GeneratorReturn, generator, undefined);
if (isSuspendedStart) {
var underlyingIterator = UnsafeGetReservedSlot(O, 1);
;;
if (IsObject(underlyingIterator)) {
IteratorClose(underlyingIterator);
}
}
return result;
}
function IteratorMap(mapper) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
if (!IsCallable(mapper)) {
try {
IteratorClose(iterator);
} catch {}
ThrowTypeError(12, DecompileArg(0, mapper));
}
var nextMethod = iterator.next;
var result = NewIteratorHelper();
var generator = IteratorMapGenerator(iterator, nextMethod, mapper);
UnsafeSetReservedSlot(
result,
0,
generator
);
UnsafeSetReservedSlot(
result,
1,
iterator
);
return result;
}
function* IteratorMapGenerator(iterator, nextMethod, mapper) {
var counter = 0;
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
var mapped = callContentFunction(mapper, undefined, value, counter);
yield mapped;
counter += 1;
}
}
function IteratorFilter(predicate) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
if (!IsCallable(predicate)) {
try {
IteratorClose(iterator);
} catch {}
ThrowTypeError(12, DecompileArg(0, predicate));
}
var nextMethod = iterator.next;
var result = NewIteratorHelper();
var generator = IteratorFilterGenerator(iterator, nextMethod, predicate);
UnsafeSetReservedSlot(
result,
0,
generator
);
UnsafeSetReservedSlot(
result,
1,
iterator
);
return result;
}
function* IteratorFilterGenerator(iterator, nextMethod, predicate) {
var counter = 0;
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
var selected = callContentFunction(predicate, undefined, value, counter);
if (selected) {
yield value;
}
counter += 1;
}
}
function IteratorTake(limit) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
var numLimit;
try {
numLimit = +limit;
} catch (e) {
try {
IteratorClose(iterator);
} catch {}
throw e;
}
var integerLimit = std_Math_trunc(numLimit);
if (!(integerLimit >= 0)) {
try {
IteratorClose(iterator);
} catch {}
ThrowRangeError(696);
}
var nextMethod = iterator.next;
var result = NewIteratorHelper();
var generator = IteratorTakeGenerator(iterator, nextMethod, integerLimit);
UnsafeSetReservedSlot(
result,
0,
generator
);
UnsafeSetReservedSlot(
result,
1,
iterator
);
return result;
}
function* IteratorTakeGenerator(iterator, nextMethod, remaining) {
if (remaining === 0) {
IteratorClose(iterator);
return;
}
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
yield value;
if (--remaining === 0) {
break;
}
}
}
function IteratorDrop(limit) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
var numLimit;
try {
numLimit = +limit;
} catch (e) {
try {
IteratorClose(iterator);
} catch {}
throw e;
}
var integerLimit = std_Math_trunc(numLimit);
if (!(integerLimit >= 0)) {
try {
IteratorClose(iterator);
} catch {}
ThrowRangeError(696);
}
var nextMethod = iterator.next;
var result = NewIteratorHelper();
var generator = IteratorDropGenerator(iterator, nextMethod, integerLimit);
UnsafeSetReservedSlot(
result,
0,
generator
);
UnsafeSetReservedSlot(
result,
1,
iterator
);
return result;
}
function* IteratorDropGenerator(iterator, nextMethod, remaining) {
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
if (remaining-- <= 0) {
yield value;
}
}
}
function IteratorFlatMap(mapper) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
if (!IsCallable(mapper)) {
try {
IteratorClose(iterator);
} catch {}
ThrowTypeError(12, DecompileArg(0, mapper));
}
var nextMethod = iterator.next;
var result = NewIteratorHelper();
var generator = IteratorFlatMapGenerator(iterator, nextMethod, mapper);
UnsafeSetReservedSlot(
result,
0,
generator
);
UnsafeSetReservedSlot(
result,
1,
iterator
);
return result;
}
function* IteratorFlatMapGenerator(iterator, nextMethod, mapper) {
var counter = 0;
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
var mapped = callContentFunction(mapper, undefined, value, counter);
var innerIterator = GetIteratorFlattenable(mapped, true);
var innerIteratorNextMethod = innerIterator.next;
for (var innerValue of allowContentIterWithNext(innerIterator, innerIteratorNextMethod)) {
yield innerValue;
}
counter += 1;
}
}
function IteratorReduce(reducer ) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
if (!IsCallable(reducer)) {
try {
IteratorClose(iterator);
} catch {}
ThrowTypeError(12, DecompileArg(0, reducer));
}
var nextMethod = iterator.next;
var accumulator;
var counter;
if (ArgumentsLength() === 1) {
counter = -1;
} else {
accumulator = GetArgument(1);
counter = 0;
}
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
if (counter < 0) {
accumulator = value;
counter = 1;
} else {
accumulator = callContentFunction(reducer, undefined, accumulator, value, counter++);
}
}
if (counter < 0) {
ThrowTypeError(53);
}
return accumulator;
}
function IteratorToArray() {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
var nextMethod = iterator.next;
return [...allowContentIterWithNext(iterator, nextMethod)];
}
function IteratorForEach(fn) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
if (!IsCallable(fn)) {
try {
IteratorClose(iterator);
} catch {}
ThrowTypeError(12, DecompileArg(0, fn));
}
var nextMethod = iterator.next;
var counter = 0;
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
callContentFunction(fn, undefined, value, counter++);
}
}
function IteratorSome(predicate) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
if (!IsCallable(predicate)) {
try {
IteratorClose(iterator);
} catch {}
ThrowTypeError(12, DecompileArg(0, predicate));
}
var nextMethod = iterator.next;
var counter = 0;
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
if (callContentFunction(predicate, undefined, value, counter++)) {
return true;
}
}
return false;
}
function IteratorEvery(predicate) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
if (!IsCallable(predicate)) {
try {
IteratorClose(iterator);
} catch {}
ThrowTypeError(12, DecompileArg(0, predicate));
}
var nextMethod = iterator.next;
var counter = 0;
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
if (!callContentFunction(predicate, undefined, value, counter++)) {
return false;
}
}
return true;
}
function IteratorFind(predicate) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
if (!IsCallable(predicate)) {
try {
IteratorClose(iterator);
} catch {}
ThrowTypeError(12, DecompileArg(0, predicate));
}
var nextMethod = iterator.next;
var counter = 0;
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
if (callContentFunction(predicate, undefined, value, counter++)) {
return value;
}
}
}
function IteratorConcat() {
var index = ArgumentsLength() * 2;
var iterables = std_Array(index);
for (var i = 0; i < ArgumentsLength(); i++) {
var item = GetArgument(i);
if (!IsObject(item)) {
ThrowTypeError(56, typeof item);
}
var method = item[GetBuiltinSymbol("iterator")];
if (!IsCallable(method)) {
ThrowTypeError(71, ToSource(item));
}
DefineDataProperty(iterables, --index, item);
DefineDataProperty(iterables, --index, method);
}
;;
var result = NewIteratorHelper();
var generator = IteratorConcatGenerator(iterables);
UnsafeSetReservedSlot(
result,
0,
generator
);
return result;
}
function* IteratorConcatGenerator(iterables) {
;;
;;
for (var i = iterables.length; i > 0;) {
var item = iterables[--i];
var method = iterables[--i];
iterables.length -= 2;
for (var innerValue of allowContentIterWith(item, method)) {
yield innerValue;
}
}
}
function IteratorZip(iterables, options = undefined) {
if (!IsObject(iterables)) {
ThrowTypeError(56, iterables === null ? "null" : typeof iterables);
}
if (options !== undefined) {
if (!IsObject(options)) {
ThrowTypeError(
57, "options", "Iterator.zip", ToSource(options)
);
}
var mode = options.mode;
if (mode === undefined) {
mode = "shortest";
}
if (mode !== "shortest" && mode !== "longest" && mode !== "strict") {
if (typeof mode !== "string") {
ThrowTypeError(
700,
"mode",
mode === null ? "null" : typeof mode
);
}
ThrowTypeError(
701, "mode", ToSource(mode)
);
}
var paddingOption = undefined;
if (mode === "longest") {
paddingOption = options.padding;
if (paddingOption !== undefined && !IsObject(paddingOption)) {
ThrowTypeError(
700,
"padding",
padding === null ? "null" : typeof padding
);
}
}
} else {
var mode = "shortest";
}
var iters = [];
var nextMethods = [];
try {
var closedIterators = false;
for (var iter of allowContentIter(iterables)) {
try {
iter = GetIteratorFlattenable(iter, true);
var nextMethod = iter.next;
} catch (e) {
closedIterators = true;
IteratorCloseAllForException(iters);
throw e;
}
DefineDataProperty(iters, iters.length, iter);
DefineDataProperty(nextMethods, nextMethods.length, nextMethod);
}
} catch (e) {
if (!closedIterators) {
IteratorCloseAllForException(iters);
}
throw e;
}
if (mode === "longest") {
var padding = [];
var iterCount = iters.length;
if (paddingOption !== undefined) {
try {
if (iterCount > 0) {
for (var paddingValue of allowContentIter(paddingOption)) {
DefineDataProperty(padding, padding.length, paddingValue);
if (padding.length === iterCount) {
break;
}
}
} else {
var [] = allowContentIter(paddingOption);
}
} catch (e) {
IteratorCloseAllForException(iters);
throw e;
}
}
for (var i = padding.length; i < iterCount; i++) {
DefineDataProperty(padding, i, undefined);
}
}
var result = NewIteratorHelper();
var generator = IteratorZipGenerator(iters, nextMethods, mode, padding);
var closeIterator = {
return() {
IteratorCloseAllForReturn(iters);
return {};
}
};
UnsafeSetReservedSlot(
result,
0,
generator
);
UnsafeSetReservedSlot(
result,
1,
closeIterator
);
return result;
}
function IteratorZipKeyed(iterables, options = undefined) {
if (!IsObject(iterables)) {
ThrowTypeError(56, iterables === null ? "null" : typeof iterables);
}
if (options !== undefined) {
if (!IsObject(options)) {
ThrowTypeError(
57, "options", "Iterator.zipKeyed", ToSource(options)
);
}
var mode = options.mode;
if (mode === undefined) {
mode = "shortest";
}
if (mode !== "shortest" && mode !== "longest" && mode !== "strict") {
if (typeof mode !== "string") {
ThrowTypeError(
700,
"mode",
mode === null ? "null" : typeof mode
);
}
ThrowTypeError(
701, "mode", ToSource(mode)
);
}
var paddingOption = undefined;
if (mode === "longest") {
paddingOption = options.padding;
if (paddingOption !== undefined && !IsObject(paddingOption)) {
ThrowTypeError(
700,
"padding",
padding === null ? "null" : typeof padding
);
}
}
} else {
var mode = "shortest";
}
var iters = [];
var nextMethods = [];
var allKeys = std_Reflect_ownKeys(iterables);
var keys = [];
try {
for (var i = 0; i < allKeys.length; i++) {
var key = allKeys[i];
var desc = ObjectGetOwnPropertyDescriptor(iterables, key);
if (desc && desc.enumerable) {
var value = iterables[key];
if (value !== undefined) {
DefineDataProperty(keys, keys.length, key);
var iter = GetIteratorFlattenable(value, true);
var nextMethod = iter.next;
DefineDataProperty(iters, iters.length, iter);
DefineDataProperty(nextMethods, nextMethods.length, nextMethod);
}
}
}
} catch (e) {
IteratorCloseAllForException(iters);
throw e;
}
if (mode === "longest") {
var padding = [];
if (paddingOption === undefined) {
var iterCount = iters.length;
for (var i = 0; i < iterCount; i++) {
DefineDataProperty(padding, i, undefined);
}
} else {
try {
for (var i = 0; i < keys.length; i++) {
DefineDataProperty(padding, i, paddingOption[keys[i]]);
}
} catch (e) {
IteratorCloseAllForException(iters);
throw e;
}
}
}
var result = NewIteratorHelper();
var generator = IteratorZipGenerator(iters, nextMethods, mode, padding, keys);
var closeIterator = {
return() {
IteratorCloseAllForReturn(iters);
return {};
}
};
UnsafeSetReservedSlot(
result,
0,
generator
);
UnsafeSetReservedSlot(
result,
1,
closeIterator
);
return result;
}
function* IteratorZipGenerator(iters, nextMethods, mode, padding, keys) {
;;
;;
;;
;;
var iterCount = iters.length;
var openIterCount = iterCount;
if (iterCount === 0) {
return;
}
while (true) {
var results = [];
;;
for (var i = 0; i < iterCount; i++) {
var iter = iters[i];
var nextMethod = nextMethods[i];
var result;
if (iter === null) {
;;
result = padding[i];
} else {
try {
var iterResult = callContentFunction(nextMethod, iter);
if (!IsObject(iterResult)) {
ThrowTypeError(74, "next");
}
var done = !!iterResult.done;
if (!done) {
result = iterResult.value;
}
} catch (e) {
iters[i] = null;
IteratorCloseAllForException(iters);
throw e;
}
if (done) {
iters[i] = null;
if (mode === "shortest") {
IteratorCloseAllForReturn(iters);
return;
}
if (mode === "strict") {
if (i !== 0) {
IteratorCloseAllForException(iters);
ThrowTypeError(702);
}
for (var k = 1; k < iterCount; k++) {
;;
var done;
try {
var iterResult = callContentFunction(nextMethods[k], iters[k]);
if (!IsObject(iterResult)) {
ThrowTypeError(74, "next");
}
done = !!iterResult.done;
} catch (e) {
iters[k] = null;
IteratorCloseAllForException(iters);
throw e;
}
if (done) {
iters[k] = null;
} else {
IteratorCloseAllForException(iters);
ThrowTypeError(702);
}
}
return;
}
;;
;;
if (--openIterCount === 0) {
return;
}
iters[i] = null;
result = padding[i];
}
}
DefineDataProperty(results, results.length, result);
}
if (keys) {
var obj = std_Object_create(null);
for (var i = 0; i < keys.length; i++) {
DefineDataProperty(obj, keys[i], results[i]);
}
results = obj;
}
var returnCompletion = true;
try {
yield results;
returnCompletion = false;
} finally {
if (returnCompletion) {
IteratorCloseAllForReturn(iters);
}
}
}
}
function IteratorCloseAllForReturn(iters) {
;;
var exception;
var hasException = false;
for (var i = iters.length - 1; i >= 0; i--) {
var iter = iters[i];
;;
if (IsObject(iter)) {
try {
IteratorClose(iter);
} catch (e) {
if (!hasException) {
hasException = true;
exception = e;
}
}
}
}
if (hasException) {
throw exception;
}
}
function IteratorCloseAllForException(iters) {
;;
for (var i = iters.length - 1; i >= 0; i--) {
var iter = iters[i];
;;
if (IsObject(iter)) {
try {
IteratorClose(iter);
} catch {
}
}
}
}
function IteratorRangeNext() {
var obj = this;
if (!IsObject(obj) || (obj = GuardToIteratorRange(obj)) === null) {
return callFunction(
CallIteratorRangeMethodIfWrapped,
this,
"IteratorRangeNext"
);
}
var start = UnsafeGetReservedSlot(obj, 0);
var end = UnsafeGetReservedSlot(obj, 1);
var step = UnsafeGetReservedSlot(obj, 2);
var inclusiveEnd = UnsafeGetReservedSlot(obj, 3);
var zero = UnsafeGetReservedSlot(obj, 4);
var one = UnsafeGetReservedSlot(obj, 5);
var currentCount = UnsafeGetReservedSlot(obj, 6);
var ifIncrease = end > start;
var ifStepIncrease = step > zero;
if (ifIncrease !== ifStepIncrease) {
return { value: undefined, done: true };
}
var hitsEnd = false;
var currentYieldingValue = start + (step * currentCount);
hitsEnd = currentYieldingValue === end && !inclusiveEnd;
currentCount = currentCount + one;
if (ifIncrease) {
if (inclusiveEnd) {
if (currentYieldingValue > end) {
return { value: undefined, done: true };
}
} else {
if (currentYieldingValue >= end) {
return { value: undefined, done: true };
}
}
} else {
if (inclusiveEnd) {
if (end > currentYieldingValue) {
return { value: undefined, done: true };
}
} else {
if (end >= currentYieldingValue) {
return { value: undefined, done: true };
}
}
}
UnsafeSetReservedSlot(obj, 6, currentCount);
if (hitsEnd) {
return { value: undefined, done: true };
}
return { value: currentYieldingValue, done: false };
}
function CreateNumericRangeIterator(start, end, optionOrStep, isNumberRange) {
if (isNumberRange && Number_isNaN(start)) {
ThrowRangeError(793);
}
if (isNumberRange && Number_isNaN(end)) {
ThrowRangeError(794);
}
if (isNumberRange) {
;;
if (typeof end !== 'number') {
ThrowTypeError(795);
}
var zero = 0;
var one = 1;
} else {
;;
if (typeof end !== 'bigint' && !(Number_isFinite(end))) {
ThrowTypeError(795);
}
var zero = 0n;
var one = 1n;
}
if (typeof start === 'number' && !Number_isFinite(start)) {
ThrowRangeError(796);
}
var inclusiveEnd = false;
var step;
if (optionOrStep !== null && typeof optionOrStep === 'object') {
step = optionOrStep.step;
inclusiveEnd = !!optionOrStep.inclusiveEnd;
}
else if (isNumberRange && typeof optionOrStep === 'number') {
step = optionOrStep;
}
else if (!isNumberRange && typeof optionOrStep === 'bigint') {
step = optionOrStep;
}
else if (optionOrStep !== undefined && optionOrStep !== null) {
ThrowTypeError(801);
}
if (step === undefined || step === null) {
step = end > start ? one : -one;
}
if (typeof step === "number" && Number_isNaN(step)) {
ThrowRangeError(797);
}
if (isNumberRange && typeof step !== 'number') {
ThrowTypeError(798);
}
else if (!isNumberRange && typeof step !== 'bigint') {
ThrowTypeError(802);
}
if (typeof step === 'number' && !Number_isFinite(step)) {
ThrowRangeError(799);
}
if (step === zero && start !== end) {
ThrowRangeError(800);
}
var obj = NewIteratorRange();
UnsafeSetReservedSlot(obj, 0, start);
UnsafeSetReservedSlot(obj, 1, end);
UnsafeSetReservedSlot(obj, 2, step);
UnsafeSetReservedSlot(obj, 3, inclusiveEnd);
UnsafeSetReservedSlot(obj, 4, zero);
UnsafeSetReservedSlot(obj, 5, one);
UnsafeSetReservedSlot(obj, 6, zero);
return obj;
}
function IteratorRange(start, end, optionOrStep) {
if (typeof start === 'number') {
return CreateNumericRangeIterator(start, end, optionOrStep, true);
}
if (typeof start === 'bigint') {
return CreateNumericRangeIterator(start, end, optionOrStep, false);
}
ThrowTypeError(792);
}
function IteratorChunks(chunkSize) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
if (!Number_isInteger(chunkSize) || (chunkSize < 1 || chunkSize > (2 ** 32) - 1)) {
try {
IteratorClose(iterator);
} catch {}
ThrowRangeError(697);
}
var nextMethod = iterator.next;
var result = NewIteratorHelper();
var generator = IteratorChunksGenerator(iterator, nextMethod, chunkSize);
UnsafeSetReservedSlot(
result,
0,
generator
);
UnsafeSetReservedSlot(
result,
1,
iterator
);
return result;
}
function* IteratorChunksGenerator(iterator, nextMethod, chunkSize) {
var buffer = [];
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
DefineDataProperty(buffer, buffer.length, value);
if (buffer.length === chunkSize) {
yield buffer;
buffer = [];
}
}
if (buffer.length) {
yield buffer;
}
}
function IteratorWindows(windowSize, undersized) {
var iterator = this;
if (!IsObject(iterator)) {
ThrowTypeError(56, iterator === null ? "null" : typeof iterator);
}
if (!Number_isInteger(windowSize) || (windowSize < 1 || windowSize > (2 ** 32) - 1)) {
try {
IteratorClose(iterator);
} catch {}
ThrowRangeError(698);
}
if (undersized === undefined) {
undersized = "only-full";
}
if (undersized !== "only-full" && undersized !== "allow-partial") {
try {
IteratorClose(iterator);
} catch {}
ThrowTypeError(
699, "undersized", ToSource(undersized)
);
}
var nextMethod = iterator.next;
var result = NewIteratorHelper();
var generator = IteratorWindowsGenerator(iterator, nextMethod, windowSize, undersized);
UnsafeSetReservedSlot(
result,
0,
generator
);
UnsafeSetReservedSlot(
result,
1,
iterator
);
return result;
}
function* IteratorWindowsGenerator(iterator, nextMethod, windowSize, undersized) {
var buffer = new_List();
for (var value of allowContentIterWithNext(iterator, nextMethod)) {
if (buffer.length === windowSize) {
callFunction(std_Array_shift, buffer);
}
DefineDataProperty(buffer, buffer.length, value);
if (buffer.length === windowSize) {
yield callFunction(std_Array_slice, buffer);
}
}
if (undersized === "allow-partial" && buffer.length && buffer.length < windowSize) {
yield callFunction(std_Array_slice, buffer);
}
}
function IteratorJoin(separator) {
return false;
}
function MapConstructorInit(iterable) {
var map = this;
var adder = map.set;
if (!IsCallable(adder)) {
ThrowTypeError(12, typeof adder);
}
for (var nextItem of allowContentIter(iterable)) {
if (!IsObject(nextItem)) {
ThrowTypeError(45, "Map");
}
callContentFunction(adder, map, nextItem[0], nextItem[1]);
}
}
function MapForEach(callbackfn, thisArg = undefined) {
var M = this;
if (!IsObject(M) || (M = GuardToMapObject(M)) === null) {
return callFunction(
CallMapMethodIfWrapped,
this,
callbackfn,
thisArg,
"MapForEach"
);
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var entries = callFunction(std_Map_entries, M);
var mapIterationResultPair = globalMapIterationResultPair;
while (true) {
var done = GetNextMapEntryForIterator(entries, mapIterationResultPair);
if (done) {
break;
}
var key = mapIterationResultPair[0];
var value = mapIterationResultPair[1];
mapIterationResultPair[0] = null;
mapIterationResultPair[1] = null;
callContentFunction(callbackfn, thisArg, value, key, M);
}
}
var globalMapIterationResultPair = CreateMapIterationResultPair();
function MapIteratorNext() {
var O = this;
if (!IsObject(O) || (O = GuardToMapIterator(O)) === null) {
return callFunction(
CallMapIteratorMethodIfWrapped,
this,
"MapIteratorNext"
);
}
var mapIterationResultPair = globalMapIterationResultPair;
var retVal = { value: undefined, done: true };
var done = GetNextMapEntryForIterator(O, mapIterationResultPair);
if (!done) {
var itemKind = UnsafeGetInt32FromReservedSlot(O, 1);
var result;
if (itemKind === 0) {
result = mapIterationResultPair[0];
} else if (itemKind === 1) {
result = mapIterationResultPair[1];
} else {
;;
result = [mapIterationResultPair[0], mapIterationResultPair[1]];
}
mapIterationResultPair[0] = null;
mapIterationResultPair[1] = null;
retVal.value = result;
retVal.done = false;
}
return retVal;
}
function $MapSpecies() {
return this;
}
SetCanonicalName($MapSpecies, "get [Symbol.species]");
function MapGroupBy(items, callbackfn) {
if (IsNullOrUndefined(items)) {
ThrowTypeError(
54,
DecompileArg(0, items),
items === null ? "null" : "undefined"
);
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(1, callbackfn));
}
var C = GetBuiltinConstructor("Map");
var map = new C();
var k = 0;
for (var value of allowContentIter(items)) {
;;
var key = callContentFunction(callbackfn, undefined, value, k);
var elements = callFunction(std_Map_get, map, key);
if (elements === undefined) {
callFunction(std_Map_set, map, key, [value]);
} else {
DefineDataProperty(elements, elements.length, value);
}
k += 1;
}
return map;
}
function MapGetOrInsertComputed(key, callbackfn) {
var M = this;
if (!IsObject(M) || (M = GuardToMapObject(M)) === null) {
return callFunction(
CallMapMethodIfWrapped,
this,
key,
callbackfn,
"MapGetOrInsertComputed"
);
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(1, callbackfn));
}
if (key === 0) {
key = 0;
}
if (callFunction(std_Map_has, M, key)) {
return callFunction(std_Map_get, M, key);
}
var value = callContentFunction(callbackfn, undefined, key);
callFunction(std_Map_set, M, key, value);
return value;
}
function Number_isFinite(num) {
if (typeof num !== "number") {
return false;
}
return num - num === 0;
}
function Number_isNaN(num) {
if (typeof num !== "number") {
return false;
}
return num !== num;
}
function Number_isInteger(number) {
if (typeof number !== "number") {
return false;
}
var integer = std_Math_trunc(number);
return number - integer === 0;
}
function Number_isSafeInteger(number) {
if (typeof number !== "number") {
return false;
}
var integer = std_Math_trunc(number);
if (number - integer !== 0) {
return false;
}
return -((2 ** 53) - 1) <= integer && integer <= (2 ** 53) - 1;
}
function Global_isNaN(number) {
return Number_isNaN(+number);
}
function Global_isFinite(number) {
return Number_isFinite(+number);
}
function ObjectGetOwnPropertyDescriptors(O) {
var obj = ToObject(O);
var keys = std_Reflect_ownKeys(obj);
var descriptors = {};
for (var index = 0, len = keys.length; index < len; index++) {
var key = keys[index];
var desc = ObjectGetOwnPropertyDescriptor(obj, key);
if (typeof desc !== "undefined") {
DefineDataProperty(descriptors, key, desc);
}
}
return descriptors;
}
function ObjectGetPrototypeOf(obj) {
return std_Reflect_getPrototypeOf(ToObject(obj));
}
function ObjectIsExtensible(obj) {
return IsObject(obj) && std_Reflect_isExtensible(obj);
}
function Object_toLocaleString() {
var O = this;
return callContentFunction(O.toString, O);
}
function Object_valueOf() {
return ToObject(this);
}
function Object_hasOwnProperty(V) {
return hasOwn(V, this);
}
function $ObjectProtoGetter() {
return std_Reflect_getPrototypeOf(ToObject(this));
}
SetCanonicalName($ObjectProtoGetter, "get __proto__");
function $ObjectProtoSetter(proto) {
return callFunction(std_Object_setProto, this, proto);
}
SetCanonicalName($ObjectProtoSetter, "set __proto__");
function ObjectDefineSetter(name, setter) {
var object = ToObject(this);
if (!IsCallable(setter)) {
ThrowTypeError(33, "setter");
}
var key = (typeof name !== "string" && typeof name !== "number" && typeof name !== "symbol" ? ToPropertyKey(name) : name);
DefineProperty(
object,
key,
0x200 | 0x01 | 0x02,
null,
setter,
true
);
}
function ObjectDefineGetter(name, getter) {
var object = ToObject(this);
if (!IsCallable(getter)) {
ThrowTypeError(33, "getter");
}
var key = (typeof name !== "string" && typeof name !== "number" && typeof name !== "symbol" ? ToPropertyKey(name) : name);
DefineProperty(
object,
key,
0x200 | 0x01 | 0x02,
getter,
null,
true
);
}
function ObjectLookupSetter(name) {
var object = ToObject(this);
var key = (typeof name !== "string" && typeof name !== "number" && typeof name !== "symbol" ? ToPropertyKey(name) : name);
do {
var desc = GetOwnPropertyDescriptorToArray(object, key);
if (desc) {
if (desc[0] & 0x200) {
return desc[2];
}
return undefined;
}
object = std_Reflect_getPrototypeOf(object);
} while (object !== null);
}
function ObjectLookupGetter(name) {
var object = ToObject(this);
var key = (typeof name !== "string" && typeof name !== "number" && typeof name !== "symbol" ? ToPropertyKey(name) : name);
do {
var desc = GetOwnPropertyDescriptorToArray(object, key);
if (desc) {
if (desc[0] & 0x200) {
return desc[1];
}
return undefined;
}
object = std_Reflect_getPrototypeOf(object);
} while (object !== null);
}
function ObjectGetOwnPropertyDescriptor(obj, propertyKey) {
var desc = GetOwnPropertyDescriptorToArray(obj, propertyKey);
if (!desc) {
return undefined;
}
var attrsAndKind = desc[0];
if (attrsAndKind & 0x100) {
return {
value: desc[1],
writable: !!(attrsAndKind & 0x04),
enumerable: !!(attrsAndKind & 0x01),
configurable: !!(attrsAndKind & 0x02),
};
}
;;
return {
get: desc[1],
set: desc[2],
enumerable: !!(attrsAndKind & 0x01),
configurable: !!(attrsAndKind & 0x02),
};
}
function ObjectOrReflectDefineProperty(obj, propertyKey, attributes, strict) {
if (!IsObject(obj)) {
ThrowTypeError(56, DecompileArg(0, obj));
}
propertyKey = (typeof propertyKey !== "string" && typeof propertyKey !== "number" && typeof propertyKey !== "symbol" ? ToPropertyKey(propertyKey) : propertyKey);
if (!IsObject(attributes)) {
ThrowTypeError(
58,
DecompileArg(2, attributes)
);
}
var attrs = 0;
var hasValue = false;
var value;
var getter = null;
var setter = null;
if ("enumerable" in attributes) {
attrs |= attributes.enumerable ? 0x01 : 0x08;
}
if ("configurable" in attributes) {
attrs |= attributes.configurable ? 0x02 : 0x10;
}
if ("value" in attributes) {
attrs |= 0x100;
value = attributes.value;
hasValue = true;
}
if ("writable" in attributes) {
attrs |= 0x100;
attrs |= attributes.writable ? 0x04 : 0x20;
}
if ("get" in attributes) {
attrs |= 0x200;
getter = attributes.get;
if (!IsCallable(getter) && getter !== undefined) {
ThrowTypeError(68, "get");
}
}
if ("set" in attributes) {
attrs |= 0x200;
setter = attributes.set;
if (!IsCallable(setter) && setter !== undefined) {
ThrowTypeError(68, "set");
}
}
if (attrs & 0x200) {
if (attrs & 0x100) {
ThrowTypeError(62);
}
return DefineProperty(obj, propertyKey, attrs, getter, setter, strict);
}
if (hasValue) {
if (strict) {
if (
(attrs & (0x01 | 0x02 | 0x04)) ===
(0x01 | 0x02 | 0x04)
) {
DefineDataProperty(obj, propertyKey, value);
return true;
}
}
return DefineProperty(obj, propertyKey, attrs, value, null, strict);
}
return DefineProperty(obj, propertyKey, attrs, undefined, undefined, strict);
}
function ObjectDefineProperty(obj, propertyKey, attributes) {
if (!ObjectOrReflectDefineProperty(obj, propertyKey, attributes, true)) {
return null;
}
return obj;
}
function ObjectFromEntries(iter) {
var obj = {};
for (var pair of allowContentIter(iter)) {
if (!IsObject(pair)) {
ThrowTypeError(45, "Object.fromEntries");
}
DefineDataProperty(obj, pair[0], pair[1]);
}
return obj;
}
function ObjectHasOwn(O, P) {
var obj = ToObject(O);
return hasOwn(P, obj);
}
function ObjectGroupBy(items, callbackfn) {
if (IsNullOrUndefined(items)) {
ThrowTypeError(
54,
DecompileArg(0, items),
items === null ? "null" : "undefined"
);
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(1, callbackfn));
}
var obj = std_Object_create(null);
var k = 0;
for (var value of allowContentIter(items)) {
;;
var key = callContentFunction(callbackfn, undefined, value, k);
key = (typeof key !== "string" && typeof key !== "number" && typeof key !== "symbol" ? ToPropertyKey(key) : key);
var elements = obj[key];
if (elements === undefined) {
DefineDataProperty(obj, key, [value]);
} else {
DefineDataProperty(elements, elements.length, value);
}
k += 1;
}
return obj;
}
function Promise_finally(onFinally) {
var promise = this;
if (!IsObject(promise)) {
ThrowTypeError(3, "Promise", "finally", "value");
}
var C = SpeciesConstructor(promise, GetBuiltinConstructor("Promise"));
;;
var thenFinally, catchFinally;
if (!IsCallable(onFinally)) {
thenFinally = onFinally;
catchFinally = onFinally;
} else {
(thenFinally) = function(value) {
var result = callContentFunction(onFinally, undefined);
var promise = PromiseResolve(C, result);
return callContentFunction(promise.then, promise, function() {
return value;
});
};
(catchFinally) = function(reason) {
var result = callContentFunction(onFinally, undefined);
var promise = PromiseResolve(C, result);
return callContentFunction(promise.then, promise, function() {
throw reason;
});
};
}
return callContentFunction(promise.then, promise, thenFinally, catchFinally);
}
function CreateListFromArrayLikeForArgs(obj) {
;;
var len = ToLength(obj.length);
if (len > (500 * 1000)) {
ThrowRangeError(119);
}
var list = std_Array(len);
for (var i = 0; i < len; i++) {
DefineDataProperty(list, i, obj[i]);
}
return list;
}
function Reflect_apply(target, thisArgument, argumentsList) {
if (!IsCallable(target)) {
ThrowTypeError(12, DecompileArg(0, target));
}
if (!IsObject(argumentsList)) {
ThrowTypeError(
57,
"`argumentsList`",
"Reflect.apply",
ToSource(argumentsList)
);
}
return callFunction(std_Function_apply, target, thisArgument, argumentsList);
}
SetIsInlinableLargeFunction(Reflect_apply);
function Reflect_construct(target, argumentsList ) {
if (!IsConstructor(target)) {
ThrowTypeError(14, DecompileArg(0, target));
}
var newTarget;
if (ArgumentsLength() > 2) {
newTarget = GetArgument(2);
if (!IsConstructor(newTarget)) {
ThrowTypeError(14, DecompileArg(2, newTarget));
}
} else {
newTarget = target;
}
if (!IsObject(argumentsList)) {
ThrowTypeError(
57,
"`argumentsList`",
"Reflect.construct",
ToSource(argumentsList)
);
}
var args =
IsPackedArray(argumentsList) && argumentsList.length <= (500 * 1000)
? argumentsList
: CreateListFromArrayLikeForArgs(argumentsList);
switch (args.length) {
case 0:
return constructContentFunction(target, newTarget);
case 1:
return constructContentFunction(target, newTarget, args[0]);
case 2:
return constructContentFunction(target, newTarget, args[0], args[1]);
case 3:
return constructContentFunction(target, newTarget, args[0], args[1], args[2]);
case 4:
return constructContentFunction(target, newTarget, args[0], args[1], args[2], args[3]);
case 5:
return constructContentFunction(target, newTarget, args[0], args[1], args[2], args[3], args[4]);
case 6:
return constructContentFunction(target, newTarget, args[0], args[1], args[2], args[3], args[4], args[5]);
case 7:
return constructContentFunction(target, newTarget, args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
case 8:
return constructContentFunction(target, newTarget, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
case 9:
return constructContentFunction(target, newTarget, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
case 10:
return constructContentFunction(target, newTarget, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]);
case 11:
return constructContentFunction(target, newTarget, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10]);
case 12:
return constructContentFunction(target, newTarget, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11]);
default:
return ConstructFunction(target, newTarget, args);
}
}
function Reflect_defineProperty(obj, propertyKey, attributes) {
return ObjectOrReflectDefineProperty(obj, propertyKey, attributes, false);
}
function Reflect_getOwnPropertyDescriptor(target, propertyKey) {
if (!IsObject(target)) {
ThrowTypeError(56, DecompileArg(0, target));
}
return ObjectGetOwnPropertyDescriptor(target, propertyKey);
}
function Reflect_has(target, propertyKey) {
if (!IsObject(target)) {
ThrowTypeError(
57,
"`target`",
"Reflect.has",
ToSource(target)
);
}
return propertyKey in target;
}
function Reflect_get(target, propertyKey ) {
if (!IsObject(target)) {
ThrowTypeError(
57,
"`target`",
"Reflect.get",
ToSource(target)
);
}
if (ArgumentsLength() > 2) {
return getPropertySuper(target, propertyKey, GetArgument(2));
}
return target[propertyKey];
}
function $RegExpFlagsGetter() {
var R = this;
if (!IsObject(R)) {
ThrowTypeError(56, R === null ? "null" : typeof R);
}
var result = "";
if (R.hasIndices) {
result += "d";
}
if (R.global) {
result += "g";
}
if (R.ignoreCase) {
result += "i";
}
if (R.multiline) {
result += "m";
}
if (R.dotAll) {
result += "s";
}
if (R.unicode) {
result += "u";
}
if (R.unicodeSets) {
result += "v";
}
if (R.sticky) {
result += "y";
}
return result;
}
SetCanonicalName($RegExpFlagsGetter, "get flags");
function $RegExpToString() {
var R = this;
if (!IsObject(R)) {
ThrowTypeError(56, R === null ? "null" : typeof R);
}
var pattern = ToString(R.source);
var flags = ToString(R.flags);
return "/" + pattern + "/" + flags;
}
SetCanonicalName($RegExpToString, "toString");
function AdvanceStringIndex(S, index) {
;;
;;
var supplementary = (
index < S.length &&
callFunction(std_String_codePointAt, S, index) > 0xffff
);
return index + 1 + supplementary;
}
function RegExpMatch(string) {
var rx = this;
if (!IsObject(rx)) {
ThrowTypeError(56, rx === null ? "null" : typeof rx);
}
var S = ToString(string);
if (IsOptimizableRegExpObject(rx)) {
var flags = UnsafeGetInt32FromReservedSlot(rx, 2);
var global = !!(flags & 0x02);
if (global) {
var fullUnicode = !!(flags & (0x10 | 0x80));
return RegExpGlobalMatchOpt(rx, S, fullUnicode);
}
return RegExpBuiltinExec(rx, S);
}
return RegExpMatchSlowPath(rx, S);
}
function RegExpMatchSlowPath(rx, S) {
var flags = ToString(rx.flags);
if (!callFunction(std_String_includes, flags, "g")) {
return RegExpExec(rx, S);
}
var fullUnicode = callFunction(std_String_includes, flags, "u") || callFunction(std_String_includes, flags, "v");
rx.lastIndex = 0;
var A = [];
var n = 0;
while (true) {
var result = RegExpExec(rx, S);
if (result === null) {
return n === 0 ? null : A;
}
var matchStr = ToString(result[0]);
DefineDataProperty(A, n, matchStr);
if (matchStr === "") {
var lastIndex = ToLength(rx.lastIndex);
rx.lastIndex = fullUnicode
? AdvanceStringIndex(S, lastIndex)
: lastIndex + 1;
}
n++;
}
}
function RegExpGlobalMatchOpt(rx, S, fullUnicode) {
var lastIndex = 0;
rx.lastIndex = 0;
var A = [];
var n = 0;
var lengthS = S.length;
while (true) {
var position = RegExpSearcher(rx, S, lastIndex);
if (position === -1) {
return n === 0 ? null : A;
}
lastIndex = RegExpSearcherLastLimit(S);
var matchStr = Substring(S, position, lastIndex - position);
DefineDataProperty(A, n, matchStr);
if (matchStr === "") {
lastIndex = fullUnicode
? AdvanceStringIndex(S, lastIndex)
: lastIndex + 1;
if (lastIndex > lengthS) {
return A;
}
}
n++;
}
}
function RegExpReplace(string, replaceValue) {
var rx = this;
if (!IsObject(rx)) {
ThrowTypeError(56, rx === null ? "null" : typeof rx);
}
var S = ToString(string);
var lengthS = S.length;
var functionalReplace = IsCallable(replaceValue);
var firstDollarIndex = -1;
if (!functionalReplace) {
replaceValue = ToString(replaceValue);
if (replaceValue.length > 1) {
firstDollarIndex = GetFirstDollarIndex(replaceValue);
}
}
if (IsOptimizableRegExpObject(rx)) {
var flags = UnsafeGetInt32FromReservedSlot(rx, 2);
var global = !!(flags & 0x02);
if (global) {
if (functionalReplace) {
if (lengthS > 5000) {
var elemBase = GetElemBaseForLambda(replaceValue);
if (IsObject(elemBase)) {
return RegExpGlobalReplaceOptElemBase(
rx,
S,
lengthS,
replaceValue,
flags,
elemBase
);
}
}
return RegExpGlobalReplaceOptFunc(rx, S, lengthS, replaceValue, flags);
}
if (firstDollarIndex !== -1) {
return RegExpGlobalReplaceOptSubst(
rx,
S,
lengthS,
replaceValue,
flags,
firstDollarIndex
);
}
return RegExpGlobalReplaceOptSimple(rx, S, lengthS, replaceValue, flags);
}
if (functionalReplace) {
return RegExpLocalReplaceOptFunc(rx, S, lengthS, replaceValue);
}
if (firstDollarIndex !== -1) {
return RegExpLocalReplaceOptSubst(
rx,
S,
lengthS,
replaceValue,
firstDollarIndex
);
}
return RegExpLocalReplaceOptSimple(rx, S, lengthS, replaceValue);
}
return RegExpReplaceSlowPath(
rx,
S,
lengthS,
replaceValue,
functionalReplace,
firstDollarIndex
);
}
function RegExpReplaceSlowPath(
rx,
S,
lengthS,
replaceValue,
functionalReplace,
firstDollarIndex
) {
var flags = ToString(rx.flags);
var global = callFunction(std_String_includes, flags, "g");
var fullUnicode = false;
if (global) {
fullUnicode = callFunction(std_String_includes, flags, "u") || callFunction(std_String_includes, flags, "v");
rx.lastIndex = 0;
}
var results = new_List();
var nResults = 0;
while (true) {
var result = RegExpExec(rx, S);
if (result === null) {
break;
}
DefineDataProperty(results, nResults++, result);
if (!global) {
break;
}
var matchStr = ToString(result[0]);
if (matchStr === "") {
var lastIndex = ToLength(rx.lastIndex);
rx.lastIndex = fullUnicode
? AdvanceStringIndex(S, lastIndex)
: lastIndex + 1;
}
}
var accumulatedResult = "";
var nextSourcePosition = 0;
for (var i = 0; i < nResults; i++) {
result = results[i];
var nCaptures = std_Math_max(ToLength(result.length) - 1, 0);
var matched = ToString(result[0]);
var matchLength = matched.length;
var position = std_Math_max(
std_Math_min(ToInteger(result.index), lengthS),
0
);
var replacement;
if (functionalReplace || firstDollarIndex !== -1) {
replacement = RegExpGetComplexReplacement(
result,
matched,
S,
position,
nCaptures,
replaceValue,
functionalReplace,
firstDollarIndex
);
} else {
for (var n = 1; n <= nCaptures; n++) {
var capN = result[n];
if (capN !== undefined) {
ToString(capN);
}
}
var namedCaptures = result.groups;
if (namedCaptures !== undefined) {
ToObject(namedCaptures);
}
replacement = replaceValue;
}
if (position >= nextSourcePosition) {
accumulatedResult +=
Substring(S, nextSourcePosition, position - nextSourcePosition) +
replacement;
nextSourcePosition = position + matchLength;
}
}
if (nextSourcePosition >= lengthS) {
return accumulatedResult;
}
return (
accumulatedResult +
Substring(S, nextSourcePosition, lengthS - nextSourcePosition)
);
}
function RegExpGetComplexReplacement(
result,
matched,
S,
position,
nCaptures,
replaceValue,
functionalReplace,
firstDollarIndex
) {
var captures = new_List();
var capturesLength = 0;
DefineDataProperty(captures, capturesLength++, matched);
for (var n = 1; n <= nCaptures; n++) {
var capN = result[n];
if (capN !== undefined) {
capN = ToString(capN);
}
DefineDataProperty(captures, capturesLength++, capN);
}
var namedCaptures = result.groups;
if (functionalReplace) {
if (namedCaptures === undefined) {
switch (nCaptures) {
case 0:
return ToString(
callContentFunction(
replaceValue,
undefined,
captures[0],
position,
S
)
);
case 1:
return ToString(
callContentFunction(
replaceValue,
undefined,
captures[0], captures[1],
position,
S
)
);
case 2:
return ToString(
callContentFunction(
replaceValue,
undefined,
captures[0], captures[1], captures[2],
position,
S
)
);
case 3:
return ToString(
callContentFunction(
replaceValue,
undefined,
captures[0], captures[1], captures[2], captures[3],
position,
S
)
);
case 4:
return ToString(
callContentFunction(
replaceValue,
undefined,
captures[0], captures[1], captures[2], captures[3], captures[4],
position,
S
)
);
}
}
DefineDataProperty(captures, capturesLength++, position);
DefineDataProperty(captures, capturesLength++, S);
if (namedCaptures !== undefined) {
DefineDataProperty(captures, capturesLength++, namedCaptures);
}
return ToString(
callFunction(std_Function_apply, replaceValue, undefined, captures)
);
}
if (namedCaptures !== undefined) {
namedCaptures = ToObject(namedCaptures);
}
return RegExpGetSubstitution(
captures,
S,
position,
replaceValue,
firstDollarIndex,
namedCaptures
);
}
function RegExpGetFunctionalReplacement(result, S, position, replaceValue) {
;;
var nCaptures = result.length - 1;
var namedCaptures = result.groups;
if (namedCaptures === undefined) {
switch (nCaptures) {
case 0:
return ToString(
callContentFunction(
replaceValue,
undefined,
result[0],
position,
S
)
);
case 1:
return ToString(
callContentFunction(
replaceValue,
undefined,
result[0], result[1],
position,
S
)
);
case 2:
return ToString(
callContentFunction(
replaceValue,
undefined,
result[0], result[1], result[2],
position,
S
)
);
case 3:
return ToString(
callContentFunction(
replaceValue,
undefined,
result[0], result[1], result[2], result[3],
position,
S
)
);
case 4:
return ToString(
callContentFunction(
replaceValue,
undefined,
result[0], result[1], result[2], result[3], result[4],
position,
S
)
);
}
}
var captures = new_List();
for (var n = 0; n <= nCaptures; n++) {
;;
DefineDataProperty(captures, n, result[n]);
}
DefineDataProperty(captures, nCaptures + 1, position);
DefineDataProperty(captures, nCaptures + 2, S);
if (namedCaptures !== undefined) {
DefineDataProperty(captures, nCaptures + 3, namedCaptures);
}
return ToString(
callFunction(std_Function_apply, replaceValue, undefined, captures)
);
}
function RegExpGlobalReplaceOptSimple(rx, S, lengthS, replaceValue, flags) {
var fullUnicode = !!(flags & (0x10 | 0x80));
var lastIndex = 0;
rx.lastIndex = 0;
var accumulatedResult = "";
var nextSourcePosition = 0;
while (true) {
var position = RegExpSearcher(rx, S, lastIndex);
if (position === -1) {
break;
}
lastIndex = RegExpSearcherLastLimit(S);
accumulatedResult +=
Substring(S, nextSourcePosition, position - nextSourcePosition) +
replaceValue;
nextSourcePosition = lastIndex;
if (lastIndex === position) {
lastIndex = fullUnicode
? AdvanceStringIndex(S, lastIndex)
: lastIndex + 1;
if (lastIndex > lengthS) {
break;
}
}
}
if (nextSourcePosition >= lengthS) {
return accumulatedResult;
}
return (
accumulatedResult +
Substring(S, nextSourcePosition, lengthS - nextSourcePosition)
);
}
function RegExpGlobalReplaceOptFunc(
rx,
S,
lengthS,
replaceValue,
flags,
) {
var fullUnicode = !!(flags & (0x10 | 0x80));
var lastIndex = 0;
rx.lastIndex = 0;
var originalSource = UnsafeGetStringFromReservedSlot(rx, 1);
var originalFlags = flags;
var hasCaptureGroups = RegExpHasCaptureGroups(rx, S);
var accumulatedResult = "";
var nextSourcePosition = 0;
while (true) {
var replacement;
var matchLength;
if (!hasCaptureGroups) {
var position = RegExpSearcher(rx, S, lastIndex);
if (position === -1) {
break;
}
lastIndex = RegExpSearcherLastLimit(S);
var matched = Substring(S, position, lastIndex - position);
matchLength = matched.length;
replacement = ToString(
callContentFunction(
replaceValue,
undefined,
matched,
position,
S
)
);
} else
{
var result = RegExpMatcher(rx, S, lastIndex);
if (result === null) {
break;
}
;;
var matched = result[0];
matchLength = matched.length | 0;
var position = result.index | 0;
lastIndex = position + matchLength;
replacement = RegExpGetFunctionalReplacement(
result,
S,
position,
replaceValue
);
}
accumulatedResult +=
Substring(S, nextSourcePosition, position - nextSourcePosition) +
replacement;
nextSourcePosition = lastIndex;
if (matchLength === 0) {
lastIndex = fullUnicode
? AdvanceStringIndex(S, lastIndex)
: lastIndex + 1;
if (lastIndex > lengthS) {
break;
}
lastIndex |= 0;
}
if (
UnsafeGetStringFromReservedSlot(rx, 1) !==
originalSource ||
UnsafeGetInt32FromReservedSlot(rx, 2) !== originalFlags
) {
var legacy = !!(originalFlags & 0x100);
var newFlags = originalFlags & ~0x100;
rx = RegExpConstructRaw(originalSource, newFlags, legacy);
}
}
if (nextSourcePosition >= lengthS) {
return accumulatedResult;
}
return (
accumulatedResult +
Substring(S, nextSourcePosition, lengthS - nextSourcePosition)
);
}
function RegExpGlobalReplaceOptElemBase(
rx,
S,
lengthS,
replaceValue,
flags,
elemBase
) {
var fullUnicode = !!(flags & (0x10 | 0x80));
var lastIndex = 0;
rx.lastIndex = 0;
var originalSource = UnsafeGetStringFromReservedSlot(rx, 1);
var originalFlags = flags;
var accumulatedResult = "";
var nextSourcePosition = 0;
while (true) {
var replacement;
var matchLength;
{
var result = RegExpMatcher(rx, S, lastIndex);
if (result === null) {
break;
}
;;
var matched = result[0];
matchLength = matched.length | 0;
var position = result.index | 0;
lastIndex = position + matchLength;
if (IsObject(elemBase)) {
var prop = GetStringDataProperty(elemBase, matched);
if (prop !== undefined) {
;;
replacement = prop;
} else {
elemBase = undefined;
}
}
if (!IsObject(elemBase)) {
replacement = RegExpGetFunctionalReplacement(
result,
S,
position,
replaceValue
);
}
}
accumulatedResult +=
Substring(S, nextSourcePosition, position - nextSourcePosition) +
replacement;
nextSourcePosition = lastIndex;
if (matchLength === 0) {
lastIndex = fullUnicode
? AdvanceStringIndex(S, lastIndex)
: lastIndex + 1;
if (lastIndex > lengthS) {
break;
}
lastIndex |= 0;
}
if (
UnsafeGetStringFromReservedSlot(rx, 1) !==
originalSource ||
UnsafeGetInt32FromReservedSlot(rx, 2) !== originalFlags
) {
var legacy = !!(originalFlags & 0x100);
var newFlags = originalFlags & ~0x100;
rx = RegExpConstructRaw(originalSource, newFlags, legacy);
}
}
if (nextSourcePosition >= lengthS) {
return accumulatedResult;
}
return (
accumulatedResult +
Substring(S, nextSourcePosition, lengthS - nextSourcePosition)
);
}
function RegExpGlobalReplaceOptSubst(
rx,
S,
lengthS,
replaceValue,
flags,
firstDollarIndex,
) {
var fullUnicode = !!(flags & (0x10 | 0x80));
var lastIndex = 0;
rx.lastIndex = 0;
var accumulatedResult = "";
var nextSourcePosition = 0;
while (true) {
var replacement;
var matchLength;
{
var result = RegExpMatcher(rx, S, lastIndex);
if (result === null) {
break;
}
;;
var matched = result[0];
matchLength = matched.length | 0;
var position = result.index | 0;
lastIndex = position + matchLength;
var namedCaptures = result.groups;
if (namedCaptures !== undefined) {
namedCaptures = ToObject(namedCaptures);
}
replacement = RegExpGetSubstitution(
result,
S,
position,
replaceValue,
firstDollarIndex,
namedCaptures
);
}
accumulatedResult +=
Substring(S, nextSourcePosition, position - nextSourcePosition) +
replacement;
nextSourcePosition = lastIndex;
if (matchLength === 0) {
lastIndex = fullUnicode
? AdvanceStringIndex(S, lastIndex)
: lastIndex + 1;
if (lastIndex > lengthS) {
break;
}
lastIndex |= 0;
}
}
if (nextSourcePosition >= lengthS) {
return accumulatedResult;
}
return (
accumulatedResult +
Substring(S, nextSourcePosition, lengthS - nextSourcePosition)
);
}
function RegExpLocalReplaceOptSimple(
rx,
S,
lengthS,
replaceValue,
) {
var lastIndex = ToLength(rx.lastIndex);
var flags = UnsafeGetInt32FromReservedSlot(rx, 2);
var globalOrSticky = !!(flags & (0x02 | 0x08));
if (globalOrSticky) {
if (lastIndex > lengthS) {
if (globalOrSticky) {
rx.lastIndex = 0;
}
return S;
}
} else {
lastIndex = 0;
}
var position = RegExpSearcher(rx, S, lastIndex);
if (position === -1) {
if (globalOrSticky) {
rx.lastIndex = 0;
}
return S;
}
var nextSourcePosition = RegExpSearcherLastLimit(S);
if (globalOrSticky) {
rx.lastIndex = nextSourcePosition;
}
var replacement;
replacement = replaceValue;
var accumulatedResult = Substring(S, 0, position) + replacement;
if (nextSourcePosition >= lengthS) {
return accumulatedResult;
}
return (
accumulatedResult +
Substring(S, nextSourcePosition, lengthS - nextSourcePosition)
);
}
function RegExpLocalReplaceOptFunc(
rx,
S,
lengthS,
replaceValue,
) {
var lastIndex = ToLength(rx.lastIndex);
var flags = UnsafeGetInt32FromReservedSlot(rx, 2);
var globalOrSticky = !!(flags & (0x02 | 0x08));
if (globalOrSticky) {
if (lastIndex > lengthS) {
if (globalOrSticky) {
rx.lastIndex = 0;
}
return S;
}
} else {
lastIndex = 0;
}
var result = RegExpMatcher(rx, S, lastIndex);
if (result === null) {
if (globalOrSticky) {
rx.lastIndex = 0;
}
return S;
}
;;
var matched = result[0];
var matchLength = matched.length;
var position = result.index;
var nextSourcePosition = position + matchLength;
if (globalOrSticky) {
rx.lastIndex = nextSourcePosition;
}
var replacement;
replacement = RegExpGetFunctionalReplacement(
result,
S,
position,
replaceValue
);
var accumulatedResult = Substring(S, 0, position) + replacement;
if (nextSourcePosition >= lengthS) {
return accumulatedResult;
}
return (
accumulatedResult +
Substring(S, nextSourcePosition, lengthS - nextSourcePosition)
);
}
function RegExpLocalReplaceOptSubst(
rx,
S,
lengthS,
replaceValue,
firstDollarIndex
) {
var lastIndex = ToLength(rx.lastIndex);
var flags = UnsafeGetInt32FromReservedSlot(rx, 2);
var globalOrSticky = !!(flags & (0x02 | 0x08));
if (globalOrSticky) {
if (lastIndex > lengthS) {
if (globalOrSticky) {
rx.lastIndex = 0;
}
return S;
}
} else {
lastIndex = 0;
}
var result = RegExpMatcher(rx, S, lastIndex);
if (result === null) {
if (globalOrSticky) {
rx.lastIndex = 0;
}
return S;
}
;;
var matched = result[0];
var matchLength = matched.length;
var position = result.index;
var nextSourcePosition = position + matchLength;
if (globalOrSticky) {
rx.lastIndex = nextSourcePosition;
}
var replacement;
var namedCaptures = result.groups;
if (namedCaptures !== undefined) {
namedCaptures = ToObject(namedCaptures);
}
replacement = RegExpGetSubstitution(
result,
S,
position,
replaceValue,
firstDollarIndex,
namedCaptures
);
var accumulatedResult = Substring(S, 0, position) + replacement;
if (nextSourcePosition >= lengthS) {
return accumulatedResult;
}
return (
accumulatedResult +
Substring(S, nextSourcePosition, lengthS - nextSourcePosition)
);
}
function RegExpSearch(string) {
var rx = this;
if (!IsObject(rx)) {
ThrowTypeError(56, rx === null ? "null" : typeof rx);
}
var S = ToString(string);
var previousLastIndex = rx.lastIndex;
var lastIndexIsZero = SameValue(previousLastIndex, 0);
if (!lastIndexIsZero) {
rx.lastIndex = 0;
}
if (IsOptimizableRegExpObject(rx) && S.length < 0x7fff) {
var result = RegExpSearcher(rx, S, 0);
if (!lastIndexIsZero) {
rx.lastIndex = previousLastIndex;
} else {
var flags = UnsafeGetInt32FromReservedSlot(rx, 2);
if (flags & (0x02 | 0x08)) {
rx.lastIndex = previousLastIndex;
}
}
return result;
}
return RegExpSearchSlowPath(rx, S, previousLastIndex);
}
function RegExpSearchSlowPath(rx, S, previousLastIndex) {
var result = RegExpExec(rx, S);
var currentLastIndex = rx.lastIndex;
if (!SameValue(currentLastIndex, previousLastIndex)) {
rx.lastIndex = previousLastIndex;
}
if (result === null) {
return -1;
}
return result.index;
}
function RegExpSplit(string, limit) {
var rx = this;
if (!IsObject(rx)) {
ThrowTypeError(56, rx === null ? "null" : typeof rx);
}
var S = ToString(string);
var builtinCtor = GetBuiltinConstructor("RegExp");
var C = SpeciesConstructor(rx, builtinCtor);
var optimizable =
IsOptimizableRegExpObject(rx) &&
C === builtinCtor &&
(limit === undefined || typeof limit === "number");
var flags, unicodeMatching, splitter;
if (optimizable) {
flags = UnsafeGetInt32FromReservedSlot(rx, 2);
;;
unicodeMatching = !!(flags & (0x10 | 0x80));
if (flags & 0x08) {
var source = UnsafeGetStringFromReservedSlot(rx, 1);
var newFlags = flags & ~(0x08 | 0x100);
splitter = RegExpConstructRaw(source, newFlags, true);
} else {
splitter = rx;
}
} else {
flags = ToString(rx.flags);
unicodeMatching = callFunction(std_String_includes, flags, "u") || callFunction(std_String_includes, flags, "v");
var newFlags;
if (callFunction(std_String_includes, flags, "y")) {
newFlags = flags;
} else {
newFlags = flags + "y";
}
splitter = constructContentFunction(C, C, rx, newFlags);
}
var A = [];
var lengthA = 0;
var lim;
if (limit === undefined) {
lim = 0xffffffff;
} else {
lim = limit >>> 0;
}
var p = 0;
if (lim === 0) {
return A;
}
var size = S.length;
if (size === 0) {
if (optimizable) {
if (RegExpSearcher(splitter, S, 0) !== -1) {
return A;
}
} else {
if (RegExpExec(splitter, S) !== null) {
return A;
}
}
DefineDataProperty(A, 0, S);
return A;
}
var q = p;
var optimizableNoCaptures = optimizable && !RegExpHasCaptureGroups(splitter, S);
while (q < size) {
var e, z;
if (optimizableNoCaptures) {
q = RegExpSearcher(splitter, S, q);
if (q === -1 || q >= size) {
break;
}
e = RegExpSearcherLastLimit(S);
z = null;
} else if (optimizable) {
z = RegExpMatcher(splitter, S, q);
if (z === null) {
break;
}
q = z.index;
if (q >= size) {
break;
}
e = q + z[0].length;
} else {
splitter.lastIndex = q;
z = RegExpExec(splitter, S);
if (z === null) {
q = unicodeMatching ? AdvanceStringIndex(S, q) : q + 1;
continue;
}
e = ToLength(splitter.lastIndex);
}
if (e === p) {
q = unicodeMatching ? AdvanceStringIndex(S, q) : q + 1;
continue;
}
DefineDataProperty(A, lengthA, Substring(S, p, q - p));
lengthA++;
if (lengthA === lim) {
return A;
}
p = e;
if (z !== null) {
var numberOfCaptures = std_Math_max(ToLength(z.length) - 1, 0);
var i = 1;
while (i <= numberOfCaptures) {
DefineDataProperty(A, lengthA, z[i]);
i++;
lengthA++;
if (lengthA === lim) {
return A;
}
}
}
q = p;
}
if (p >= size) {
DefineDataProperty(A, lengthA, "");
} else {
DefineDataProperty(A, lengthA, Substring(S, p, size - p));
}
return A;
}
function RegExp_prototype_Exec(string) {
var R = this;
if (!IsObject(R) || !IsRegExpObject(R)) {
return callFunction(
CallRegExpMethodIfWrapped,
R,
string,
"RegExp_prototype_Exec"
);
}
var S = ToString(string);
return RegExpBuiltinExec(R, S);
}
function RegExpTest(string) {
var R = this;
if (!IsObject(R)) {
ThrowTypeError(56, R === null ? "null" : typeof R);
}
var S = ToString(string);
return RegExpExecForTest(R, S);
}
function $RegExpSpecies() {
return this;
}
SetCanonicalName($RegExpSpecies, "get [Symbol.species]");
function RegExpMatchAll(string) {
var rx = this;
if (!IsObject(rx)) {
ThrowTypeError(56, rx === null ? "null" : typeof rx);
}
var str = ToString(string);
var builtinCtor = GetBuiltinConstructor("RegExp");
var C = SpeciesConstructor(rx, builtinCtor);
var source, flags, matcher, lastIndex;
if (IsOptimizableRegExpObject(rx) && C === builtinCtor) {
source = UnsafeGetStringFromReservedSlot(rx, 1);
flags = UnsafeGetInt32FromReservedSlot(rx, 2);
;;
matcher = rx;
lastIndex = ToLength(rx.lastIndex);
} else {
source = "";
flags = ToString(rx.flags);
matcher = constructContentFunction(C, C, rx, flags);
matcher.lastIndex = ToLength(rx.lastIndex);
flags =
(callFunction(std_String_includes, flags, "g") ? 0x02 : 0) |
(callFunction(std_String_includes, flags, "u") ? 0x10 : 0) |
(callFunction(std_String_includes, flags, "v") ? 0x80 : 0);
lastIndex = -2;
}
return CreateRegExpStringIterator(matcher, str, source, flags, lastIndex);
}
function CreateRegExpStringIterator(regexp, string, source, flags, lastIndex) {
;;
;;
;;
;;
var iterator = NewRegExpStringIterator();
UnsafeSetReservedSlot(iterator, 0, regexp);
UnsafeSetReservedSlot(iterator, 1, string);
UnsafeSetReservedSlot(iterator, 2, source);
UnsafeSetReservedSlot(iterator, 3, flags | 0);
UnsafeSetReservedSlot(
iterator,
4,
lastIndex
);
return iterator;
}
function RegExpStringIteratorNext() {
var obj = this;
if (!IsObject(obj) || (obj = GuardToRegExpStringIterator(obj)) === null) {
return callFunction(
CallRegExpStringIteratorMethodIfWrapped,
this,
"RegExpStringIteratorNext"
);
}
var result = { value: undefined, done: false };
var lastIndex = UnsafeGetReservedSlot(
obj,
4
);
if (lastIndex === -1) {
result.done = true;
return result;
}
var regexp = UnsafeGetObjectFromReservedSlot(
obj,
0
);
var string = UnsafeGetStringFromReservedSlot(
obj,
1
);
var flags = UnsafeGetInt32FromReservedSlot(
obj,
3
);
var global = !!(flags & 0x02);
var fullUnicode = !!(flags & (0x10 | 0x80));
if (lastIndex >= 0) {
;;
var source = UnsafeGetStringFromReservedSlot(
obj,
2
);
if (
IsRegExpPrototypeOptimizable() &&
UnsafeGetStringFromReservedSlot(regexp, 1) === source &&
UnsafeGetInt32FromReservedSlot(regexp, 2) === flags
) {
var globalOrSticky = !!(
flags &
(0x02 | 0x08)
);
if (!globalOrSticky) {
lastIndex = 0;
}
var match =
lastIndex <= string.length
? RegExpMatcher(regexp, string, lastIndex)
: null;
if (match === null) {
UnsafeSetReservedSlot(
obj,
4,
-1
);
result.done = true;
return result;
}
if (global) {
var matchLength = match[0].length;
lastIndex = match.index + matchLength;
if (matchLength === 0) {
lastIndex = fullUnicode
? AdvanceStringIndex(string, lastIndex)
: lastIndex + 1;
}
UnsafeSetReservedSlot(
obj,
4,
lastIndex
);
} else {
UnsafeSetReservedSlot(
obj,
4,
-1
);
}
result.value = match;
return result;
}
var newFlags = flags & ~0x100;
regexp = RegExpConstructRaw(source, newFlags, true);
regexp.lastIndex = lastIndex;
UnsafeSetReservedSlot(obj, 0, regexp);
UnsafeSetReservedSlot(
obj,
4,
-2
);
}
var match = RegExpExec(regexp, string);
if (match === null) {
UnsafeSetReservedSlot(
obj,
4,
-1
);
result.done = true;
return result;
}
if (global) {
var matchStr = ToString(match[0]);
if (matchStr.length === 0) {
var thisIndex = ToLength(regexp.lastIndex);
var nextIndex = fullUnicode
? AdvanceStringIndex(string, thisIndex)
: thisIndex + 1;
regexp.lastIndex = nextIndex;
}
} else {
UnsafeSetReservedSlot(
obj,
4,
-1
);
}
result.value = match;
return result;
}
function IsRegExp(argument) {
if (!IsObject(argument)) {
return false;
}
var matcher = argument[GetBuiltinSymbol("match")];
if (matcher !== undefined) {
return !!matcher;
}
return IsPossiblyWrappedRegExpObject(argument);
}
function ThrowIncompatibleMethod(name, thisv) {
ThrowTypeError(3, "String", name, ToString(thisv));
}
function String_match(regexp) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("match", this);
}
if (IsObject(regexp)) {
if (IsOptimizableRegExpObject(regexp)) {
return callFunction(RegExpMatch, regexp, this);
}
var matcher = GetMethod(regexp, GetBuiltinSymbol("match"));
if (matcher !== undefined) {
return callContentFunction(matcher, regexp, this);
}
}
var S = ToString(this);
if (typeof regexp === "string" && IsRegExpPrototypeOptimizable()) {
var flatResult = FlatStringMatch(S, regexp);
if (flatResult !== undefined) {
return flatResult;
}
}
var rx = RegExpCreate(regexp);
if (IsRegExpPrototypeOptimizable()) {
return RegExpMatcher(rx, S, 0);
}
return callContentFunction(GetMethod(rx, GetBuiltinSymbol("match")), rx, S);
}
function String_matchAll(regexp) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("matchAll", this);
}
if (IsObject(regexp)) {
if (IsRegExp(regexp)) {
var flags = regexp.flags;
if (IsNullOrUndefined(flags)) {
ThrowTypeError(111);
}
if (!callFunction(std_String_includes, ToString(flags), "g")) {
ThrowTypeError(112, "matchAll");
}
}
if (IsOptimizableRegExpObject(regexp)) {
return callFunction(RegExpMatchAll, regexp, this);
}
var matcher = GetMethod(regexp, GetBuiltinSymbol("matchAll"));
if (matcher !== undefined) {
return callContentFunction(matcher, regexp, this);
}
}
var string = ToString(this);
var rx = RegExpCreate(regexp, "g");
return callContentFunction(
GetMethod(rx, GetBuiltinSymbol("matchAll")),
rx,
string
);
}
function String_pad(maxLength, fillString, padEnd) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod(padEnd ? "padEnd" : "padStart", this);
}
var str = ToString(this);
var intMaxLength = ToLength(maxLength);
var strLen = str.length;
if (intMaxLength <= strLen) {
return str;
}
;;
var filler = ToString(fillString);
if (filler === "") {
return str;
}
if (intMaxLength > ((1 << 30) - 2)) {
ThrowRangeError(110);
}
var fillLen = intMaxLength - strLen;
var truncatedStringFiller = callFunction(
String_repeat,
filler,
(fillLen / filler.length) | 0
);
truncatedStringFiller += Substring(filler, 0, fillLen % filler.length);
if (padEnd === true) {
return str + truncatedStringFiller;
}
return truncatedStringFiller + str;
}
function String_pad_start(maxLength, fillString = " ") {
return callFunction(String_pad, this, maxLength, fillString, false);
}
function String_pad_end(maxLength, fillString = " ") {
return callFunction(String_pad, this, maxLength, fillString, true);
}
function Substring(str, from, length) {
;;
;;
;;
return SubstringKernel(
str,
std_Math_max(from, 0) | 0,
std_Math_max(length, 0) | 0
);
}
function String_replace(searchValue, replaceValue) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("replace", this);
}
if (IsObject(searchValue)) {
if (IsOptimizableRegExpObject(searchValue)) {
return callFunction(RegExpReplace, searchValue, this, replaceValue);
}
var replacer = GetMethod(searchValue, GetBuiltinSymbol("replace"));
if (replacer !== undefined) {
return callContentFunction(replacer, searchValue, this, replaceValue);
}
}
var string = ToString(this);
var searchString = ToString(searchValue);
if (typeof replaceValue === "string") {
return StringReplaceString(string, searchString, replaceValue);
}
if (!IsCallable(replaceValue)) {
return StringReplaceString(string, searchString, ToString(replaceValue));
}
var pos = callFunction(std_String_indexOf, string, searchString);
if (pos === -1) {
return string;
}
var replStr = ToString(
callContentFunction(replaceValue, undefined, searchString, pos, string)
);
var tailPos = pos + searchString.length;
var newString;
if (pos === 0) {
newString = "";
} else {
newString = Substring(string, 0, pos);
}
newString += replStr;
var stringLength = string.length;
if (tailPos < stringLength) {
newString += Substring(string, tailPos, stringLength - tailPos);
}
return newString;
}
function String_replaceAll(searchValue, replaceValue) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("replaceAll", this);
}
if (IsObject(searchValue)) {
if (IsRegExp(searchValue)) {
var flags = searchValue.flags;
if (IsNullOrUndefined(flags)) {
ThrowTypeError(111);
}
if (!callFunction(std_String_includes, ToString(flags), "g")) {
ThrowTypeError(112, "replaceAll");
}
}
if (IsOptimizableRegExpObject(searchValue)) {
return callFunction(RegExpReplace, searchValue, this, replaceValue);
}
var replacer = GetMethod(searchValue, GetBuiltinSymbol("replace"));
if (replacer !== undefined) {
return callContentFunction(replacer, searchValue, this, replaceValue);
}
}
var string = ToString(this);
var searchString = ToString(searchValue);
if (!IsCallable(replaceValue)) {
return StringReplaceAllString(string, searchString, ToString(replaceValue));
}
var searchLength = searchString.length;
var advanceBy = std_Math_max(1, searchLength);
var endOfLastMatch = 0;
var result = "";
var position = 0;
while (true) {
var nextPosition = callFunction(
std_String_indexOf,
string,
searchString,
position
);
if (nextPosition < position) {
break;
}
position = nextPosition;
var replacement = ToString(
callContentFunction(
replaceValue,
undefined,
searchString,
position,
string
)
);
var stringSlice = Substring(
string,
endOfLastMatch,
position - endOfLastMatch
);
result += stringSlice + replacement;
endOfLastMatch = position + searchLength;
position += advanceBy;
}
if (endOfLastMatch < string.length) {
result += Substring(string, endOfLastMatch, string.length - endOfLastMatch);
}
return result;
}
function String_search(regexp) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("search", this);
}
var isPatternString = typeof regexp === "string";
if (IsObject(regexp)) {
if (IsOptimizableRegExpObject(regexp)) {
return callFunction(RegExpSearch, regexp, this);
}
var searcher = GetMethod(regexp, GetBuiltinSymbol("search"));
if (searcher !== undefined) {
return callContentFunction(searcher, regexp, this);
}
}
var string = ToString(this);
if (isPatternString && IsRegExpPrototypeOptimizable()) {
var flatResult = FlatStringSearch(string, regexp);
if (flatResult !== -2) {
return flatResult;
}
}
var rx = RegExpCreate(regexp);
return callContentFunction(
GetMethod(rx, GetBuiltinSymbol("search")),
rx,
string
);
}
function String_split(separator, limit) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("split", this);
}
if (typeof this === "string") {
if (typeof separator === "string") {
if (limit === undefined) {
return StringSplitString(this, separator);
}
}
}
if (IsObject(separator)) {
if (IsOptimizableRegExpObject(separator)) {
return callFunction(RegExpSplit, separator, this, limit);
}
var splitter = GetMethod(separator, GetBuiltinSymbol("split"));
if (splitter !== undefined) {
return callContentFunction(splitter, separator, this, limit);
}
}
var S = ToString(this);
var R;
if (limit !== undefined) {
var lim = limit >>> 0;
R = ToString(separator);
if (lim === 0) {
return [];
}
if (separator === undefined) {
return [S];
}
return StringSplitStringLimit(S, R, lim);
}
R = ToString(separator);
if (separator === undefined) {
return [S];
}
return StringSplitString(S, R);
}
function String_substring(start, end) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("substring", this);
}
var str = ToString(this);
var len = str.length;
var intStart = ToInteger(start);
var intEnd = end === undefined ? len : ToInteger(end);
var finalStart = std_Math_min(std_Math_max(intStart, 0), len);
var finalEnd = std_Math_min(std_Math_max(intEnd, 0), len);
var from = std_Math_min(finalStart, finalEnd);
var to = std_Math_max(finalStart, finalEnd);
return SubstringKernel(str, from | 0, (to - from) | 0);
}
SetIsInlinableLargeFunction(String_substring);
function String_substr(start, length) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("substr", this);
}
var str = ToString(this);
var intStart = ToInteger(start);
var size = str.length;
var end = length === undefined ? size : ToInteger(length);
if (intStart < 0) {
intStart = std_Math_max(intStart + size, 0);
} else {
intStart = std_Math_min(intStart, size);
}
var resultLength = std_Math_min(std_Math_max(end, 0), size - intStart);
;;
return SubstringKernel(str, intStart | 0, resultLength | 0);
}
SetIsInlinableLargeFunction(String_substr);
function String_concat(arg1) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("concat", this);
}
var str = ToString(this);
if (ArgumentsLength() === 0) {
return str;
}
if (ArgumentsLength() === 1) {
return str + ToString(GetArgument(0));
}
if (ArgumentsLength() === 2) {
return str + ToString(GetArgument(0)) + ToString(GetArgument(1));
}
var result = str;
for (var i = 0; i < ArgumentsLength(); i++) {
var nextString = ToString(GetArgument(i));
result += nextString;
}
return result;
}
function String_slice(start, end) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("slice", this);
}
var str = ToString(this);
var len = str.length;
var intStart = ToInteger(start);
var intEnd = end === undefined ? len : ToInteger(end);
var from =
intStart < 0
? std_Math_max(len + intStart, 0)
: std_Math_min(intStart, len);
var to =
intEnd < 0 ? std_Math_max(len + intEnd, 0) : std_Math_min(intEnd, len);
var span = std_Math_max(to - from, 0);
return SubstringKernel(str, from | 0, span | 0);
}
SetIsInlinableLargeFunction(String_slice);
function String_repeat(count) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("repeat", this);
}
var S = ToString(this);
var n = ToInteger(count);
if (n < 0) {
ThrowRangeError(108);
}
if (!(n * S.length <= ((1 << 30) - 2))) {
ThrowRangeError(110);
}
;;
;;
n = n & (((1 << 30) - 2) + 1);
var T = "";
for (;;) {
if (n & 1) {
T += S;
}
n >>= 1;
if (n) {
S += S;
} else {
break;
}
}
return T;
}
function String_iterator() {
if (IsNullOrUndefined(this)) {
ThrowTypeError(
4,
"String",
"Symbol.iterator",
ToString(this)
);
}
var S = ToString(this);
var iterator = NewStringIterator();
UnsafeSetReservedSlot(iterator, 0, S);
UnsafeSetReservedSlot(iterator, 1, 0);
return iterator;
}
function StringIteratorNext() {
var obj = this;
if (!IsObject(obj) || (obj = GuardToStringIterator(obj)) === null) {
return callFunction(
CallStringIteratorMethodIfWrapped,
this,
"StringIteratorNext"
);
}
var S = UnsafeGetStringFromReservedSlot(obj, 0);
var index = UnsafeGetInt32FromReservedSlot(obj, 1);
var size = S.length;
var result = { value: undefined, done: false };
if (index >= size) {
result.done = true;
return result;
}
var codePoint = callFunction(std_String_codePointAt, S, index);
var charCount = 1 + (codePoint > 0xffff);
UnsafeSetReservedSlot(obj, 1, index + charCount);
result.value = callFunction(std_String_fromCodePoint, null, codePoint);
return result;
}
SetIsInlinableLargeFunction(StringIteratorNext);
function String_static_raw(callSite ) {
var cooked = ToObject(callSite);
var raw = ToObject(cooked.raw);
var literalSegments = ToLength(raw.length);
if (literalSegments === 0) {
return "";
}
if (literalSegments === 1) {
return ToString(raw[0]);
}
var resultString = ToString(raw[0]);
for (var nextIndex = 1; nextIndex < literalSegments; nextIndex++) {
if (nextIndex < ArgumentsLength()) {
resultString += ToString(GetArgument(nextIndex));
}
resultString += ToString(raw[nextIndex]);
}
return resultString;
}
function String_big() {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("big", this);
}
return "<big>" + ToString(this) + "</big>";
}
function String_blink() {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("blink", this);
}
return "<blink>" + ToString(this) + "</blink>";
}
function String_bold() {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("bold", this);
}
return "<b>" + ToString(this) + "</b>";
}
function String_fixed() {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("fixed", this);
}
return "<tt>" + ToString(this) + "</tt>";
}
function String_italics() {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("italics", this);
}
return "<i>" + ToString(this) + "</i>";
}
function String_small() {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("small", this);
}
return "<small>" + ToString(this) + "</small>";
}
function String_strike() {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("strike", this);
}
return "<strike>" + ToString(this) + "</strike>";
}
function String_sub() {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("sub", this);
}
return "<sub>" + ToString(this) + "</sub>";
}
function String_sup() {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("sup", this);
}
return "<sup>" + ToString(this) + "</sup>";
}
function EscapeAttributeValue(v) {
var inputStr = ToString(v);
return StringReplaceAllString(inputStr, '"', """);
}
function String_anchor(name) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("anchor", this);
}
var S = ToString(this);
return '<a name="' + EscapeAttributeValue(name) + '">' + S + "</a>";
}
function String_fontcolor(color) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("fontcolor", this);
}
var S = ToString(this);
return '<font color="' + EscapeAttributeValue(color) + '">' + S + "</font>";
}
function String_fontsize(size) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("fontsize", this);
}
var S = ToString(this);
return '<font size="' + EscapeAttributeValue(size) + '">' + S + "</font>";
}
function String_link(url) {
if (IsNullOrUndefined(this)) {
ThrowIncompatibleMethod("link", this);
}
var S = ToString(this);
return '<a href="' + EscapeAttributeValue(url) + '">' + S + "</a>";
}
function SetConstructorInit(iterable) {
var set = this;
var adder = set.add;
if (!IsCallable(adder)) {
ThrowTypeError(12, typeof adder);
}
for (var nextValue of allowContentIter(iterable)) {
callContentFunction(adder, set, nextValue);
}
}
function SetForEach(callbackfn, thisArg = undefined) {
var S = this;
if (!IsObject(S) || (S = GuardToSetObject(S)) === null) {
return callFunction(
CallSetMethodIfWrapped,
this,
callbackfn,
thisArg,
"SetForEach"
);
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var values = callFunction(std_Set_values, S);
var setIterationResult = globalSetIterationResult;
while (true) {
var done = GetNextSetEntryForIterator(values, setIterationResult);
if (done) {
break;
}
var value = setIterationResult[0];
setIterationResult[0] = null;
callContentFunction(callbackfn, thisArg, value, value, S);
}
}
function $SetSpecies() {
return this;
}
SetCanonicalName($SetSpecies, "get [Symbol.species]");
var globalSetIterationResult = CreateSetIterationResult();
function SetIteratorNext() {
var O = this;
if (!IsObject(O) || (O = GuardToSetIterator(O)) === null) {
return callFunction(
CallSetIteratorMethodIfWrapped,
this,
"SetIteratorNext"
);
}
var setIterationResult = globalSetIterationResult;
var retVal = { value: undefined, done: true };
var done = GetNextSetEntryForIterator(O, setIterationResult);
if (!done) {
var itemKind = UnsafeGetInt32FromReservedSlot(O, 1);
var result;
if (itemKind === 1) {
result = setIterationResult[0];
} else {
;;
result = [setIterationResult[0], setIterationResult[0]];
}
setIterationResult[0] = null;
retVal.value = result;
retVal.done = false;
}
return retVal;
}
function GetSetRecord(obj) {
if (!IsObject(obj)) {
ThrowTypeError(56, obj === null ? "null" : typeof obj);
}
var rawSize = obj.size;
var numSize = +rawSize;
if (numSize !== numSize) {
if (rawSize === undefined) {
ThrowTypeError(54, "size", "undefined");
} else {
ThrowTypeError(54, "size", "NaN");
}
}
var intSize = ToInteger(numSize);
if (intSize < 0) {
ThrowRangeError(703);
}
var has = obj.has;
if (!IsCallable(has)) {
ThrowTypeError(13, "has");
}
var keys = obj.keys;
if (!IsCallable(keys)) {
ThrowTypeError(13, "keys");
}
return { set: obj, size: intSize, has, keys };
}
function GetIteratorFromMethod(setRec) {
var keysIter = callContentFunction(setRec.keys, setRec.set);
if (!IsObject(keysIter)) {
ThrowTypeError(
56,
keysIter === null ? "null" : typeof keysIter
);
}
return keysIter;
}
function SetUnion(other) {
var O = this;
if (!IsObject(O) || (O = GuardToSetObject(O)) === null) {
return callFunction(CallSetMethodIfWrapped, this, other, "SetUnion");
}
var otherRec = GetSetRecord(other);
var keysIter = GetIteratorFromMethod(otherRec);
var keysIterNext = keysIter.next;
var result = SetCopy(O);
for (var nextValue of allowContentIterWithNext(keysIter, keysIterNext)) {
callFunction(std_Set_add, result, nextValue);
}
return result;
}
function SetIntersection(other) {
var O = this;
if (!IsObject(O) || (O = GuardToSetObject(O)) === null) {
return callFunction(CallSetMethodIfWrapped, this, other, "SetIntersection");
}
var otherRec = GetSetRecord(other);
var Set = GetBuiltinConstructor("Set");
var result = new Set();
var thisSize = callFunction(std_Set_size, O);
if (thisSize <= otherRec.size) {
var values = callFunction(std_Set_values, O);
var setIterationResult = globalSetIterationResult;
while (true) {
var done = GetNextSetEntryForIterator(values, setIterationResult);
if (done) {
break;
}
var value = setIterationResult[0];
setIterationResult[0] = null;
if (callContentFunction(otherRec.has, otherRec.set, value)) {
callFunction(std_Set_add, result, value);
}
}
} else {
var keysIter = GetIteratorFromMethod(otherRec);
for (var nextValue of allowContentIterWithNext(keysIter, keysIter.next)) {
if (callFunction(std_Set_has, O, nextValue)) {
callFunction(std_Set_add, result, nextValue);
}
}
}
return result;
}
function SetDifference(other) {
var O = this;
if (!IsObject(O) || (O = GuardToSetObject(O)) === null) {
return callFunction(CallSetMethodIfWrapped, this, other, "SetDifference");
}
var otherRec = GetSetRecord(other);
var result = SetCopy(O);
var thisSize = callFunction(std_Set_size, O);
if (thisSize <= otherRec.size) {
var values = callFunction(std_Set_values, result);
var setIterationResult = globalSetIterationResult;
while (true) {
var done = GetNextSetEntryForIterator(values, setIterationResult);
if (done) {
break;
}
var value = setIterationResult[0];
setIterationResult[0] = null;
if (callContentFunction(otherRec.has, otherRec.set, value)) {
callFunction(std_Set_delete, result, value);
}
}
} else {
var keysIter = GetIteratorFromMethod(otherRec);
for (var nextValue of allowContentIterWithNext(keysIter, keysIter.next)) {
callFunction(std_Set_delete, result, nextValue);
}
}
return result;
}
function SetSymmetricDifference(other) {
var O = this;
if (!IsObject(O) || (O = GuardToSetObject(O)) === null) {
return callFunction(
CallSetMethodIfWrapped,
this,
other,
"SetSymmetricDifference"
);
}
var otherRec = GetSetRecord(other);
var keysIter = GetIteratorFromMethod(otherRec);
var keysIterNext = keysIter.next;
var result = SetCopy(O);
for (var nextValue of allowContentIterWithNext(keysIter, keysIterNext)) {
if (callFunction(std_Set_has, O, nextValue)) {
callFunction(std_Set_delete, result, nextValue);
} else {
callFunction(std_Set_add, result, nextValue);
}
}
return result;
}
function SetIsSubsetOf(other) {
var O = this;
if (!IsObject(O) || (O = GuardToSetObject(O)) === null) {
return callFunction(CallSetMethodIfWrapped, this, other, "SetIsSubsetOf");
}
var otherRec = GetSetRecord(other);
var thisSize = callFunction(std_Set_size, O);
if (thisSize > otherRec.size) {
return false;
}
var values = callFunction(std_Set_values, O);
var setIterationResult = globalSetIterationResult;
while (true) {
var done = GetNextSetEntryForIterator(values, setIterationResult);
if (done) {
break;
}
var value = setIterationResult[0];
setIterationResult[0] = null;
if (!callContentFunction(otherRec.has, otherRec.set, value)) {
return false;
}
}
return true;
}
function SetIsSupersetOf(other) {
var O = this;
if (!IsObject(O) || (O = GuardToSetObject(O)) === null) {
return callFunction(CallSetMethodIfWrapped, this, other, "SetIsSupersetOf");
}
var otherRec = GetSetRecord(other);
var thisSize = callFunction(std_Set_size, O);
if (thisSize < otherRec.size) {
return false;
}
var keysIter = GetIteratorFromMethod(otherRec);
for (var nextValue of allowContentIterWithNext(keysIter, keysIter.next)) {
if (!callFunction(std_Set_has, O, nextValue)) {
return false;
}
}
return true;
}
function SetIsDisjointFrom(other) {
var O = this;
if (!IsObject(O) || (O = GuardToSetObject(O)) === null) {
return callFunction(
CallSetMethodIfWrapped,
this,
other,
"SetIsDisjointFrom"
);
}
var otherRec = GetSetRecord(other);
var thisSize = callFunction(std_Set_size, O);
if (thisSize <= otherRec.size) {
var values = callFunction(std_Set_values, O);
var setIterationResult = globalSetIterationResult;
while (true) {
var done = GetNextSetEntryForIterator(values, setIterationResult);
if (done) {
break;
}
var value = setIterationResult[0];
setIterationResult[0] = null;
if (callContentFunction(otherRec.has, otherRec.set, value)) {
return false;
}
}
} else {
var keysIter = GetIteratorFromMethod(otherRec);
for (var nextValue of allowContentIterWithNext(keysIter, keysIter.next)) {
if (callFunction(std_Set_has, O, nextValue)) {
return false;
}
}
}
return true;
}
function ViewedArrayBufferIfReified(tarray) {
;;
var buf = UnsafeGetReservedSlot(tarray, 0);
;;
return IsObject(buf) ? buf : null;
}
function GetArrayBufferFlagsOrZero(buffer) {
if (buffer === null) {
return 0;
}
;;
if ((buffer = GuardToArrayBuffer(buffer)) === null) {
return 0;
}
return UnsafeGetInt32FromReservedSlot(buffer, 3);
}
function EnsureAttachedArrayBuffer(tarray) {
var buffer = ViewedArrayBufferIfReified(tarray);
var flags = GetArrayBufferFlagsOrZero(buffer);
if ((flags & 0x8) !== 0) {
ThrowTypeError(598);
}
}
function EnsureAttachedMutableArrayBuffer(tarray) {
var buffer = ViewedArrayBufferIfReified(tarray);
var flags = GetArrayBufferFlagsOrZero(buffer);
if ((flags & 0x8) !== 0) {
ThrowTypeError(598);
}
if ((flags & 0x80) !== 0) {
ThrowTypeError(599);
}
}
function EnsureAttachedArrayBufferMethod() {
EnsureAttachedArrayBuffer(this);
}
function EnsureTypedArrayWithArrayBuffer(arg) {
if (IsObject(arg) && IsTypedArray(arg)) {
EnsureAttachedArrayBuffer(arg);
return;
}
callFunction(
CallTypedArrayMethodIfWrapped,
arg,
"EnsureAttachedArrayBufferMethod"
);
}
function TypedArraySpeciesConstructor(obj) {
;;
var ctor = obj.constructor;
if (ctor === undefined) {
return ConstructorForTypedArray(obj);
}
if (!IsObject(ctor)) {
ThrowTypeError(56, "object's 'constructor' property");
}
var s = ctor[GetBuiltinSymbol("species")];
if (IsNullOrUndefined(s)) {
return ConstructorForTypedArray(obj);
}
if (IsConstructor(s)) {
return s;
}
ThrowTypeError(
14,
"@@species property of object's constructor"
);
}
function ValidateWritableTypedArray(obj) {
if (IsObject(obj)) {
if (IsTypedArray(obj)) {
EnsureAttachedMutableArrayBuffer(obj);
return;
}
if (IsPossiblyWrappedTypedArray(obj)) {
if (PossiblyWrappedTypedArrayHasDetachedBuffer(obj)) {
ThrowTypeError(598);
}
if (PossiblyWrappedTypedArrayHasImmutableBuffer(obj)) {
ThrowTypeError(599);
}
return;
}
}
ThrowTypeError(617);
}
function TypedArrayCreateWithLength(constructor, length) {
var newTypedArray = constructContentFunction(
constructor,
constructor,
length
);
ValidateWritableTypedArray(newTypedArray);
var len = PossiblyWrappedTypedArrayLength(newTypedArray);
if (len < length) {
ThrowTypeError(618, length, len);
}
return newTypedArray;
}
function TypedArraySpeciesCreateWithLength(exemplar, length) {
var C = TypedArraySpeciesConstructor(exemplar);
return TypedArrayCreateWithLength(C, length);
}
function TypedArrayEntries() {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
PossiblyWrappedTypedArrayLength(O);
var iteratedObject = ToObject(O); var iterator = NewArrayIterator(); UnsafeSetReservedSlot(iterator, 0, iteratedObject); UnsafeSetReservedSlot(iterator, 1, 0); UnsafeSetReservedSlot(iterator, 2, 2); return iterator;
}
function TypedArrayEvery(callbackfn ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "%TypedArray%.prototype.every");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = 0; k < len; k++) {
var kValue = O[k];
var testResult = callContentFunction(callbackfn, thisArg, kValue, k, O);
if (!testResult) {
return false;
}
}
return true;
}
SetIsInlinableLargeFunction(TypedArrayEvery);
function TypedArrayFilter(callbackfn ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "%TypedArray%.prototype.filter");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
var kept = new_List();
var captured = 0;
for (var k = 0; k < len; k++) {
var kValue = O[k];
if (callContentFunction(callbackfn, T, kValue, k, O)) {
kept[captured++] = kValue;
}
}
var A = TypedArraySpeciesCreateWithLength(O, captured);
for (var n = 0; n < captured; n++) {
A[n] = kept[n];
}
return A;
}
SetIsInlinableLargeFunction(TypedArrayFilter);
function TypedArrayFind(predicate ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "%TypedArray%.prototype.find");
}
if (!IsCallable(predicate)) {
ThrowTypeError(12, DecompileArg(0, predicate));
}
var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = 0; k < len; k++) {
var kValue = O[k];
if (callContentFunction(predicate, thisArg, kValue, k, O)) {
return kValue;
}
}
return undefined;
}
SetIsInlinableLargeFunction(TypedArrayFind);
function TypedArrayFindIndex(predicate ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(
55,
0,
"%TypedArray%.prototype.findIndex"
);
}
if (!IsCallable(predicate)) {
ThrowTypeError(12, DecompileArg(0, predicate));
}
var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = 0; k < len; k++) {
if (callContentFunction(predicate, thisArg, O[k], k, O)) {
return k;
}
}
return -1;
}
SetIsInlinableLargeFunction(TypedArrayFindIndex);
function TypedArrayForEach(callbackfn ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "TypedArray.prototype.forEach");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = 0; k < len; k++) {
callContentFunction(callbackfn, thisArg, O[k], k, O);
}
return undefined;
}
SetIsInlinableLargeFunction(TypedArrayForEach);
function TypedArrayKeys() {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
PossiblyWrappedTypedArrayLength(O);
var iteratedObject = ToObject(O); var iterator = NewArrayIterator(); UnsafeSetReservedSlot(iterator, 0, iteratedObject); UnsafeSetReservedSlot(iterator, 1, 0); UnsafeSetReservedSlot(iterator, 2, 0); return iterator;
}
function TypedArrayMap(callbackfn ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "%TypedArray%.prototype.map");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
var A = TypedArraySpeciesCreateWithLength(O, len);
for (var k = 0; k < len; k++) {
var mappedValue = callContentFunction(callbackfn, T, O[k], k, O);
A[k] = mappedValue;
}
return A;
}
SetIsInlinableLargeFunction(TypedArrayMap);
function TypedArrayReduce(callbackfn ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "%TypedArray%.prototype.reduce");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
if (len === 0 && ArgumentsLength() === 1) {
ThrowTypeError(52);
}
var k = 0;
var accumulator = ArgumentsLength() > 1 ? GetArgument(1) : O[k++];
for (; k < len; k++) {
accumulator = callContentFunction(
callbackfn,
undefined,
accumulator,
O[k],
k,
O
);
}
return accumulator;
}
function TypedArrayReduceRight(callbackfn ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(
55,
0,
"%TypedArray%.prototype.reduceRight"
);
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
if (len === 0 && ArgumentsLength() === 1) {
ThrowTypeError(52);
}
var k = len - 1;
var accumulator = ArgumentsLength() > 1 ? GetArgument(1) : O[k--];
for (; k >= 0; k--) {
accumulator = callContentFunction(
callbackfn,
undefined,
accumulator,
O[k],
k,
O
);
}
return accumulator;
}
function TypedArraySome(callbackfn ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "%TypedArray%.prototype.some");
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(0, callbackfn));
}
var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = 0; k < len; k++) {
var kValue = O[k];
var testResult = callContentFunction(callbackfn, thisArg, kValue, k, O);
if (testResult) {
return true;
}
}
return false;
}
SetIsInlinableLargeFunction(TypedArraySome);
function TypedArrayToLocaleString(locales = undefined, options = undefined) {
var array = this;
EnsureTypedArrayWithArrayBuffer(array);
var len = PossiblyWrappedTypedArrayLength(array);
if (len === 0) {
return "";
}
var firstElement = array[0];
;;
var R = ToString(
callContentFunction(
firstElement.toLocaleString,
firstElement,
locales,
options
)
);
var separator = ",";
for (var k = 1; k < len; k++) {
R += separator;
var nextElement = array[k];
if (nextElement === undefined) {
continue;
}
;;
R += ToString(
callContentFunction(
nextElement.toLocaleString,
nextElement,
locales,
options
)
);
}
return R;
}
function TypedArrayAt(index) {
var obj = this;
if (!IsObject(obj) || !IsTypedArray(obj)) {
return callFunction(
CallTypedArrayMethodIfWrapped,
obj,
index,
"TypedArrayAt"
);
}
EnsureAttachedArrayBuffer(obj);
var len = TypedArrayLength(obj);
var relativeIndex = ToInteger(index);
var k;
if (relativeIndex >= 0) {
k = relativeIndex;
} else {
k = len + relativeIndex;
}
if (k < 0 || k >= len) {
return undefined;
}
return obj[k];
}
SetIsInlinableLargeFunction(TypedArrayAt);
function TypedArrayFindLast(predicate ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(55, 0, "%TypedArray%.prototype.findLast");
}
if (!IsCallable(predicate)) {
ThrowTypeError(12, DecompileArg(0, predicate));
}
var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = len - 1; k >= 0; k--) {
var kValue = O[k];
if (callContentFunction(predicate, thisArg, kValue, k, O)) {
return kValue;
}
}
return undefined;
}
SetIsInlinableLargeFunction(TypedArrayFindLast);
function TypedArrayFindLastIndex(predicate ) {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
if (ArgumentsLength() === 0) {
ThrowTypeError(
55,
0,
"%TypedArray%.prototype.findLastIndex"
);
}
if (!IsCallable(predicate)) {
ThrowTypeError(12, DecompileArg(0, predicate));
}
var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
for (var k = len - 1; k >= 0; k--) {
if (callContentFunction(predicate, thisArg, O[k], k, O)) {
return k;
}
}
return -1;
}
SetIsInlinableLargeFunction(TypedArrayFindLastIndex);
function $TypedArrayValues() {
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
PossiblyWrappedTypedArrayLength(O);
var iteratedObject = ToObject(O); var iterator = NewArrayIterator(); UnsafeSetReservedSlot(iterator, 0, iteratedObject); UnsafeSetReservedSlot(iterator, 1, 0); UnsafeSetReservedSlot(iterator, 2, 1); return iterator;
}
SetCanonicalName($TypedArrayValues, "values");
function TypedArrayStaticFrom(source, mapfn = undefined, thisArg = undefined) {
var C = this;
if (!IsConstructor(C)) {
ThrowTypeError(14, typeof C);
}
var mapping;
if (mapfn !== undefined) {
if (!IsCallable(mapfn)) {
ThrowTypeError(12, DecompileArg(1, mapfn));
}
mapping = true;
} else {
mapping = false;
}
var T = thisArg;
var usingIterator = source[GetBuiltinSymbol("iterator")];
if (usingIterator !== undefined && usingIterator !== null) {
if (!IsCallable(usingIterator)) {
ThrowTypeError(71, DecompileArg(0, source));
}
if (!mapping && IsTypedArrayConstructor(C) && IsObject(source)) {
if (
usingIterator === $TypedArrayValues &&
IsTypedArray(source) &&
ArrayIteratorPrototypeOptimizable()
) {
EnsureAttachedArrayBuffer(source);
var len = TypedArrayLength(source);
var targetObj = constructContentFunction(C, C, len);
for (var k = 0; k < len; k++) {
targetObj[k] = source[k];
}
return targetObj;
}
if (
usingIterator === $ArrayValues &&
IsPackedArray(source) &&
ArrayIteratorPrototypeOptimizable()
) {
var targetObj = constructContentFunction(C, C, source.length);
TypedArrayInitFromPackedArray(targetObj, source);
return targetObj;
}
}
var values = IterableToList(source, usingIterator);
var len = values.length;
var targetObj = TypedArrayCreateWithLength(C, len);
for (var k = 0; k < len; k++) {
var kValue = values[k];
var mappedValue = mapping
? callContentFunction(mapfn, T, kValue, k)
: kValue;
targetObj[k] = mappedValue;
}
return targetObj;
}
var arrayLike = ToObject(source);
var len = ToLength(arrayLike.length);
var targetObj = TypedArrayCreateWithLength(C, len);
for (var k = 0; k < len; k++) {
var kValue = arrayLike[k];
var mappedValue = mapping
? callContentFunction(mapfn, T, kValue, k)
: kValue;
targetObj[k] = mappedValue;
}
return targetObj;
}
function TypedArrayStaticOf( ) {
var len = ArgumentsLength();
var C = this;
if (!IsConstructor(C)) {
ThrowTypeError(14, typeof C);
}
var newObj = TypedArrayCreateWithLength(C, len);
for (var k = 0; k < len; k++) {
newObj[k] = GetArgument(k);
}
return newObj;
}
function $TypedArraySpecies() {
return this;
}
SetCanonicalName($TypedArraySpecies, "get [Symbol.species]");
function IterableToList(items, method) {
;;
var iterator = callContentFunction(method, items);
if (!IsObject(iterator)) {
ThrowTypeError(73);
}
var nextMethod = iterator.next;
var values = [];
var i = 0;
while (true) {
var next = callContentFunction(nextMethod, iterator);
if (!IsObject(next)) {
ThrowTypeError(74, "next");
}
if (next.done) {
break;
}
DefineDataProperty(values, i++, next.value);
}
return values;
}
function $ArrayBufferSpecies() {
return this;
}
SetCanonicalName($ArrayBufferSpecies, "get [Symbol.species]");
function $SharedArrayBufferSpecies() {
return this;
}
SetCanonicalName($SharedArrayBufferSpecies, "get [Symbol.species]");
function TypedArrayCreateSameType(exemplar, length) {
;;
var constructor = ConstructorForTypedArray(exemplar);
return TypedArrayCreateWithLength(constructor, length);
}
function TypedArrayToSorted(comparefn) {
if (comparefn !== undefined) {
if (!IsCallable(comparefn)) {
ThrowTypeError(12, DecompileArg(0, comparefn));
}
}
var O = this;
EnsureTypedArrayWithArrayBuffer(O);
var len = PossiblyWrappedTypedArrayLength(O);
var A = TypedArrayCreateSameType(O, len);
for (var k = 0; k < len; k++) {
A[k] = O[k];
}
if (len > 1) {
callFunction(std_TypedArray_sort, A, comparefn);
}
return A;
}
function WeakMapConstructorInit(iterable) {
var map = this;
var adder = map.set;
if (!IsCallable(adder)) {
ThrowTypeError(12, typeof adder);
}
for (var nextItem of allowContentIter(iterable)) {
if (!IsObject(nextItem)) {
ThrowTypeError(45, "WeakMap");
}
callContentFunction(adder, map, nextItem[0], nextItem[1]);
}
}
function WeakMapGetOrInsertComputed(key, callbackfn) {
var M = this;
if (!IsObject(M) || (M = GuardToWeakMapObject(M)) === null) {
return callFunction(
CallWeakMapMethodIfWrapped,
this,
key,
callbackfn,
"WeakMapGetOrInsertComputed"
);
}
if (!IsCallable(callbackfn)) {
ThrowTypeError(12, DecompileArg(1, callbackfn));
}
if (!CanBeHeldWeakly(key)) {
ThrowTypeError(29, DecompileArg(0, key));
}
if (callFunction(std_WeakMap_has, M, key)) {
return callFunction(std_WeakMap_get, M, key);
}
var value = callContentFunction(callbackfn, undefined, key);
callFunction(std_WeakMap_set, M, key, value);
return value;
}
function WeakSetConstructorInit(iterable) {
var set = this;
var adder = set.add;
if (!IsCallable(adder)) {
ThrowTypeError(12, typeof adder);
}
for (var nextValue of allowContentIter(iterable)) {
callContentFunction(adder, set, nextValue);
}
}
function CreateSegmentDataObject(string, boundaries) {
;;
;;
var startIndex = boundaries[0];
;;
var endIndex = boundaries[1];
;;
var isWordLike = boundaries[2];
;;
;;
;;
;;
var segment = Substring(string, startIndex, endIndex - startIndex);
if (isWordLike === undefined) {
return {
segment,
index: startIndex,
input: string,
};
}
return {
segment,
index: startIndex,
input: string,
isWordLike,
};
}
function Intl_Segments_containing(index) {
var segments = this;
if (
!IsObject(segments) ||
(segments = intl_GuardToSegments(segments)) === null
) {
return callFunction(
intl_CallSegmentsMethodIfWrapped,
this,
index,
"Intl_Segments_containing"
);
}
var string = UnsafeGetStringFromReservedSlot(
segments,
1
);
var len = string.length;
var n = ToInteger(index);
if (n < 0 || n >= len) {
return undefined;
}
var boundaries = intl_FindSegmentBoundaries(segments, n | 0);
return CreateSegmentDataObject(string, boundaries);
}
function Intl_Segments_iterator() {
var segments = this;
if (
!IsObject(segments) ||
(segments = intl_GuardToSegments(segments)) === null
) {
return callFunction(
intl_CallSegmentsMethodIfWrapped,
this,
"Intl_Segments_iterator"
);
}
return intl_CreateSegmentIterator(segments);
}
function Intl_SegmentIterator_next() {
var iterator = this;
if (
!IsObject(iterator) ||
(iterator = intl_GuardToSegmentIterator(iterator)) === null)
{
return callFunction(
intl_CallSegmentIteratorMethodIfWrapped,
this,
"Intl_SegmentIterator_next"
);
}
var string = UnsafeGetStringFromReservedSlot(
iterator,
1
);
var index = UnsafeGetInt32FromReservedSlot(
iterator,
3
);
var result = { value: undefined, done: false };
if (index === string.length) {
result.done = true;
return result;
}
var boundaries = intl_FindNextSegmentBoundaries(iterator);
result.value = CreateSegmentDataObject(string, boundaries);
return result;
}
async function AsyncDisposableStackDisposeAsyncImpl() {
var asyncDisposableStack = this;
if (!IsObject(asyncDisposableStack) || (asyncDisposableStack = GuardToAsyncDisposableStackHelper(asyncDisposableStack)) === null) {
return callFunction(
CallAsyncDisposableStackMethodIfWrapped,
this,
"$AsyncDisposableStackDisposeAsync"
);
}
var state = UnsafeGetReservedSlot(asyncDisposableStack, 1);
if (state === undefined) {
ThrowTypeError(47, 'disposeAsync', 'method', 'AsyncDisposableStack');
}
if (state === 1) {
return undefined;
}
UnsafeSetReservedSlot(asyncDisposableStack, 1, 1);
var disposeCapability = UnsafeGetReservedSlot(asyncDisposableStack, 0);
UnsafeSetReservedSlot(asyncDisposableStack, 0, undefined);
if (disposeCapability === undefined) {
return undefined;
}
DisposeResourcesAsync(disposeCapability, disposeCapability.length);
return undefined;
}
function $AsyncDisposableStackDisposeAsync() {
return callFunction(AsyncDisposableStackDisposeAsyncImpl, this);
}
SetCanonicalName($AsyncDisposableStackDisposeAsync, "disposeAsync");
function $DisposableStackDispose() {
var disposableStack = this;
if (!IsObject(disposableStack) || (disposableStack = GuardToDisposableStackHelper(disposableStack)) === null) {
return callFunction(
CallDisposableStackMethodIfWrapped,
this,
"$DisposableStackDispose"
);
}
var state = UnsafeGetReservedSlot(disposableStack, 1);
if (state === 1) {
return undefined;
}
UnsafeSetReservedSlot(disposableStack, 1, 1);
var disposeCapability = UnsafeGetReservedSlot(disposableStack, 0);
UnsafeSetReservedSlot(disposableStack, 0, undefined);
if (disposeCapability === undefined) {
return undefined;
}
DisposeResourcesSync(disposeCapability, disposeCapability.length);
return undefined;
}
SetCanonicalName($DisposableStackDispose, "dispose");