poe-code 14.0.65 → 14.0.66

package/packages/safe-js/dist/interp/methods/array.js

@@ -1,8 +1,9 @@
 import { createSandboxBox } from "../boxed.js";
 import { createSandboxClosure, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet, measureSandboxData } from "../values.js";
 import { assertCollectionMutable, enterRunningState } from "../running-state.js";
+import { retainValues } from "../resources.js";
 import { getSandboxDataProperty, getSandboxPrototype } from "../object-model.js";
-import { sandboxNumber } from "../string-coercion.js";
+import { joinSandboxArray, sandboxNumber, sandboxString } from "../string-coercion.js";
 const arrayLikeSources = new WeakMap();
 const activeArrayCallbacks = new WeakMap();
 const arrayMethodNames = new Set([
@@ -117,7 +118,7 @@ export async function callArrayMethod(receiver, methodName, args, options, stack
 }
 async function arrayLikeView(receiver, options) {
     const rawLength = options.context?.getProperty !== undefined
-        ? options.context.getProperty(receiver, "length")
+        ? await options.context.getProperty(receiver, "length")
         : getSandboxDataProperty(receiver, "length", options.budget);
     const number = await sandboxNumber(rawLength, options.budget, options.context);
     const length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
@@ -192,172 +193,364 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
         case "flatMap":
             return budgetProducedValue(await flatMapArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]), options.budget);
         case "flat":
-            return budgetProducedValue(flattenArray(value, toIntegerOrInfinity(args[0] ?? 1), options.budget), options.budget);
+            return budgetProducedValue(await flattenArray(value, args[0] === undefined
+                ? 1
+                : toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context)), options), options.budget);
         case "includes":
-            return Reflect.apply(Array.prototype.includes, value, [...args]);
         case "indexOf":
-            return Reflect.apply(Array.prototype.indexOf, value, [...args]);
-        case "lastIndexOf":
-            return Reflect.apply(Array.prototype.lastIndexOf, value, [...args]);
-        case "join":
-            return options.budget.allocateString(Reflect.apply(Array.prototype.join, value, [...args]));
+        case "lastIndexOf": {
+            const length = value.length;
+            if (length === 0)
+                return methodName === "includes" ? false : -1;
+            const reverse = methodName === "lastIndexOf";
+            const start = reverse && args.length < 2
+                ? length - 1
+                : toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context));
+            let index = reverse
+                ? Math.min(start < 0 ? length + start : start, length - 1)
+                : start < 0
+                    ? Math.max(length + start, 0)
+                    : start;
+            for (; index >= 0 && index < length; index += reverse ? -1 : 1) {
+                options.budget.visitNode();
+                if (methodName !== "includes" && !(index in value))
+                    continue;
+                const entry = await readArrayElement(value, index, options);
+                if (entry === args[0] ||
+                    (methodName === "includes" && Number.isNaN(entry) && Number.isNaN(args[0])))
+                    return methodName === "includes" ? true : index;
+            }
+            return methodName === "includes" ? false : -1;
+        }
+        case "join": {
+            const length = value.length;
+            const separator = args[0] === undefined ? "," : await sandboxString(args[0], options.budget, options.context);
+            return joinSandboxArray(arrayLikeSources.get(value) ?? value, length, separator, options.budget, options.context);
+        }
         case "slice": {
             const length = value.length;
             const start = toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context));
-            const end = args[1] === undefined ? length : toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context));
+            const end = args[1] === undefined
+                ? length
+                : toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context));
             const first = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
             const final = end < 0 ? Math.max(length + end, 0) : Math.min(end, length);
             const count = Math.max(final - first, 0);
             options.budget.allocateArrayLength(count);
             const result = new Array(count);
-            for (let index = 0; index < count; index += 1) {
-                options.budget.visitNode();
-                if (first + index in value)
-                    result[index] = value[first + index];
+            const release = retainValues(options.budget, () => [result]);
+            try {
+                for (let index = 0; index < count; index += 1) {
+                    options.budget.visitNode();
+                    if (first + index in value)
+                        result[index] = await readArrayElement(value, first + index, options);
+                }
+                return budgetProducedValue(result, options.budget);
+            }
+            finally {
+                release();
+            }
+        }
+        case "concat": {
+            const result = [];
+            const retained = {};
+            options.budget.setRetainedValues(retained, () => [result]);
+            try {
+                for (const entry of [value, ...args]) {
+                    if (!Array.isArray(entry)) {
+                        options.budget.allocateArrayLength(result.length + 1);
+                        result.push(entry);
+                        continue;
+                    }
+                    const start = result.length;
+                    const length = entry.length;
+                    options.budget.allocateArrayLength(start + length);
+                    result.length += length;
+                    for (let index = 0; index < length; index++) {
+                        options.budget.visitNode();
+                        if (index in entry)
+                            result[start + index] = await readArrayElement(entry, index, options);
+                    }
+                }
+                return budgetProducedValue(result, options.budget);
+            }
+            finally {
+                options.budget.setRetainedValues(retained, undefined);
             }
-            return budgetProducedValue(result, options.budget);
         }
-        case "concat":
-            return budgetProducedValue(Reflect.apply(Array.prototype.concat, value, [...args]), options.budget);
         case "splice": {
-            const removed = Reflect.apply(Array.prototype.splice, value, [...args]);
+            const length = value.length;
+            const start = toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context));
+            const first = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
+            const inserted = Math.max(args.length - 2, 0);
+            const deleted = args.length === 0
+                ? 0
+                : args.length === 1
+                    ? length - first
+                    : Math.min(Math.max(toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context)), 0), length - first);
+            const nextLength = length + inserted - deleted;
+            if (nextLength > Number.MAX_SAFE_INTEGER)
+                throw new TypeError("Array-like length exceeds the safe integer limit.");
+            options.budget.allocateArrayLength(deleted);
+            const removed = new Array(deleted);
+            const retained = {};
+            options.budget.setRetainedValues(retained, () => [removed]);
+            try {
+                for (let index = 0; index < deleted; index++) {
+                    options.budget.visitNode();
+                    if (first + index in value)
+                        removed[index] = await readArrayElement(value, first + index, options);
+                }
+                if (inserted < deleted) {
+                    for (let index = first; index < length - deleted; index++)
+                        await moveArrayElement(value, index + deleted, index + inserted, options);
+                    for (let index = length; index > nextLength; index--)
+                        deleteArrayElement(value, index - 1, options);
+                }
+                else if (inserted > deleted) {
+                    for (let index = length - deleted; index > first; index--)
+                        await moveArrayElement(value, index + deleted - 1, index + inserted - 1, options);
+                }
+                for (let index = 0; index < inserted; index++)
+                    await writeArrayProperty(value, first + index, args[index + 2], options);
+                await writeArrayProperty(value, "length", nextLength, options);
+            }
+            finally {
+                options.budget.setRetainedValues(retained, undefined);
+            }
             budgetProducedValue(removed, options.budget);
             budgetProducedValue(value, options.budget);
             return removed;
         }
-        case "fill":
-            Reflect.apply(Array.prototype.fill, value, [...args]);
+        case "fill": {
+            const length = value.length;
+            const start = toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context));
+            const end = args[2] === undefined
+                ? length
+                : toIntegerOrInfinity(await sandboxNumber(args[2], options.budget, options.context));
+            const first = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
+            const final = end < 0 ? Math.max(length + end, 0) : Math.min(end, length);
+            for (let index = first; index < final; index++)
+                await writeArrayProperty(value, index, args[0], options);
             budgetProducedValue(value, options.budget);
             return value;
-        case "copyWithin":
-            Reflect.apply(Array.prototype.copyWithin, value, [...args]);
+        }
+        case "copyWithin": {
+            const length = value.length;
+            const target = toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context));
+            const start = toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context));
+            const end = args[2] === undefined
+                ? length
+                : toIntegerOrInfinity(await sandboxNumber(args[2], options.budget, options.context));
+            let to = target < 0 ? Math.max(length + target, 0) : Math.min(target, length);
+            let from = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
+            const final = end < 0 ? Math.max(length + end, 0) : Math.min(end, length);
+            let count = Math.min(final - from, length - to);
+            const direction = from < to && to < from + count ? -1 : 1;
+            if (direction < 0) {
+                from += count - 1;
+                to += count - 1;
+            }
+            while (count-- > 0) {
+                await moveArrayElement(value, from, to, options);
+                from += direction;
+                to += direction;
+            }
             budgetProducedValue(value, options.budget);
             return value;
-        case "at":
-            return budgetProducedValue(Reflect.apply(Array.prototype.at, value, [...args]), options.budget);
+        }
+        case "at": {
+            const length = value.length;
+            const index = toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context));
+            const actual = index < 0 ? length + index : index;
+            return actual < 0 || actual >= length
+                ? undefined
+                : budgetProducedValue(await readArrayElement(value, actual, options), options.budget);
+        }
         case "sort":
-            if (args[0] === undefined) {
-                Reflect.apply(Array.prototype.sort, value, []);
+            await sortArray(value, args[0] === undefined ? undefined : getRequiredCallback(methodName, args[0]), options, stack);
+            budgetProducedValue(value, options.budget);
+            return value;
+        case "reverse": {
+            const length = value.length;
+            let lowerValue;
+            let upperValue;
+            const release = retainValues(options.budget, () => [lowerValue, upperValue]);
+            try {
+                for (let lower = 0; lower < Math.floor(length / 2); lower++) {
+                    options.budget.visitNode();
+                    lowerValue = upperValue = undefined;
+                    const upper = length - lower - 1;
+                    const lowerExists = lower in value;
+                    lowerValue = lowerExists ? await readArrayElement(value, lower, options) : undefined;
+                    const upperExists = upper in value;
+                    upperValue = upperExists ? await readArrayElement(value, upper, options) : undefined;
+                    if (lowerExists && upperExists) {
+                        await writeArrayProperty(value, lower, upperValue, options);
+                        await writeArrayProperty(value, upper, lowerValue, options);
+                    }
+                    else if (!lowerExists && upperExists) {
+                        await writeArrayProperty(value, lower, upperValue, options);
+                        deleteArrayElement(value, upper, options);
+                    }
+                    else if (lowerExists) {
+                        deleteArrayElement(value, lower, options);
+                        await writeArrayProperty(value, upper, lowerValue, options);
+                    }
+                }
                 budgetProducedValue(value, options.budget);
                 return value;
             }
-            await sortArray(value, getRequiredCallback(methodName, args[0]), options, stack);
-            budgetProducedValue(value, options.budget);
-            return value;
-        case "reverse":
-            Reflect.apply(Array.prototype.reverse, value, []);
-            budgetProducedValue(value, options.budget);
-            return value;
+            finally {
+                release();
+            }
+        }
         case "toSorted": {
             const length = value.length;
             options.budget.allocateArrayLength(length);
             const result = new Array(length);
-            for (let index = 0; index < length; index += 1) {
-                options.budget.visitNode();
-                result[index] = value[index];
-            }
-            if (args[0] === undefined) {
-                result.sort();
+            const release = retainValues(options.budget, () => [result]);
+            try {
+                for (let index = 0; index < length; index += 1) {
+                    options.budget.visitNode();
+                    result[index] = await readArrayElement(value, index, options);
+                }
+                await sortArray(result, args[0] === undefined ? undefined : getRequiredCallback(methodName, args[0]), options, stack);
+                return budgetProducedValue(result, options.budget);
             }
-            else {
-                await sortArray(result, getRequiredCallback(methodName, args[0]), options, stack);
+            finally {
+                release();
             }
-            return budgetProducedValue(result, options.budget);
         }
         case "toReversed": {
             const length = value.length;
             options.budget.allocateArrayLength(length);
             const result = new Array(length);
-            for (let index = 0; index < length; index += 1) {
-                options.budget.visitNode();
-                result[index] = value[length - index - 1];
+            const release = retainValues(options.budget, () => [result]);
+            try {
+                for (let index = 0; index < length; index += 1) {
+                    options.budget.visitNode();
+                    result[index] = await readArrayElement(value, length - index - 1, options);
+                }
+                return budgetProducedValue(result, options.budget);
+            }
+            finally {
+                release();
             }
-            return budgetProducedValue(result, options.budget);
         }
         case "toSpliced": {
             const length = value.length;
             const start = toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context));
             const first = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
             const inserted = Math.max(args.length - 2, 0);
-            const deleted = args.length === 0 ? 0 : args.length === 1 ? length - first
-                : Math.min(Math.max(toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context)), 0), length - first);
+            const deleted = args.length === 0
+                ? 0
+                : args.length === 1
+                    ? length - first
+                    : Math.min(Math.max(toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context)), 0), length - first);
             const resultLength = length + inserted - deleted;
             if (resultLength > Number.MAX_SAFE_INTEGER)
                 throw new TypeError("Array-like length exceeds the safe integer limit.");
             options.budget.allocateArrayLength(resultLength);
             const result = new Array(resultLength);
-            for (let index = 0; index < resultLength; index += 1) {
-                options.budget.visitNode();
-                result[index] = index < first ? value[index]
-                    : index < first + inserted ? args[index - first + 2]
-                        : value[index - inserted + deleted];
+            const release = retainValues(options.budget, () => [result]);
+            try {
+                for (let index = 0; index < resultLength; index += 1) {
+                    options.budget.visitNode();
+                    result[index] =
+                        index < first
+                            ? await readArrayElement(value, index, options)
+                            : index < first + inserted
+                                ? args[index - first + 2]
+                                : await readArrayElement(value, index - inserted + deleted, options);
+                }
+                return budgetProducedValue(result, options.budget);
+            }
+            finally {
+                release();
             }
-            return budgetProducedValue(result, options.budget);
         }
         case "with": {
             const length = value.length;
-            const index = toIntegerOrInfinity(args[0]);
+            const index = toIntegerOrInfinity(options.context === undefined
+                ? args[0]
+                : await sandboxNumber(args[0], options.budget, options.context));
             const actualIndex = index < 0 ? length + index : index;
             if (actualIndex < 0 || actualIndex >= length) {
                 throw new RangeError("Invalid index");
             }
             options.budget.allocateArrayLength(length);
             const result = [];
-            for (let position = 0; position < length; position += 1) {
-                options.budget.visitNode();
-                result[position] =
-                    position === actualIndex
-                        ? args[1]
-                        : Array.isArray(value) && !Object.hasOwn(value, position)
-                            ? undefined
-                            : value[position];
+            const release = retainValues(options.budget, () => [result]);
+            try {
+                for (let position = 0; position < length; position += 1) {
+                    options.budget.visitNode();
+                    result[position] =
+                        position === actualIndex ? args[1] : await readArrayElement(value, position, options);
+                }
+                return budgetProducedValue(result, options.budget);
+            }
+            finally {
+                release();
             }
-            return budgetProducedValue(result, options.budget);
         }
         case "push": {
-            const nextLength = appendArrayValues(value, args);
+            const nextLength = await appendArrayValues(value, args, options);
             budgetProducedValue(value, options.budget);
             return nextLength;
         }
         case "pop":
-            return budgetProducedValue(Reflect.apply(Array.prototype.pop, value, []), options.budget);
-        case "shift":
-            return budgetProducedValue(Reflect.apply(Array.prototype.shift, value, []), options.budget);
+        case "shift": {
+            const length = value.length;
+            if (length === 0) {
+                await writeArrayProperty(value, "length", 0, options);
+                return undefined;
+            }
+            const result = await readArrayElement(value, methodName === "pop" ? length - 1 : 0, options);
+            const retained = {};
+            options.budget.setRetainedValues(retained, () => [result]);
+            try {
+                if (methodName === "shift")
+                    for (let index = 1; index < length; index++)
+                        await moveArrayElement(value, index, index - 1, options);
+                deleteArrayElement(value, length - 1, options);
+                await writeArrayProperty(value, "length", length - 1, options);
+                return budgetProducedValue(result, options.budget);
+            }
+            finally {
+                options.budget.setRetainedValues(retained, undefined);
+            }
+        }
         case "unshift": {
-            const nextLength = prependArrayValues(value, args);
+            const nextLength = await prependArrayValues(value, args, options);
             budgetProducedValue(value, options.budget);
             return nextLength;
         }
     }
 }
-function appendArrayValues(target, values) {
+async function appendArrayValues(target, values, options) {
     let length = target.length;
     if (length + values.length > Number.MAX_SAFE_INTEGER)
         throw new TypeError("Array-like length exceeds the safe integer limit.");
     for (const value of values) {
-        target[length++] = value;
+        await writeArrayProperty(target, length++, value, options);
     }
-    target.length = length;
+    await writeArrayProperty(target, "length", length, options);
     return length;
 }
-function prependArrayValues(target, values) {
+async function prependArrayValues(target, values, options) {
     const originalLength = target.length;
     const length = originalLength + values.length;
     if (length > Number.MAX_SAFE_INTEGER)
         throw new TypeError("Array-like length exceeds the safe integer limit.");
     for (let index = values.length === 0 ? -1 : originalLength - 1; index >= 0; index -= 1) {
         const targetIndex = index + values.length;
-        if (index in target) {
-            target[targetIndex] = target[index];
-        }
-        else {
-            delete target[targetIndex];
-        }
+        await moveArrayElement(target, index, targetIndex, options);
     }
     for (let index = 0; index < values.length; index += 1) {
-        target[index] = values[index];
+        await writeArrayProperty(target, index, values[index], options);
     }
-    target.length = length;
+    await writeArrayProperty(target, "length", length, options);
     return length;
 }
 function isCallbackArrayMethod(methodName) {
@@ -392,6 +585,42 @@ function getRequiredCallback(methodName, value) {
     }
     return value;
 }
+function readArrayElement(value, index, options) {
+    const receiver = arrayLikeSources.get(value) ?? value;
+    return options.context?.getProperty !== undefined
+        ? options.context.getProperty(receiver, index)
+        : getSandboxDataProperty(receiver, index, options.budget);
+}
+function writeArrayProperty(value, key, entry, options) {
+    options.budget.visitNode();
+    const receiver = arrayLikeSources.get(value) ?? value;
+    if (Array.isArray(receiver)) {
+        if (key === "length")
+            options.budget.allocateArrayLength(Number(entry));
+        else if (typeof key === "number")
+            options.budget.allocateArrayLength(key + 1);
+    }
+    if (options.setProperty !== undefined)
+        return options.setProperty(receiver, String(key), entry);
+    if (!Reflect.set(receiver, key, entry))
+        throw new TypeError(`Cannot assign to read only property '${key}'.`);
+}
+function deleteArrayElement(value, index, options) {
+    options.budget.visitNode();
+    const receiver = arrayLikeSources.get(value) ?? value;
+    const deleted = options.deleteProperty === undefined
+        ? Reflect.deleteProperty(receiver, String(index))
+        : options.deleteProperty(receiver, String(index));
+    if (!deleted)
+        throw new TypeError(`Cannot delete property '${index}'.`);
+}
+async function moveArrayElement(value, from, to, options) {
+    options.budget.visitNode();
+    if (from in value)
+        await writeArrayProperty(value, to, await readArrayElement(value, from, options), options);
+    else
+        deleteArrayElement(value, to, options);
+}
 async function mapArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     options.budget.allocateArrayLength(length);
@@ -403,7 +632,7 @@ async function mapArray(value, callback, options, stack, thisValue) {
             if (!(index in value)) {
                 continue;
             }
-            result[index] = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
+            result[index] = await callArrayCallback(callback, await readArrayElement(value, index, options), index, value, options, stack, thisValue);
         }
         return result;
     }
@@ -421,7 +650,7 @@ async function filterArray(value, callback, options, stack, thisValue) {
             if (!(index in value)) {
                 continue;
             }
-            const entry = value[index];
+            const entry = await readArrayElement(value, index, options);
             if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
                 result.push(entry);
             }
@@ -436,7 +665,7 @@ async function findInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
         options.budget.visitNode();
-        const entry = index in value ? value[index] : undefined;
+        const entry = await readArrayElement(value, index, options);
         if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return entry;
         }
@@ -447,7 +676,7 @@ async function findIndexInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
         options.budget.visitNode();
-        const entry = index in value ? value[index] : undefined;
+        const entry = await readArrayElement(value, index, options);
         if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return index;
         }
@@ -458,7 +687,7 @@ async function findLastInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = length - 1; index >= 0; index -= 1) {
         options.budget.visitNode();
-        const entry = index in value ? value[index] : undefined;
+        const entry = await readArrayElement(value, index, options);
         if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return entry;
         }
@@ -469,7 +698,7 @@ async function findLastIndexInArray(value, callback, options, stack, thisValue)
     const length = value.length;
     for (let index = length - 1; index >= 0; index -= 1) {
         options.budget.visitNode();
-        const entry = index in value ? value[index] : undefined;
+        const entry = await readArrayElement(value, index, options);
         if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return index;
         }
@@ -483,7 +712,7 @@ async function someInArray(value, callback, options, stack, thisValue) {
         if (!(index in value)) {
             continue;
         }
-        if (await callArrayCallback(callback, value[index], index, value, options, stack, thisValue)) {
+        if (await callArrayCallback(callback, await readArrayElement(value, index, options), index, value, options, stack, thisValue)) {
             return true;
         }
     }
@@ -496,7 +725,7 @@ async function everyInArray(value, callback, options, stack, thisValue) {
         if (!(index in value)) {
             continue;
         }
-        if (!(await callArrayCallback(callback, value[index], index, value, options, stack, thisValue))) {
+        if (!(await callArrayCallback(callback, await readArrayElement(value, index, options), index, value, options, stack, thisValue))) {
             return false;
         }
     }
@@ -511,7 +740,7 @@ async function reduceArray(value, callback, hasInitialValue, initialValue, optio
     if (start < 0) {
         throw new TypeError("Reduce of empty array with no initial value.");
     }
-    return reduceFromLeft(value, callback, value[start], start + 1, length, options, stack);
+    return reduceFromLeft(value, callback, await readArrayElement(value, start, options), start + 1, length, options, stack);
 }
 async function reduceRightArray(value, callback, hasInitialValue, initialValue, options, stack) {
     const length = value.length;
@@ -522,7 +751,7 @@ async function reduceRightArray(value, callback, hasInitialValue, initialValue,
     if (start < 0) {
         throw new TypeError("Reduce of empty array with no initial value.");
     }
-    return reduceFromRight(value, callback, value[start], start - 1, length, options, stack);
+    return reduceFromRight(value, callback, await readArrayElement(value, start, options), start - 1, length, options, stack);
 }
 async function reduceFromLeft(value, callback, accumulator, startIndex, length, options, stack) {
     let current = accumulator;
@@ -534,7 +763,12 @@ async function reduceFromLeft(value, callback, accumulator, startIndex, length,
             if (!(index in value)) {
                 continue;
             }
-            current = await options.callClosure(callback, [current, value[index], index, arrayLikeSources.get(value) ?? value], stack);
+            current = await options.callClosure(callback, [
+                current,
+                await readArrayElement(value, index, options),
+                index,
+                arrayLikeSources.get(value) ?? value
+            ], stack);
         }
         return current;
     }
@@ -552,7 +786,12 @@ async function reduceFromRight(value, callback, accumulator, startIndex, length,
             if (!(index in value)) {
                 continue;
             }
-            current = await options.callClosure(callback, [current, value[index], index, arrayLikeSources.get(value) ?? value], stack);
+            current = await options.callClosure(callback, [
+                current,
+                await readArrayElement(value, index, options),
+                index,
+                arrayLikeSources.get(value) ?? value
+            ], stack);
         }
         return current;
     }
@@ -567,7 +806,7 @@ async function forEachArray(value, callback, options, stack, thisValue) {
         if (!(index in value)) {
             continue;
         }
-        await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
+        await callArrayCallback(callback, await readArrayElement(value, index, options), index, value, options, stack, thisValue);
     }
 }
 async function flatMapArray(value, callback, options, stack, thisValue) {
@@ -580,14 +819,14 @@ async function flatMapArray(value, callback, options, stack, thisValue) {
             if (!(index in value)) {
                 continue;
             }
-            const mapped = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
+            const mapped = await callArrayCallback(callback, await readArrayElement(value, index, options), index, value, options, stack, thisValue);
             if (Array.isArray(mapped)) {
                 for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
                     options.budget.visitNode();
                     if (!(mappedIndex in mapped)) {
                         continue;
                     }
-                    result.push(mapped[mappedIndex]);
+                    result.push(await readArrayElement(mapped, mappedIndex, options));
                     options.budget.allocateArrayLength(result.length);
                 }
                 continue;
@@ -601,23 +840,32 @@ async function flatMapArray(value, callback, options, stack, thisValue) {
         options.budget.setRetainedValues(result, undefined);
     }
 }
-function flattenArray(value, depth, budget) {
+async function flattenArray(value, depth, options) {
     const result = [];
-    appendFlattenedEntries(value, depth, result, budget);
-    return result;
+    const retained = {};
+    options.budget.setRetainedValues(retained, () => [result]);
+    try {
+        await appendFlattenedEntries(value, depth, result, options);
+        return result;
+    }
+    finally {
+        options.budget.setRetainedValues(retained, undefined);
+    }
 }
-function appendFlattenedEntries(value, depth, result, budget) {
-    for (let index = 0; index < value.length; index += 1) {
+async function appendFlattenedEntries(value, depth, result, options) {
+    const length = value.length;
+    for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
         if (!(index in value)) {
             continue;
         }
-        const entry = value[index];
+        const entry = await readArrayElement(value, index, options);
         if (depth > 0 && Array.isArray(entry)) {
-            appendFlattenedEntries(entry, depth - 1, result, budget);
+            await appendFlattenedEntries(entry, depth - 1, result, options);
             continue;
         }
         result.push(entry);
-        budget.allocateArrayLength(result.length);
+        options.budget.allocateArrayLength(result.length);
     }
 }
 async function sortArray(value, comparator, options, stack) {
@@ -632,7 +880,7 @@ async function sortArray(value, comparator, options, stack) {
             if (!(index in value)) {
                 continue;
             }
-            const entry = value[index];
+            const entry = await readArrayElement(value, index, options);
             if (entry === undefined) {
                 undefinedCount += 1;
                 continue;
@@ -651,14 +899,14 @@ async function sortArray(value, comparator, options, stack) {
         }
         currentEntry = undefined;
         for (let index = 0; index < definedValues.length; index += 1) {
-            value[index] = definedValues[index];
+            await writeArrayProperty(value, index, definedValues[index], options);
         }
         for (let index = 0; index < undefinedCount; index += 1) {
-            value[definedValues.length + index] = undefined;
+            await writeArrayProperty(value, definedValues.length + index, undefined, options);
         }
         for (let index = definedValues.length + undefinedCount; index < length; index += 1) {
             options.budget.visitNode();
-            delete value[index];
+            deleteArrayElement(value, index, options);
         }
     }
     finally {
@@ -667,7 +915,18 @@ async function sortArray(value, comparator, options, stack) {
 }
 async function compareEntries(left, right, comparator, options, stack) {
     options.budget.visitNode();
-    const result = Number(await options.callClosure(comparator, [left, right], stack));
+    if (comparator === undefined) {
+        const leftString = await sandboxString(left, options.budget, options.context);
+        const release = retainValues(options.budget, () => [leftString]);
+        try {
+            const rightString = await sandboxString(right, options.budget, options.context);
+            return leftString < rightString ? -1 : leftString > rightString ? 1 : 0;
+        }
+        finally {
+            release();
+        }
+    }
+    const result = await sandboxNumber(await options.callClosure(comparator, [left, right], stack), options.budget, options.context);
     return Number.isNaN(result) ? 0 : result;
 }
 async function callArrayCallback(callback, value, index, array, options, stack, thisValue) {