@poe-platform/safe-js 0.1.291 → 0.1.293

package/dist/safe-js/chunks/{chunk-ZOLHW4OV.js → chunk-SZZFUQKW.js}

@@ -7790,6 +7790,8 @@ var regexPrototypes = /* @__PURE__ */ new WeakMap();
 var collectionPrototypes = /* @__PURE__ */ new WeakMap();
 var promisePrototypes = /* @__PURE__ */ new WeakMap();
 var datePrototypes = /* @__PURE__ */ new WeakMap();
+var arrayPrototypes = /* @__PURE__ */ new WeakMap();
+var initialArrayMethods = /* @__PURE__ */ new WeakMap();
 var initialRegexDescriptors = /* @__PURE__ */ new WeakMap();
 var intrinsicPrototypeRoots = /* @__PURE__ */ new WeakMap();
 var intrinsicConstructors = /* @__PURE__ */ new WeakMap();
@@ -7873,6 +7875,16 @@ function installDatePrototype(budget, prototype, constructor) {
   datePrototypes.set(budget, prototype);
   registerIntrinsicPrototype(budget, prototype, constructor);
 }
+function installArrayPrototype(budget, prototype, constructor) {
+  arrayPrototypes.set(budget, prototype);
+  prototypes.set(prototype, intrinsicPrototypes.get(budget) ?? null);
+  initialArrayMethods.set(prototype, new Map(Object.entries(Object.getOwnPropertyDescriptors(prototype)).map(([key, descriptor]) => [key, descriptor.value])));
+  registerIntrinsicPrototype(budget, prototype, constructor);
+}
+function isDefaultArrayMethod(value, key, budget) {
+  const prototype = arrayPrototypes.get(budget);
+  return prototype !== void 0 && getSandboxPrototype(value, budget) === prototype && !Object.hasOwn(value, key) && initialArrayMethods.get(prototype)?.has(key) === true && Object.getOwnPropertyDescriptor(prototype, key)?.value === initialArrayMethods.get(prototype)?.get(key);
+}
 function hasRegexPropertyOverride(value, keys, budget) {
   const initial = initialRegexDescriptors.get(budget);
   const prototype = regexPrototypes.get(budget);
@@ -7954,11 +7966,13 @@ function releaseObjectPrototype(budget) {
   collectionPrototypes.delete(budget);
   promisePrototypes.delete(budget);
   datePrototypes.delete(budget);
+  arrayPrototypes.delete(budget);
   initialRegexDescriptors.delete(budget);
   intrinsicPrototypes.delete(budget);
 }
 function getSandboxPrototype(value, budget) {
   if (prototypes.has(value)) return prototypes.get(value) ?? null;
+  if (budget !== void 0 && Array.isArray(value)) return arrayPrototypes.get(budget) ?? null;
   if (budget !== void 0 && isSandboxDate(value)) return datePrototypes.get(budget) ?? null;
   if (budget !== void 0 && isSandboxPromise(value)) return promisePrototypes.get(budget) ?? null;
   if (budget !== void 0 && (isSandboxMap(value) || isSandboxSet(value)))
@@ -10446,62 +10460,6 @@ function createNumericParsers(budget) {
   };
 }
 
-// packages/safe-js/src/interp/methods/number.ts
-var numberMethodNames = /* @__PURE__ */ new Set([
-  "toExponential",
-  "toFixed",
-  "toPrecision",
-  "toString"
-]);
-function getNumberMember(property, budget) {
-  if (!isNumberMethodName(property)) {
-    return void 0;
-  }
-  return createSandboxClosure({
-    sandbox: true,
-    name: `Number#${property}`,
-    call: (args, context) => callNumberMethod(context?.thisValue, property, args, budget, context)
-  });
-}
-function isNumberMethodName(property) {
-  return typeof property === "string" && numberMethodNames.has(property);
-}
-function callNumberMethod(value, methodName, args, budget, context) {
-  if (isSandboxBox(value)) value = boxedValue(value);
-  if (typeof value !== "number") {
-    throw new TypeError(`Number#${methodName} requires a number receiver.`);
-  }
-  const argument = args[0];
-  if (argument !== null && typeof argument === "object") {
-    return formatObjectArgument(value, methodName, argument, budget, context);
-  }
-  return formatNumber(value, methodName, argument === void 0 ? void 0 : +argument, budget);
-}
-async function formatObjectArgument(value, methodName, argument, budget, context) {
-  const retainedArgument = {};
-  budget.setRetainedValues(retainedArgument, () => [argument]);
-  try {
-    const number = await sandboxNumber(argument, budget, context);
-    return formatNumber(value, methodName, number, budget);
-  } finally {
-    budget.setRetainedValues(retainedArgument, void 0);
-  }
-}
-function formatNumber(value, methodName, argument, budget) {
-  let result;
-  try {
-    result = value[methodName](argument);
-  } catch (error) {
-    if (!(error instanceof RangeError)) throw error;
-    const detail = methodName === "toString" ? "radix must be between 2 and 36." : methodName === "toPrecision" ? "precision must be between 1 and 100." : "digits must be between 0 and 100.";
-    throw new RangeError(`Number#${methodName} ${detail}`);
-  }
-  return budget.allocateString(result);
-}
-
-// packages/safe-js/src/interp/methods/string.ts
-import { types as types5 } from "node:util";
-
 // packages/safe-js/src/interp/intl-options.ts
 var canonicalLocales = Intl.getCanonicalLocales;
 function readIntlProperty(value, key, budget, context) {
@@ -10557,6 +10515,162 @@ async function convertIntlOption(value, key, type, budget, context, invalid) {
   throw new RangeError(`Invalid ${key} option.`);
 }
 
+// packages/safe-js/src/interp/number-locale.ts
+var NativeNumberFormat = Intl.NumberFormat;
+var roundingIncrements = [1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1e3, 2e3, 2500, 5e3];
+async function formatNumberLocale(value, args, budget, context) {
+  let locales = [];
+  const options = /* @__PURE__ */ Object.create(null);
+  const digits = /* @__PURE__ */ Object.create(null);
+  const release = retainValues(budget, () => [value, locales, options, digits]);
+  const allocation = {};
+  try {
+    locales = await canonicalizeGuestLocales(args[0], budget, context);
+    const input = intlOptionsObject(args[1], budget);
+    const readString = async (key, type) => {
+      const raw = await readIntlProperty(input, key, budget, context);
+      if (raw === void 0) return void 0;
+      const text = type === void 0 ? await sandboxString(raw, budget, context) : await convertIntlOption(raw, key, type, budget, context);
+      if (type === void 0) budget.visitNode(text.length);
+      options[key] = text;
+      return text;
+    };
+    const numberOption = async (raw, key, minimum, maximum, fallback) => {
+      if (raw === void 0) return fallback;
+      const number = await sandboxNumber(raw, budget, context);
+      if (!Number.isFinite(number) || number < minimum || number > maximum)
+        throw new RangeError(`Invalid ${key} option.`);
+      return Math.floor(number);
+    };
+    await readString("localeMatcher", ["lookup", "best fit"]);
+    await readString("numberingSystem", "unicodeType");
+    const style = await readString("style", ["decimal", "percent", "currency", "unit"]) ?? "decimal";
+    const currency = await readString("currency");
+    if (currency === void 0) {
+      if (style === "currency") throw new TypeError("Currency formatting requires a currency.");
+    } else if (currency.length !== 3 || ![...currency].every((char) => char >= "A" && char <= "Z" || char >= "a" && char <= "z"))
+      throw new RangeError("Invalid currency code.");
+    await readString("currencyDisplay", ["code", "symbol", "narrowSymbol", "name"]);
+    await readString("currencySign", ["standard", "accounting"]);
+    const unit = await readString("unit");
+    if (unit === void 0) {
+      if (style === "unit") throw new TypeError("Unit formatting requires a unit.");
+    } else new NativeNumberFormat("en", { style: "unit", unit });
+    await readString("unitDisplay", ["short", "narrow", "long"]);
+    const notation = await readString("notation", ["standard", "scientific", "engineering", "compact"]) ?? "standard";
+    let minimumDefault = 0;
+    let maximumDefault = style === "percent" ? 0 : 3;
+    if (style === "currency" && notation === "standard") {
+      const currencyDefaults = new NativeNumberFormat("en", { style: "currency", currency }).resolvedOptions();
+      minimumDefault = currencyDefaults.minimumFractionDigits;
+      maximumDefault = currencyDefaults.maximumFractionDigits;
+    }
+    options.minimumIntegerDigits = await numberOption(await readIntlProperty(input, "minimumIntegerDigits", budget, context), "minimumIntegerDigits", 1, 21, 1);
+    for (const key of ["minimumFractionDigits", "maximumFractionDigits", "minimumSignificantDigits", "maximumSignificantDigits"])
+      digits[key] = await readIntlProperty(input, key, budget, context);
+    const increment = await numberOption(await readIntlProperty(input, "roundingIncrement", budget, context), "roundingIncrement", 1, 5e3, 1);
+    if (!roundingIncrements.includes(increment)) throw new RangeError("Invalid roundingIncrement option.");
+    options.roundingIncrement = increment;
+    await readString("roundingMode", ["ceil", "floor", "expand", "trunc", "halfCeil", "halfFloor", "halfExpand", "halfTrunc", "halfEven"]);
+    const priority = await readString("roundingPriority", ["auto", "morePrecision", "lessPrecision"]) ?? "auto";
+    await readString("trailingZeroDisplay", ["auto", "stripIfInteger"]);
+    if (increment !== 1) maximumDefault = minimumDefault;
+    const hasSignificant = digits.minimumSignificantDigits !== void 0 || digits.maximumSignificantDigits !== void 0;
+    const hasFraction = digits.minimumFractionDigits !== void 0 || digits.maximumFractionDigits !== void 0;
+    const needSignificant = priority !== "auto" || hasSignificant;
+    const needFraction = priority !== "auto" || !(hasSignificant || !hasFraction && notation === "compact");
+    if (needSignificant) {
+      const minimum = await numberOption(digits.minimumSignificantDigits, "minimumSignificantDigits", 1, 21, 1);
+      options.minimumSignificantDigits = minimum;
+      options.maximumSignificantDigits = await numberOption(digits.maximumSignificantDigits, "maximumSignificantDigits", minimum, 21, 21);
+    }
+    if (needFraction) {
+      let minimum = await numberOption(digits.minimumFractionDigits, "minimumFractionDigits", 0, 100);
+      let maximum = await numberOption(digits.maximumFractionDigits, "maximumFractionDigits", 0, 100);
+      if (minimum === void 0 && maximum === void 0) {
+        minimum = minimumDefault;
+        maximum = maximumDefault;
+      } else if (minimum === void 0) minimum = Math.min(minimumDefault, maximum);
+      else if (maximum === void 0) maximum = Math.max(maximumDefault, minimum);
+      if (minimum > maximum) throw new RangeError("minimumFractionDigits exceeds maximumFractionDigits.");
+      options.minimumFractionDigits = minimum;
+      options.maximumFractionDigits = maximum;
+    }
+    new NativeNumberFormat(locales, options);
+    await readString("compactDisplay", ["short", "long"]);
+    const grouping = await readIntlProperty(input, "useGrouping", budget, context);
+    if (grouping !== void 0) options.useGrouping = grouping === true ? true : !grouping ? false : await convertIntlOption(grouping, "useGrouping", ["min2", "auto", "always", "true", "false"], budget, context);
+    await readString("signDisplay", ["auto", "never", "always", "exceptZero", "negative"]);
+    const size = typeof value === "bigint" ? value.toString(16).length * 4 : 64;
+    budget.visitNode(size);
+    budget.setRetainedDataUsage(allocation, size);
+    const formatter = new NativeNumberFormat(locales, options);
+    return budget.allocateString(formatter.format(value));
+  } finally {
+    budget.setRetainedDataUsage(allocation, 0);
+    release();
+  }
+}
+
+// packages/safe-js/src/interp/methods/number.ts
+var numberMethodNames = /* @__PURE__ */ new Set([
+  "toExponential",
+  "toFixed",
+  "toPrecision",
+  "toString",
+  "toLocaleString"
+]);
+function getNumberMember(property, budget) {
+  if (!isNumberMethodName(property)) {
+    return void 0;
+  }
+  return createSandboxClosure({
+    sandbox: true,
+    name: `Number#${property}`,
+    ...property === "toLocaleString" ? { guest: true, name: property, length: 0 } : {},
+    call: (args, context) => callNumberMethod(context?.thisValue, property, args, budget, context)
+  });
+}
+function isNumberMethodName(property) {
+  return typeof property === "string" && numberMethodNames.has(property);
+}
+function callNumberMethod(value, methodName, args, budget, context) {
+  if (isSandboxBox(value)) value = boxedValue(value);
+  if (typeof value !== "number") {
+    throw new TypeError(`Number#${methodName} requires a number receiver.`);
+  }
+  if (methodName === "toLocaleString") return formatNumberLocale(value, args, budget, context);
+  const argument = args[0];
+  if (argument !== null && typeof argument === "object") {
+    return formatObjectArgument(value, methodName, argument, budget, context);
+  }
+  return formatNumber(value, methodName, argument === void 0 ? void 0 : +argument, budget);
+}
+async function formatObjectArgument(value, methodName, argument, budget, context) {
+  const retainedArgument = {};
+  budget.setRetainedValues(retainedArgument, () => [argument]);
+  try {
+    const number = await sandboxNumber(argument, budget, context);
+    return formatNumber(value, methodName, number, budget);
+  } finally {
+    budget.setRetainedValues(retainedArgument, void 0);
+  }
+}
+function formatNumber(value, methodName, argument, budget) {
+  let result;
+  try {
+    result = value[methodName](argument);
+  } catch (error) {
+    if (!(error instanceof RangeError)) throw error;
+    const detail = methodName === "toString" ? "radix must be between 2 and 36." : methodName === "toPrecision" ? "precision must be between 1 and 100." : "digits must be between 0 and 100.";
+    throw new RangeError(`Number#${methodName} ${detail}`);
+  }
+  return budget.allocateString(result);
+}
+
+// packages/safe-js/src/interp/methods/string.ts
+import { types as types5 } from "node:util";
+
 // packages/safe-js/src/interp/methods/string-locale.ts
 var collatorOptions = [
   ["usage", ["sort", "search"]],
@@ -11490,2060 +11604,2124 @@ function createPrimitiveConstructor(options, budget) {
   return constructor;
 }
 
-// packages/safe-js/src/interp/globals/object-array.ts
-function createObjectArrayGlobals(options) {
-  return {
-    Object: createObjectGlobal(
-      {
-        keys: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => budgetSandboxValue(ownEnumerableSandboxKeys(value), options.budget),
-          name: "keys"
-        }),
-        values: createSandboxClosure({
-          sandbox: true,
-          call: ([value], context) => context === void 0 ? allocateProducedSandboxValue(
-            ownEnumerableSandboxEntries(value).map(([, entry]) => entry),
-            options.budget
-          ) : getOwnEnumerableEntries(value, options.budget, context).then(
-            (entries) => allocateProducedSandboxValue(
-              entries.map(([, entry]) => entry),
-              options.budget
-            )
-          ),
-          name: "values"
-        }),
-        entries: createSandboxClosure({
-          sandbox: true,
-          call: ([value], context) => context === void 0 ? allocateProducedSandboxValue(ownEnumerableSandboxEntries(value), options.budget) : getOwnEnumerableEntries(value, options.budget, context).then(
-            (entries) => allocateProducedSandboxValue(entries, options.budget)
-          ),
-          name: "entries"
-        }),
-        hasOwn: createSandboxClosure({
-          sandbox: true,
-          call: ([value, key], context) => {
-            if (value === null || value === void 0)
-              throw new TypeError("Cannot convert undefined or null to object.");
-            const name = toPropertyKey(key, options.budget, context);
-            return typeof name === "string" || typeof name === "symbol" ? hasOwnSandboxProperty(value, name, false) : name.then((property) => hasOwnSandboxProperty(value, property, false));
-          },
-          name: "hasOwn"
-        }),
-        getOwnPropertyDescriptor: createSandboxClosure({
-          sandbox: true,
-          call: async ([value, key], context) => {
-            const descriptor = Object.getOwnPropertyDescriptor(
-              reflectionProperties(value),
-              await toPropertyKey(key, options.budget, context)
-            );
-            if (descriptor === void 0) return void 0;
-            return allocateProducedSandboxValue(
-              exposePropertyDescriptor(descriptor),
-              options.budget
-            );
-          },
-          name: "getOwnPropertyDescriptor"
-        }),
-        getOwnPropertyDescriptors: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => {
-            const descriptors2 = /* @__PURE__ */ Object.create(null);
-            const properties = reflectionProperties(value);
-            for (const key of [...Object.getOwnPropertyNames(properties), ...ownSandboxSymbolKeys(value)])
-              defineOwnDataProperty(descriptors2, key, exposePropertyDescriptor(Object.getOwnPropertyDescriptor(properties, key)));
-            return allocateProducedSandboxValue(descriptors2, options.budget);
-          },
-          name: "getOwnPropertyDescriptors"
-        }),
-        getOwnPropertyNames: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => budgetSandboxValue(Object.getOwnPropertyNames(reflectionProperties(value)), options.budget),
-          name: "getOwnPropertyNames"
-        }),
-        getOwnPropertySymbols: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => allocateProducedSandboxValue(ownSandboxSymbolKeys(value), options.budget),
-          name: "getOwnPropertySymbols"
-        }),
-        defineProperty: createSandboxClosure({
-          sandbox: true,
-          call: async ([value, key, descriptor], context) => {
-            objectProperties(value, true);
-            const property = await toPropertyKey(key, options.budget, context);
-            defineDataProperty(
-              value,
-              property,
-              await propertyDescriptor(descriptor, options.budget, context),
-              options.budget
-            );
-            return value;
-          },
-          name: "defineProperty"
-        }),
-        defineProperties: createSandboxClosure({
-          sandbox: true,
-          call: async ([value, descriptors2], context) => {
-            await definePropertiesFromObject(value, descriptors2, options.budget, context);
-            return value;
-          },
-          name: "defineProperties"
-        }),
-        getPrototypeOf: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => {
-            if (isSandboxMap(value) || isSandboxSet(value))
-              return getSandboxPrototype(value, options.budget);
-            if (value !== null && value !== void 0 && typeof value !== "object")
-              value = createSandboxBox(value);
-            objectProperties(value);
-            return getSandboxPrototype(value, options.budget);
-          },
-          name: "getPrototypeOf"
-        }),
-        setPrototypeOf: createSandboxClosure({
-          sandbox: true,
-          call: ([value, prototype]) => {
-            if (value === null || value === void 0)
-              throw new TypeError("Cannot set the prototype of null or undefined.");
-            if (prototype !== null && typeof prototype !== "object")
-              throw new TypeError("Prototype must be an object or null.");
-            if (typeof value !== "object") return value;
-            objectProperties(value, true);
-            if (prototype !== null) objectProperties(prototype);
-            setSandboxPrototype(value, prototype, options.budget);
-            return value;
-          },
-          name: "setPrototypeOf"
-        }),
-        create: createSandboxClosure({
-          sandbox: true,
-          call: async ([prototype, descriptors2], context) => {
-            if (prototype !== null) objectProperties(prototype);
-            const value = /* @__PURE__ */ Object.create(null);
-            setSandboxPrototype(value, prototype, options.budget);
-            if (descriptors2 !== void 0) {
-              await definePropertiesFromObject(value, descriptors2, options.budget, context);
-            }
-            return allocateProducedSandboxValue(value, options.budget);
-          },
-          name: "create"
-        }),
-        is: createSandboxClosure({
-          sandbox: true,
-          call: ([left, right]) => Reflect.apply(Object.is, Object, [left, right]),
-          name: "is"
-        }),
-        fromEntries: createSandboxClosure({
-          sandbox: true,
-          call: ([value], context) => {
-            if (context !== void 0) return acquireSandboxIterator(value, options.budget, context).then((iterator2) => {
-              if (iterator2 === void 0) throw new TypeError("Object.fromEntries requires an iterable.");
-              return objectFromSandboxEntries(value, iterator2, options.budget, context);
-            });
-            const iterator = getSandboxIterator(value, options.budget, context);
-            if (iterator === void 0) {
-              throw new TypeError("Object.fromEntries requires an iterable.");
-            }
-            if (context === void 0 && !iterator.generator && !iterator.asynchronous) {
-              return allocateProducedSandboxValue(
-                Object.setPrototypeOf(
-                  Reflect.apply(Object.fromEntries, Object, [
-                    { [Symbol.iterator]: () => iterator }
-                  ]),
-                  null
-                ),
-                options.budget
-              );
-            }
-            return objectFromSandboxEntries(value, iterator, options.budget, context);
-          },
-          name: "fromEntries"
-        }),
-        preventExtensions: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => {
-            if (isGuestHostObject(value))
-              throw new TypeError("Live host objects cannot be made non-extensible.");
-            Object.preventExtensions(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
-            return value;
-          },
-          name: "preventExtensions"
-        }),
-        isExtensible: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => Object.isExtensible(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
-          name: "isExtensible"
-        }),
-        seal: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => {
-            if (isGuestHostObject(value))
-              throw new TypeError("Live host objects cannot be sealed.");
-            Object.seal(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
-            return value;
-          },
-          name: "seal"
-        }),
-        isSealed: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => Object.isSealed(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
-          name: "isSealed"
-        }),
-        freeze: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => {
-            if (isGuestHostObject(value))
-              throw new TypeError("Live host objects cannot be frozen.");
-            if (typeof value === "object" && value !== null) {
-              Object.freeze(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
-            }
-            return value;
-          },
-          name: "freeze"
-        }),
-        isFrozen: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => Object.isFrozen(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
-          name: "isFrozen"
-        }),
-        assign: createSandboxClosure({
-          sandbox: true,
-          call: ([target, ...sources], context) => assignSandboxValues(target, sources, options.budget, context),
-          name: "assign"
-        })
-      },
-      options.budget
-    ),
-    Array: createSandboxClosure({
+// packages/safe-js/src/interp/methods/array.ts
+var arrayLikeSources = /* @__PURE__ */ new WeakMap();
+var activeArrayCallbacks = /* @__PURE__ */ new WeakMap();
+var localeArrays = /* @__PURE__ */ new WeakSet();
+var arrayMethodNames = /* @__PURE__ */ new Set([
+  "map",
+  "filter",
+  "find",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "some",
+  "every",
+  "reduce",
+  "reduceRight",
+  "forEach",
+  "flatMap",
+  "flat",
+  "includes",
+  "indexOf",
+  "lastIndexOf",
+  "join",
+  "toLocaleString",
+  "slice",
+  "concat",
+  "splice",
+  "fill",
+  "copyWithin",
+  "at",
+  "sort",
+  "reverse",
+  "toSorted",
+  "toReversed",
+  "toSpliced",
+  "with",
+  "push",
+  "pop",
+  "shift",
+  "unshift"
+]);
+function getArrayMember(value, property, options) {
+  const index = getArrayIndex(property);
+  if (index !== void 0) {
+    return Object.hasOwn(value, index) ? value[index] : void 0;
+  }
+  if (property === "length") {
+    return value.length;
+  }
+  if (Object.hasOwn(value, property)) {
+    return value[String(property)];
+  }
+  if (isArrayMethodName(property)) {
+    return createSandboxClosure({
       sandbox: true,
-      call: (args) => createArrayFromConstructorArgs(args, options.budget),
-      construct: (args) => createArrayFromConstructorArgs(args, options.budget),
-      name: "Array",
-      properties: {
-        isArray: createSandboxClosure({
-          sandbox: true,
-          call: ([value]) => Array.isArray(value),
-          name: "isArray"
-        }),
-        from: createSandboxClosure({
-          sandbox: true,
-          call: (args, context) => arrayFromSandboxValues(args, options.budget, context),
-          name: "from"
-        }),
-        of: createSandboxClosure({
-          sandbox: true,
-          call: (args) => budgetSandboxValue(Reflect.apply(Array.of, Array, [...args]), options.budget),
-          name: "of"
-        })
+      name: `Array#${property}`,
+      call: (args, context) => callArrayMethod(
+        context?.thisValue,
+        property,
+        args,
+        { ...options, context },
+        context?.stack ?? []
+      )
+    });
+  }
+  return void 0;
+}
+function getArrayIndex(property) {
+  const index = typeof property === "number" ? property : Number(property);
+  if (!Number.isSafeInteger(index) || index < 0 || index >= 2 ** 32 - 1 || String(index) !== String(property)) {
+    return void 0;
+  }
+  return index;
+}
+function isArrayMethodName(property) {
+  return typeof property === "string" && arrayMethodNames.has(property);
+}
+async function callArrayMethod(receiver, methodName, args, options, stack = []) {
+  if (receiver === null || receiver === void 0)
+    throw new TypeError("Array method requires a receiver.");
+  if (typeof receiver !== "object") {
+    receiver = createSandboxBox(receiver);
+    options.budget.chargeDataUsage(measureSandboxData([receiver]));
+  }
+  const retainedReceiver = {};
+  options.budget.setRetainedValues(retainedReceiver, () => [receiver]);
+  try {
+    const value = Array.isArray(receiver) || methodName === "concat" ? receiver : await arrayLikeView(receiver, options);
+    if (isMutatingArrayMethod(methodName)) {
+      assertCollectionMutable(receiver);
+    }
+    if (isCallbackArrayMethod(methodName)) {
+      let callbackState = activeArrayCallbacks.get(receiver);
+      if (callbackState === void 0) {
+        callbackState = { depth: 0, leave: enterRunningState(receiver) };
+        activeArrayCallbacks.set(receiver, callbackState);
       }
-    }),
-    String: createPrimitiveConstructor(
-      {
-        call: (args, context) => typeof args[0] === "symbol" ? options.budget.allocateString(String(args[0])) : sandboxString(args.length === 0 ? "" : args[0], options.budget, context),
-        name: "String",
-        properties: {
-          raw: createSandboxClosure({
-            sandbox: true,
-            call: (args, context) => stringRaw(args, options.budget, context),
-            name: "raw"
-          }),
-          fromCharCode: createSandboxClosure({
-            sandbox: true,
-            call: (args, context) => stringFromCodes(args, String.fromCharCode, options.budget, context),
-            name: "fromCharCode"
-          }),
-          fromCodePoint: createSandboxClosure({
-            sandbox: true,
-            call: (args, context) => stringFromCodes(args, String.fromCodePoint, options.budget, context),
-            name: "fromCodePoint"
-          })
+      callbackState.depth += 1;
+      try {
+        const result2 = await callArrayMethodUnlocked(value, methodName, args, options, stack);
+        return result2 === value ? receiver : result2;
+      } finally {
+        callbackState.depth -= 1;
+        if (callbackState.depth === 0) {
+          activeArrayCallbacks.delete(receiver);
+          callbackState.leave();
         }
+      }
+    }
+    const result = await callArrayMethodUnlocked(value, methodName, args, options, stack);
+    return result === value ? receiver : result;
+  } finally {
+    options.budget.setRetainedValues(retainedReceiver, void 0);
+  }
+}
+async function arrayLikeView(receiver, options) {
+  const rawLength = options.context?.getProperty !== void 0 ? 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);
+  const view = new Proxy(
+    /* @__PURE__ */ Object.create(null),
+    {
+      get: (_target, key) => {
+        options.budget.visitNode();
+        if (key === "length") return length;
+        if (typeof key !== "string") return void 0;
+        return options.context?.getProperty !== void 0 ? options.context.getProperty(receiver, key) : getSandboxDataProperty(receiver, key, options.budget);
       },
-      options.budget
-    ),
-    Number: createPrimitiveConstructor(
-      {
-        call: (args, context) => sandboxNumber(args.length === 0 ? 0 : args[0], options.budget, context, true),
-        name: "Number",
-        properties: {
-          isFinite: createSandboxClosure({
-            guest: true,
-            sandbox: true,
-            call: ([value]) => typeof value === "number" && Number.isFinite(value),
-            name: "isFinite"
-          }),
-          isNaN: createSandboxClosure({
-            guest: true,
-            sandbox: true,
-            call: ([value]) => typeof value === "number" && Number.isNaN(value),
-            name: "isNaN"
-          }),
-          isInteger: createSandboxClosure({
-            guest: true,
-            sandbox: true,
-            call: ([value]) => typeof value === "number" && Number.isInteger(value),
-            name: "isInteger"
-          }),
-          ...createNumericParsers(options.budget),
-          isSafeInteger: createSandboxClosure({
-            guest: true,
-            sandbox: true,
-            call: ([value]) => typeof value === "number" && Number.isSafeInteger(value),
-            name: "isSafeInteger"
-          }),
-          MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,
-          MIN_SAFE_INTEGER: Number.MIN_SAFE_INTEGER,
-          EPSILON: Number.EPSILON,
-          MAX_VALUE: Number.MAX_VALUE,
-          MIN_VALUE: Number.MIN_VALUE,
-          NaN: Number.NaN,
-          NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
-          POSITIVE_INFINITY: Number.POSITIVE_INFINITY
+      has: (_target, key) => {
+        options.budget.visitNode();
+        if (typeof key === "string" && options.hasProperty !== void 0)
+          return options.hasProperty(receiver, key);
+        for (let current = receiver; current !== null; current = getSandboxPrototype(current, options.budget)) {
+          options.budget.visitNode();
+          if (Object.hasOwn(current, key)) return true;
         }
+        return false;
       },
-      options.budget
-    ),
-    Boolean: createPrimitiveConstructor(
-      {
-        call: ([value]) => Boolean(value),
-        name: "Boolean"
+      set: (_target, key, entry) => {
+        options.budget.visitNode();
+        if (typeof key !== "string") throw new TypeError("Array indices must be string keys.");
+        if (options.setProperty !== void 0) options.setProperty(receiver, key, entry);
+        else if (!Reflect.set(receiver, key, entry))
+          throw new TypeError(`Cannot assign property '${key}'.`);
+        return true;
       },
-      options.budget
-    )
-  };
-}
-async function objectFromSandboxEntries(items, iterator, budget, context) {
-  const object = /* @__PURE__ */ Object.create(null);
-  let entry;
-  let key;
-  let value;
-  let failure;
-  const retained = {};
-  budget.setRetainedValues(retained, () => [
-    items,
-    iterator.retainedValue,
-    object,
-    entry,
-    key,
-    value,
-    failure
-  ]);
-  const checkData = createDataCheckpoint(budget, context);
-  const closeOnThrow = async (error) => {
-    failure = isCapturedException(error) ? error.reason : error;
-    try {
-      await closeIterator(iterator, true);
-    } catch (closeError) {
-      if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
-    }
-    throw error;
-  };
-  try {
-    checkData(object, 0, true);
-    while (true) {
-      try {
-        budget.visitNode();
-      } catch (error) {
-        await closeOnThrow(error);
-      }
-      const result = await iterator.next();
-      if (typeof result !== "object" || result === null) {
-        throw new TypeError("Iterator result must be an object.");
-      }
-      if ((await readIteratorResult(iterator, result, "done")).value) break;
-      entry = (await readIteratorResult(iterator, result, "value")).value;
-      try {
-        if (typeof entry !== "object" || entry === null) {
-          throw new TypeError("Object.fromEntries requires entry objects.");
-        }
-        key = context?.getProperty !== void 0 ? await context.getProperty(entry, 0) : getSandboxDataProperty(entry, 0, budget);
-        value = context?.getProperty !== void 0 ? await context.getProperty(entry, 1) : getSandboxDataProperty(entry, 1, budget);
-        const property = await toPropertyKey(key, budget, context);
-        const growth = (typeof property === "symbol" ? property.description?.length ?? 0 : property.length) + 1 + (budget.limits.dataSize === void 0 ? 0 : measureSandboxData([value]));
-        budget.visitNode();
-        defineOwnDataProperty(object, property, value);
-        entry = key = value = void 0;
-        checkData(object, growth);
-      } catch (error) {
-        await closeOnThrow(error);
+      deleteProperty: (_target, key) => {
+        options.budget.visitNode();
+        if (typeof key === "string" && options.deleteProperty !== void 0)
+          return options.deleteProperty(receiver, key);
+        return Reflect.deleteProperty(receiver, key);
       }
     }
-    checkData(object, 0, true);
-    return allocateProducedSandboxValue(object, budget);
-  } finally {
-    budget.setRetainedValues(retained, void 0);
-  }
+  );
+  arrayLikeSources.set(view, receiver);
+  return view;
 }
-function assignSandboxValues(target, sources, budget, context) {
-  if (target === null || target === void 0) {
-    throw new TypeError("Object.assign(target, ...sources) requires a non-null target.");
-  }
-  if (typeof target !== "object") {
-    target = createSandboxBox(target);
-    budget.chargeDataUsage(measureSandboxData([target]));
-  }
-  if (!isGuestHostObject(target)) objectProperties(target, true);
-  if (context === void 0) {
-    for (const source of sources) {
-      if (source === null || source === void 0) continue;
-      const properties = isGuestHostObject(source) ? void 0 : reflectionProperties(source);
-      const keys = properties === void 0 ? ownEnumerableSandboxKeys(source, true) : [...Object.getOwnPropertyNames(properties), ...ownSandboxSymbolKeys(source)];
-      for (const key of keys) {
-        if (!hasOwnSandboxProperty(source, key, true)) continue;
-        const value = properties === void 0 ? getSandboxDataProperty(source, key, budget) : Reflect.get(properties, key, source);
-        setSandboxProperty(target, key, value, budget);
-      }
-    }
-    return target;
-  }
-  return (async () => {
-    const release = retainValues(budget, () => [target, ...sources]);
-    try {
-      for (const source of sources) {
-        if (source === null || source === void 0) continue;
-        const properties = isGuestHostObject(source) ? void 0 : reflectionProperties(source);
-        const keys = properties === void 0 ? ownEnumerableSandboxKeys(source, true) : [...Object.getOwnPropertyNames(properties), ...ownSandboxSymbolKeys(source)];
-        for (const key of keys) {
-          if (!hasOwnSandboxProperty(source, key, true)) continue;
-          const value = await (context?.getProperty !== void 0 ? context.getProperty(source, key) : isGuestHostObject(source) ? getSandboxDataProperty(source, key, budget) : readPropertyDescriptor(Object.getOwnPropertyDescriptor(properties, key), source, context, true));
-          await setSandboxProperty(target, key, value, budget, true, context);
+async function callArrayMethodUnlocked(value, methodName, args, options, stack) {
+  switch (methodName) {
+    case "toLocaleString": {
+      const receiver = arrayLikeSources.get(value) ?? value;
+      const length = value.length;
+      if (localeArrays.has(receiver)) return "";
+      localeArrays.add(receiver);
+      let text = "";
+      const release = retainValues(options.budget, () => [receiver, text, ...args]);
+      try {
+        for (let index = 0; index < length; index++) {
+          options.budget.visitNode();
+          const element = options.context?.getProperty === void 0 ? getSandboxDataProperty(receiver, String(index), options.budget) : await options.context.getProperty(receiver, String(index));
+          let part = "";
+          if (element !== null && element !== void 0) {
+            const method = options.context?.getProperty === void 0 ? getSandboxDataProperty(element, "toLocaleString", options.budget) : await options.context.getProperty(element, "toLocaleString");
+            if (!isSandboxClosure(method)) throw new TypeError("Element toLocaleString must be callable.");
+            const converted = await invokeBuiltinClosure(method, [args[0], args[1]], options.budget, options.context, element);
+            part = await sandboxString(converted, options.budget, options.context);
+          }
+          text = options.budget.allocateString(text + (index === 0 ? "" : ",") + part);
         }
+        return text;
+      } finally {
+        release();
+        localeArrays.delete(receiver);
       }
-      return target;
-    } finally {
-      release();
-    }
-  })();
-}
-function reflectionProperties(value) {
-  if (value !== null && value !== void 0 && typeof value !== "object")
-    value = createSandboxBox(value);
-  return objectProperties(value);
-}
-function objectProperties(value, mutable = false) {
-  if (isSandboxPromise(value)) return getPromiseProperties(value);
-  if (isSandboxMap(value) || isSandboxSet(value)) return getCollectionProperties(value);
-  if (isSandboxRegex(value)) return getRegexProperties(value);
-  if (isSandboxDate(value)) {
-    return value;
-  }
-  if (isGuestHostObject(value))
-    throw new TypeError("Live host object descriptors are not supported.");
-  if (isGuestClosure(value)) return materializeFunctionProperties(value);
-  if (isSandboxClosure(value)) {
-    if (mutable) throw new TypeError("Host function properties are read only.");
-    return value.properties ?? /* @__PURE__ */ Object.create(null);
-  }
-  if (!isAssignableSandboxTarget(value))
-    throw new TypeError("Expected a sandbox object or function.");
-  return value;
-}
-function exposePropertyDescriptor(descriptor) {
-  return "value" in descriptor ? descriptor : {
-    get: accessorClosure(descriptor.get),
-    set: accessorClosure(descriptor.set),
-    enumerable: descriptor.enumerable,
-    configurable: descriptor.configurable
-  };
-}
-async function propertyDescriptor(input, budget, context) {
-  objectProperties(input);
-  const descriptor = {};
-  const release = retainValues(budget, () => [
-    input,
-    descriptor.value,
-    ...retainedAccessorClosures(descriptor)
-  ]);
-  try {
-    for (const field of [
-      "enumerable",
-      "configurable",
-      "value",
-      "writable",
-      "get",
-      "set"
-    ]) {
-      if (getSandboxPropertyDescriptor(input, field, budget) === void 0 && !hasOwnSandboxProperty(input, field, false))
-        continue;
-      const value = await (context?.getProperty !== void 0 ? context.getProperty(input, field) : getSandboxDataProperty(input, field, budget));
-      if (field === "get" || field === "set") {
-        if (value !== void 0 && !isSandboxClosure(value))
-          throw new TypeError("Accessor must be a function or undefined.");
-        descriptor[field] = value === void 0 ? void 0 : accessorAdapter(value, field);
-      } else if (field === "value") {
-        descriptor.value = value;
-      } else {
-        descriptor[field] = Boolean(value);
-      }
-    }
-    if (("get" in descriptor || "set" in descriptor) && ("value" in descriptor || "writable" in descriptor))
-      throw new TypeError("A property cannot be both a data property and an accessor.");
-    return descriptor;
-  } finally {
-    release();
-  }
-}
-async function definePropertiesFromObject(target, descriptors2, budget, context) {
-  objectProperties(target, true);
-  const properties = [];
-  const release = retainValues(budget, () => [
-    target,
-    descriptors2,
-    properties,
-    ...properties.flatMap(([, descriptor]) => retainedAccessorClosures(descriptor))
-  ]);
-  try {
-    for (const key of ownEnumerableSandboxKeys(descriptors2, true)) {
-      if (!hasOwnSandboxProperty(descriptors2, key, true)) continue;
-      const descriptor = await (context?.getProperty !== void 0 ? context.getProperty(descriptors2, key) : getSandboxDataProperty(descriptors2, key, budget));
-      properties.push([key, await propertyDescriptor(descriptor, budget, context)]);
     }
-    for (const [key, descriptor] of properties) defineDataProperty(target, key, descriptor, budget);
-  } finally {
-    release();
-  }
-}
-function defineDataProperty(target, key, descriptor, budget) {
-  budget.visitNode();
-  if (isFloat32Array(target))
-    throw new TypeError("Typed array property descriptors are not supported.");
-  const properties = objectProperties(target, true);
-  if (Array.isArray(properties)) {
-    if (key === "length" && "value" in descriptor)
-      budget.allocateArrayLength(Number(descriptor.value));
-    else if (typeof key !== "symbol") {
-      const index = Number(key);
-      if (Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key) {
-        budget.allocateArrayLength(index + 1);
+    case "map":
+      return budgetProducedValue(
+        await mapArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]),
+        options.budget
+      );
+    case "filter":
+      return budgetProducedValue(
+        await filterArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]),
+        options.budget
+      );
+    case "find":
+      return budgetProducedValue(
+        await findInArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]),
+        options.budget
+      );
+    case "findIndex":
+      return await findIndexInArray(
+        value,
+        getRequiredCallback(methodName, args[0]),
+        options,
+        stack,
+        args[1]
+      );
+    case "findLast":
+      return budgetProducedValue(
+        await findLastInArray(
+          value,
+          getRequiredCallback(methodName, args[0]),
+          options,
+          stack,
+          args[1]
+        ),
+        options.budget
+      );
+    case "findLastIndex":
+      return await findLastIndexInArray(
+        value,
+        getRequiredCallback(methodName, args[0]),
+        options,
+        stack,
+        args[1]
+      );
+    case "some":
+      return await someInArray(
+        value,
+        getRequiredCallback(methodName, args[0]),
+        options,
+        stack,
+        args[1]
+      );
+    case "every":
+      return await everyInArray(
+        value,
+        getRequiredCallback(methodName, args[0]),
+        options,
+        stack,
+        args[1]
+      );
+    case "reduce":
+      return budgetProducedValue(
+        await reduceArray(
+          value,
+          getRequiredCallback(methodName, args[0]),
+          args.length > 1,
+          args[1],
+          options,
+          stack
+        ),
+        options.budget
+      );
+    case "reduceRight":
+      return budgetProducedValue(
+        await reduceRightArray(
+          value,
+          getRequiredCallback(methodName, args[0]),
+          args.length > 1,
+          args[1],
+          options,
+          stack
+        ),
+        options.budget
+      );
+    case "forEach":
+      await forEachArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]);
+      return void 0;
+    case "flatMap":
+      return budgetProducedValue(
+        await flatMapArray(
+          value,
+          getRequiredCallback(methodName, args[0]),
+          options,
+          stack,
+          args[1]
+        ),
+        options.budget
+      );
+    case "flat":
+      return budgetProducedValue(
+        await flattenArray(
+          value,
+          args[0] === void 0 ? 1 : toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context)),
+          options
+        ),
+        options.budget
+      );
+    case "includes":
+    case "indexOf":
+    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;
     }
-  }
-  Object.defineProperty(properties, key, descriptor);
-  markDescriptorObject(properties);
-}
-function isAssignableSandboxTarget(value) {
-  return typeof value === "object" && value !== null && !isSandboxClosure(value) && !isSandboxGenerator(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isSandboxPromise(value) && !isSandboxRegex(value);
-}
-async function arrayFromSandboxValues(args, budget, context) {
-  const [items, mapFn, thisValue] = args;
-  if (mapFn !== void 0 && !isSandboxClosure(mapFn)) {
-    throw new TypeError("Array.from mapping callback must be a function.");
-  }
-  if (items === null || items === void 0) {
-    throw new TypeError("Array.from requires a non-null input.");
-  }
-  const read = (property) => context?.getProperty !== void 0 ? context.getProperty(items, property) : getSandboxDataProperty(items, property, budget);
-  const iterator = context === void 0 ? getSandboxIterator(items, budget) : await acquireSandboxIterator(items, budget, context);
-  const constructor = context?.thisValue;
-  let result;
-  let currentValue;
-  let failure;
-  const retained = {};
-  budget.setRetainedValues(retained, () => [
-    items,
-    iterator?.retainedValue,
-    mapFn,
-    constructor,
-    result,
-    currentValue,
-    failure
-  ]);
-  const checkData = createDataCheckpoint(budget, context);
-  const closeOnThrow = async (error) => {
-    failure = isCapturedException(error) ? error.reason : error;
-    try {
-      if (iterator !== void 0) await closeIterator(iterator, true);
-    } catch (closeError) {
-      if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
-    }
-    throw error;
-  };
-  try {
-    let length = 0;
-    if (iterator === void 0) {
-      const number = await sandboxNumber(await read("length"), budget, context);
-      length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+    case "join": {
+      const length = value.length;
+      const separator = args[0] === void 0 ? "," : await sandboxString(args[0], options.budget, options.context);
+      return joinSandboxArray(
+        arrayLikeSources.get(value) ?? value,
+        length,
+        separator,
+        options.budget,
+        options.context
+      );
     }
-    result = isSandboxClosure(constructor) && constructor.construct !== void 0 ? await invokeBuiltinClosure(
-      constructor,
-      iterator === void 0 ? [length] : [],
-      budget,
-      context,
-      void 0,
-      true
-    ) : createArrayFromConstructorArgs([length], budget);
-    checkData(result, 0, true);
-    let index = 0;
-    while (iterator !== void 0 || index < length) {
-      try {
-        budget.visitNode();
-        if (iterator !== void 0 && index >= Number.MAX_SAFE_INTEGER)
-          throw new TypeError("Array.from input is too long.");
-      } catch (error) {
-        await closeOnThrow(error);
-      }
-      if (iterator !== void 0) {
-        const next = await iterator.next();
-        if (typeof next !== "object" || next === null)
-          throw new TypeError("Iterator result must be an object.");
-        if ((await readIteratorResult(iterator, next, "done")).value) break;
-        currentValue = (await readIteratorResult(iterator, next, "value")).value;
-      } else {
-        currentValue = await read(index);
-      }
+    case "slice": {
+      const length = value.length;
+      const start = toIntegerOrInfinity(
+        await sandboxNumber(args[0], options.budget, options.context)
+      );
+      const end = args[1] === void 0 ? 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);
+      const release = retainValues(options.budget, () => [result]);
       try {
-        if (Array.isArray(result)) budget.allocateArrayLength(index + 1);
-        if (mapFn !== void 0)
-          currentValue = await invokeBuiltinClosure(
-            mapFn,
-            [currentValue, index],
-            budget,
-            context,
-            thisValue
-          );
-        const key = String(index);
-        const growth = key.length + 1 + (Array.isArray(result) ? Math.max(0, index + 1 - result.length) : 0) + (budget.limits.dataSize === void 0 ? 0 : measureSandboxData([currentValue]));
-        budget.visitNode();
-        defineOwnDataProperty(objectProperties(result, true), key, currentValue);
-        currentValue = void 0;
-        checkData(result, growth, isSandboxClosure(result));
-      } catch (error) {
-        await closeOnThrow(error);
+        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();
       }
-      index += 1;
     }
-    setSandboxProperty(result, "length", index, budget);
-    checkData(result, 0, true);
-    return allocateProducedSandboxValue(result, budget);
-  } finally {
-    budget.setRetainedValues(retained, void 0);
-  }
-}
-function createArrayFromConstructorArgs(args, budget) {
-  if (args.length !== 1) {
-    return budgetSandboxValue(Reflect.apply(Array, Array, [...args]), budget);
-  }
-  const [lengthOrValue] = args;
-  if (typeof lengthOrValue !== "number") {
-    return budgetSandboxValue([lengthOrValue], budget);
-  }
-  if (!Number.isInteger(lengthOrValue) || lengthOrValue < 0 || lengthOrValue > 4294967295) {
-    throw new RangeError("Invalid array length.");
-  }
-  budget.allocateArrayLength(lengthOrValue);
-  const release = budget.provisionDataUsage(lengthOrValue + 1);
-  try {
-    return new Array(lengthOrValue);
-  } finally {
-    release();
-  }
-}
-async function getOwnEnumerableEntries(value, budget, context) {
-  const entries = [];
-  const release = retainValues(budget, () => [value, entries]);
-  try {
-    for (const key of ownEnumerableSandboxKeys(value)) {
-      if (!hasOwnSandboxProperty(value, key, true)) continue;
-      entries.push([
-        key,
-        await (context?.getProperty !== void 0 ? context.getProperty(value, key) : getSandboxDataProperty(value, key, budget))
-      ]);
-    }
-    return entries;
-  } finally {
-    release();
-  }
-}
-function budgetSandboxValue(value, budget) {
-  const sandboxValue = deepCopyToSandbox(value);
-  return allocateProducedSandboxValue(sandboxValue, budget);
-}
-function stringFromCodes(args, convert, budget, context) {
-  let result = "";
-  let index = 0;
-  const release = retainValues(budget, () => [...args, result]);
-  try {
-    const output = advance();
-    if (typeof output !== "string") return output.finally(release);
-    release();
-    return output;
-  } catch (error) {
-    release();
-    throw error;
-  }
-  function advance() {
-    while (index < args.length) {
-      budget.visitNode();
-      const number = sandboxNumber(args[index++], budget, context);
-      if (number instanceof Promise) return number.then((value) => {
-        result = budget.allocateString(result + convert(value));
-        return advance();
-      });
-      result = budget.allocateString(result + convert(number));
+    case "concat": {
+      const result = [];
+      const retained = {};
+      options.budget.setRetainedValues(retained, () => [result]);
+      try {
+        for (const entry of [value, ...args]) {
+          let spread = false;
+          if (entry !== null && (typeof entry === "object" || typeof entry === "function")) {
+            const flag = options.context?.getProperty !== void 0 ? await options.context.getProperty(entry, Symbol.isConcatSpreadable) : getSandboxDataProperty(entry, Symbol.isConcatSpreadable, options.budget);
+            spread = flag === void 0 ? Array.isArray(entry) : Boolean(flag);
+          }
+          if (!spread) {
+            options.budget.allocateArrayLength(result.length + 1);
+            result.push(entry);
+            continue;
+          }
+          const start = result.length;
+          const source = await arrayLikeView(entry, options);
+          const length = source.length;
+          options.budget.allocateArrayLength(start + length);
+          result.length += length;
+          for (let index = 0; index < length; index++) {
+            options.budget.visitNode();
+            if (index in source)
+              result[start + index] = await readArrayElement(source, index, options);
+          }
+        }
+        return budgetProducedValue(result, options.budget);
+      } finally {
+        options.budget.setRetainedValues(retained, void 0);
+      }
     }
-    return result;
-  }
-}
-function stringRaw(args, budget, context) {
-  const [template, ...substitutions] = args;
-  if (context?.getProperty !== void 0)
-    return (async () => {
-      if (template === null || template === void 0)
-        throw new TypeError("String.raw requires a template object.");
-      const raw2 = await context.getProperty(template, "raw");
-      if (raw2 === null || raw2 === void 0)
-        throw new TypeError("String.raw requires raw strings.");
-      const number = await sandboxNumber(
-        await context.getProperty(raw2, "length"),
-        budget,
-        context
+    case "splice": {
+      const length = value.length;
+      const start = toIntegerOrInfinity(
+        await sandboxNumber(args[0], options.budget, options.context)
       );
-      const length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
-      let result2 = "";
+      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 = {};
-      budget.setRetainedValues(retained, () => [raw2, result2]);
+      options.budget.setRetainedValues(retained, () => [removed]);
       try {
-        for (let index = 0; index < length; index++) {
-          budget.visitNode();
-          result2 = budget.allocateString(
-            result2 + await sandboxString(await context.getProperty(raw2, index), budget, context)
-          );
-          if (index + 1 < length && index < substitutions.length)
-            result2 = budget.allocateString(
-              result2 + await sandboxString(substitutions[index], budget, context)
-            );
+        for (let index = 0; index < deleted; index++) {
+          options.budget.visitNode();
+          if (first + index in value)
+            removed[index] = await readArrayElement(value, first + index, options);
         }
-        return result2;
+        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 {
-        budget.setRetainedValues(retained, void 0);
+        options.budget.setRetainedValues(retained, void 0);
       }
-    })();
-  const raw = getTemplateRawParts(template);
-  let result = "";
-  for (let index = 0; index < raw.length; index += 1) {
-    result += String(raw[index]);
-    if (index < raw.length - 1 && index < substitutions.length) {
-      result += String(substitutions[index]);
+      budgetProducedValue(removed, options.budget);
+      budgetProducedValue(value, options.budget);
+      return removed;
     }
-  }
-  return budget.allocateString(result);
-}
-function getTemplateRawParts(template) {
-  const raw = typeof template === "object" && template !== null ? template.raw : void 0;
-  if (typeof template !== "object" || template === null || isSandboxClosure(template) || isSandboxPromise(template) || !Array.isArray(raw)) {
-    throw new TypeError("String.raw requires a raw strings array.");
-  }
-  return raw;
-}
-
-// packages/safe-js/src/interp/classes.ts
-async function evaluateClass(node, context, evaluateNode2, callContext) {
-  const scope = context.scope.child();
-  if (node.id !== void 0) scope.predeclare(node.id.name, "const");
-  const classContext = { ...context, scope, inferredName: void 0 };
-  let parent;
-  let prototypeParent;
-  const fields2 = [];
-  const statics = [];
-  let constructor;
-  const release = retainValues(context.budget, () => [parent, prototypeParent, constructor, ...fields2.map((field) => field.key), ...statics.flatMap((field) => "key" in field ? [field.key] : [])]);
-  try {
-    if (node.superClass !== void 0) {
-      const result = await evaluateNode2(node.superClass, classContext);
-      if (result.kind !== "normal") return result;
-      parent = result.value;
-      if (parent !== null && (!isSandboxClosure(parent) || parent.construct === void 0))
-        throw new TypeError("Class extends value is not a constructor or null.");
-      prototypeParent = parent === null ? null : await callContext.getProperty(parent, "prototype");
-      if (prototypeParent !== null && typeof prototypeParent !== "object")
-        throw new TypeError("Class extends value has an invalid prototype.");
+    case "fill": {
+      const length = value.length;
+      const start = toIntegerOrInfinity(
+        await sandboxNumber(args[1], options.budget, options.context)
+      );
+      const end = args[2] === void 0 ? 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;
     }
-    const derived = node.superClass !== void 0;
-    constructor = createClassConstructor(node, { ...classContext, inferredName: context.inferredName }, evaluateNode2, fields2);
-    const properties = materializeFunctionProperties(constructor);
-    const prototype = properties.prototype;
-    Object.defineProperty(properties, "prototype", { writable: false });
-    if (derived) setSandboxPrototype(prototype, prototypeParent, context.budget);
-    if (isSandboxClosure(parent)) setSandboxPrototype(constructor, parent, context.budget);
-    const pattern = createPatternContext(classContext, scope, evaluateNode2);
-    for (const element of node.body.body) {
-      context.budget.visitNode();
-      if (element.type === "StaticBlock") {
-        statics.push({ element });
-        continue;
+    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] === void 0 ? 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;
       }
-      if (element.type === "MethodDefinition" && element.kind === "constructor") continue;
-      let key;
-      if (element.computed) {
-        const result = await evaluateNode2(element.key, classContext);
-        if (result.kind !== "normal") return result;
-        key = await pattern.toPropertyKey(result.value);
-      } else {
-        key = element.key.type === "Identifier" ? element.key.name : String(element.key.value);
-      }
-      if (typeof key === "string") context.budget.allocateString(key);
-      if (element.type === "PropertyDefinition") {
-        (element.static ? statics : fields2).push({ element, key });
-      } else {
-        const home = element.static ? constructor : prototype;
-        const method = createInterpretedClosure(element.value, classContext, evaluateNode2, home);
-        const accessor = element.kind === "get" || element.kind === "set" ? element.kind : void 0;
-        Object.defineProperty(materializeFunctionProperties(method), "name", {
-          value: accessor === void 0 ? propertyFunctionName(key) : `${accessor} ${propertyFunctionName(key)}`
-        });
-        Object.defineProperty(
-          element.static ? properties : prototype,
-          key,
-          accessor === void 0 ? { value: method, configurable: true, writable: true, enumerable: false } : { [accessor]: accessorAdapter(method, accessor), configurable: true, enumerable: false }
-        );
+      while (count-- > 0) {
+        await moveArrayElement(value, from, to, options);
+        from += direction;
+        to += direction;
       }
+      budgetProducedValue(value, options.budget);
+      return value;
     }
-    if (node.id !== void 0) scope.declare(node.id.name, "const", constructor);
-    for (const element of statics) await initializeElement(element, constructor, constructor, classContext, evaluateNode2);
-    classOrigins.get(constructor).initialized = true;
-    if (node.type === "ClassDeclaration") {
-      context.scope.declare(node.id.name, "let", constructor);
-      return { kind: "normal", hasValue: false, value: void 0 };
+    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 ? void 0 : budgetProducedValue(await readArrayElement(value, actual, options), options.budget);
     }
-    return { kind: "normal", hasValue: true, value: constructor };
-  } finally {
-    release();
-  }
-}
-var classOrigins = /* @__PURE__ */ new WeakMap();
-function createClassConstructor(node, context, evaluateNode2, fields2) {
-  const scope = context.scope;
-  const classContext = { ...context, inferredName: void 0 };
-  const constructorElement = node.body.body.find((element) => element.type === "MethodDefinition" && element.kind === "constructor");
-  const derived = node.superClass !== void 0;
-  const constructor = createSandboxClosure({
-    guest: true,
-    sandbox: true,
-    name: node.id?.name ?? context.inferredName ?? "",
-    length: constructorElement === void 0 ? 0 : getFunctionLength(constructorElement.value.params),
-    sourceRange: functionSources.get(node),
-    retainedValues: () => [...scope.retainedValues(), ...fields2.map((field) => field.key)],
-    call: () => {
-      throw new TypeError("Class constructor cannot be invoked without 'new'.");
-    },
-    construct: async (args, invocation) => {
-      const prototype = materializeFunctionProperties(constructor).prototype;
-      const newTarget = invocation?.newTarget ?? constructor;
-      let thisValue;
-      let thisScope;
-      let initialized = !derived;
-      const initializeFields = async (receiver) => {
-        for (const field of fields2) {
-          await initializeElement(field, receiver, prototype, classContext, evaluateNode2);
+    case "sort":
+      await sortArray(
+        value,
+        args[0] === void 0 ? void 0 : 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 = void 0;
+          const upper = length - lower - 1;
+          const lowerExists = lower in value;
+          lowerValue = lowerExists ? await readArrayElement(value, lower, options) : void 0;
+          const upperExists = upper in value;
+          upperValue = upperExists ? await readArrayElement(value, upper, options) : void 0;
+          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);
+          }
         }
-      };
-      const superCall = async (argumentsList) => {
-        const superConstructor = getSandboxPrototype(constructor, context.budget);
-        if (!isSandboxClosure(superConstructor) || superConstructor.construct === void 0)
-          throw new TypeError("Super constructor is not a constructor.");
-        const receiver = await invocation.invokeClosure(superConstructor, argumentsList, void 0, true, newTarget);
-        if (initialized) throw new ReferenceError("Super constructor may only initialize this once.");
-        initialized = true;
-        thisValue = receiver;
-        thisScope?.declare("this", "const", receiver);
-        await initializeFields(receiver);
-        return receiver;
-      };
-      if (!derived) {
-        thisValue = {};
-        const targetPrototype = await invocation.getProperty(newTarget, "prototype");
-        if (typeof targetPrototype === "object" && targetPrototype !== null)
-          setSandboxPrototype(thisValue, targetPrototype, context.budget);
-      }
-      if (constructorElement === void 0) {
-        if (derived) return superCall(args);
-        await initializeFields(thisValue);
-        return thisValue;
+        budgetProducedValue(value, options.budget);
+        return value;
+      } finally {
+        release();
       }
-      const result = await executeClosure(constructorElement.value, args, thisValue, {
-        ...classContext,
-        compilation: invocation?.compilation ?? context.compilation,
-        callStack: [...invocation?.stack ?? context.callStack],
-        functionEnvironment: {
-          newTarget,
-          homeObject: prototype,
-          construction: {
-            derived,
-            superCall,
-            initialize: async (functionScope) => {
-              thisScope = functionScope;
-              if (!derived) await initializeFields(thisValue);
-            }
-          }
+    }
+    case "toSorted": {
+      const length = value.length;
+      options.budget.allocateArrayLength(length);
+      const result = new Array(length);
+      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);
         }
-      }, evaluateNode2);
-      if (typeof result === "object" && result !== null) return result;
-      if (derived && result !== void 0) throw new TypeError("Derived constructors may only return an object or undefined.");
-      if (!initialized) throw new ReferenceError("Must call super constructor before returning from derived constructor.");
-      return thisValue;
+        await sortArray(
+          result,
+          args[0] === void 0 ? void 0 : getRequiredCallback(methodName, args[0]),
+          options,
+          stack
+        );
+        return budgetProducedValue(result, options.budget);
+      } finally {
+        release();
+      }
     }
-  });
-  classOrigins.set(constructor, { node, scope, fields: fields2, initialized: false });
-  return constructor;
-}
-async function initializeElement(definition, receiver, homeObject, context, evaluateNode2) {
-  const scope = context.scope.child({}, { functionBoundary: true });
-  scope.declare("this", "const", receiver);
-  const element = definition.element;
-  const initializer = element.type === "StaticBlock" ? element.body : element.value;
-  let value;
-  if (initializer !== void 0) {
-    if (element.type === "StaticBlock") hoistVarDeclarations(element.body, scope);
-    const result = await evaluateNode2(initializer, { ...context, scope, functionEnvironment: { homeObject }, inferredName: "key" in definition ? propertyFunctionName(definition.key) : void 0 });
-    if (result.kind === "error") throw result.error;
-    if (result.kind === "throw") throw result.value;
-    value = result.hasValue ? result.value : void 0;
-  }
-  if ("key" in definition) {
-    defineDataProperty(receiver, definition.key, { value, configurable: true, writable: true, enumerable: true }, context.budget);
-  }
-}
-
-// packages/safe-js/src/interp/resume-target.ts
-function containsResumeTarget(node, targetNodeIds) {
-  if (targetNodeIds === void 0 ? node.type === "YieldExpression" : node.nodeId !== void 0 && targetNodeIds.has(node.nodeId)) {
-    return true;
-  }
-  if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") {
-    return false;
-  }
-  for (const value of Object.values(node)) {
-    if (Array.isArray(value)) {
-      if (value.some((entry) => isParseResult(entry) && containsResumeTarget(entry, targetNodeIds))) {
-        return true;
+    case "toReversed": {
+      const length = value.length;
+      options.budget.allocateArrayLength(length);
+      const result = new Array(length);
+      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();
       }
-      continue;
     }
-    if (isParseResult(value) && containsResumeTarget(value, targetNodeIds)) {
-      return true;
+    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 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);
+      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();
+      }
+    }
+    case "with": {
+      const length = value.length;
+      const index = toIntegerOrInfinity(
+        options.context === void 0 ? 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 = [];
+      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();
+      }
+    }
+    case "push": {
+      const nextLength = await appendArrayValues(value, args, options);
+      budgetProducedValue(value, options.budget);
+      return nextLength;
+    }
+    case "pop":
+    case "shift": {
+      const length = value.length;
+      if (length === 0) {
+        await writeArrayProperty(value, "length", 0, options);
+        return void 0;
+      }
+      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, void 0);
+      }
+    }
+    case "unshift": {
+      const nextLength = await prependArrayValues(value, args, options);
+      budgetProducedValue(value, options.budget);
+      return nextLength;
     }
   }
-  return false;
-}
-function isParseResult(value) {
-  return typeof value === "object" && value !== null && typeof value.type === "string" && Object.hasOwn(value, "span");
-}
-
-// packages/safe-js/src/interp/methods/array.ts
-var arrayLikeSources = /* @__PURE__ */ new WeakMap();
-var activeArrayCallbacks = /* @__PURE__ */ new WeakMap();
-var arrayMethodNames = /* @__PURE__ */ new Set([
-  "map",
-  "filter",
-  "find",
-  "findIndex",
-  "findLast",
-  "findLastIndex",
-  "some",
-  "every",
-  "reduce",
-  "reduceRight",
-  "forEach",
-  "flatMap",
-  "flat",
-  "includes",
-  "indexOf",
-  "lastIndexOf",
-  "join",
-  "slice",
-  "concat",
-  "splice",
-  "fill",
-  "copyWithin",
-  "at",
-  "sort",
-  "reverse",
-  "toSorted",
-  "toReversed",
-  "toSpliced",
-  "with",
-  "push",
-  "pop",
-  "shift",
-  "unshift"
-]);
-function getArrayMember(value, property, options) {
-  const index = getArrayIndex(property);
-  if (index !== void 0) {
-    return Object.hasOwn(value, index) ? value[index] : void 0;
-  }
-  if (property === "length") {
-    return value.length;
+}
+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) {
+    await writeArrayProperty(target, length++, value, options);
   }
-  if (Object.hasOwn(value, property)) {
-    return value[String(property)];
+  await writeArrayProperty(target, "length", length, options);
+  return length;
+}
+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;
+    await moveArrayElement(target, index, targetIndex, options);
   }
-  if (isArrayMethodName(property)) {
-    return createSandboxClosure({
-      sandbox: true,
-      name: `Array#${property}`,
-      call: (args, context) => callArrayMethod(
-        context?.thisValue,
-        property,
-        args,
-        { ...options, context },
-        context?.stack ?? []
-      )
-    });
+  for (let index = 0; index < values.length; index += 1) {
+    await writeArrayProperty(target, index, values[index], options);
   }
-  return void 0;
+  await writeArrayProperty(target, "length", length, options);
+  return length;
 }
-function getArrayIndex(property) {
-  const index = typeof property === "number" ? property : Number(property);
-  if (!Number.isSafeInteger(index) || index < 0 || index >= 2 ** 32 - 1 || String(index) !== String(property)) {
-    return void 0;
+function isCallbackArrayMethod(methodName) {
+  return methodName === "map" || methodName === "filter" || methodName === "find" || methodName === "findIndex" || methodName === "findLast" || methodName === "findLastIndex" || methodName === "some" || methodName === "every" || methodName === "reduce" || methodName === "reduceRight" || methodName === "forEach" || methodName === "flatMap" || methodName === "sort";
+}
+function isMutatingArrayMethod(methodName) {
+  return methodName === "splice" || methodName === "fill" || methodName === "copyWithin" || methodName === "sort" || methodName === "reverse" || methodName === "push" || methodName === "pop" || methodName === "shift" || methodName === "unshift";
+}
+function getRequiredCallback(methodName, value) {
+  if (!isSandboxClosure(value)) {
+    throw new TypeError(`Array#${methodName} requires a sandbox closure callback.`);
   }
-  return index;
+  return value;
 }
-function isArrayMethodName(property) {
-  return typeof property === "string" && arrayMethodNames.has(property);
+function readArrayElement(value, index, options) {
+  const receiver = arrayLikeSources.get(value) ?? value;
+  return options.context?.getProperty !== void 0 ? options.context.getProperty(receiver, index) : getSandboxDataProperty(receiver, index, options.budget);
 }
-async function callArrayMethod(receiver, methodName, args, options, stack = []) {
-  if (receiver === null || receiver === void 0)
-    throw new TypeError("Array method requires a receiver.");
-  if (typeof receiver !== "object") {
-    receiver = createSandboxBox(receiver);
-    options.budget.chargeDataUsage(measureSandboxData([receiver]));
+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);
   }
-  const retainedReceiver = {};
-  options.budget.setRetainedValues(retainedReceiver, () => [receiver]);
+  if (options.setProperty !== void 0) 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 === void 0 ? 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);
+  const result = new Array(length);
+  options.budget.setRetainedValues(result, () => [result]);
   try {
-    const value = Array.isArray(receiver) || methodName === "concat" ? receiver : await arrayLikeView(receiver, options);
-    if (isMutatingArrayMethod(methodName)) {
-      assertCollectionMutable(receiver);
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      result[index] = await callArrayCallback(
+        callback,
+        await readArrayElement(value, index, options),
+        index,
+        value,
+        options,
+        stack,
+        thisValue
+      );
     }
-    if (isCallbackArrayMethod(methodName)) {
-      let callbackState = activeArrayCallbacks.get(receiver);
-      if (callbackState === void 0) {
-        callbackState = { depth: 0, leave: enterRunningState(receiver) };
-        activeArrayCallbacks.set(receiver, callbackState);
+    return result;
+  } finally {
+    options.budget.setRetainedValues(result, void 0);
+  }
+}
+async function filterArray(value, callback, options, stack, thisValue) {
+  const length = value.length;
+  const result = [];
+  options.budget.setRetainedValues(result, () => [result]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
       }
-      callbackState.depth += 1;
-      try {
-        const result2 = await callArrayMethodUnlocked(value, methodName, args, options, stack);
-        return result2 === value ? receiver : result2;
-      } finally {
-        callbackState.depth -= 1;
-        if (callbackState.depth === 0) {
-          activeArrayCallbacks.delete(receiver);
-          callbackState.leave();
-        }
+      const entry = await readArrayElement(value, index, options);
+      if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+        result.push(entry);
       }
     }
-    const result = await callArrayMethodUnlocked(value, methodName, args, options, stack);
-    return result === value ? receiver : result;
+    return result;
   } finally {
-    options.budget.setRetainedValues(retainedReceiver, void 0);
+    options.budget.setRetainedValues(result, void 0);
   }
 }
-async function arrayLikeView(receiver, options) {
-  const rawLength = options.context?.getProperty !== void 0 ? 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);
-  const view = new Proxy(
-    /* @__PURE__ */ Object.create(null),
-    {
-      get: (_target, key) => {
-        options.budget.visitNode();
-        if (key === "length") return length;
-        if (typeof key !== "string") return void 0;
-        return options.context?.getProperty !== void 0 ? options.context.getProperty(receiver, key) : getSandboxDataProperty(receiver, key, options.budget);
-      },
-      has: (_target, key) => {
-        options.budget.visitNode();
-        if (typeof key === "string" && options.hasProperty !== void 0)
-          return options.hasProperty(receiver, key);
-        for (let current = receiver; current !== null; current = getSandboxPrototype(current, options.budget)) {
-          options.budget.visitNode();
-          if (Object.hasOwn(current, key)) return true;
-        }
-        return false;
-      },
-      set: (_target, key, entry) => {
-        options.budget.visitNode();
-        if (typeof key !== "string") throw new TypeError("Array indices must be string keys.");
-        if (options.setProperty !== void 0) options.setProperty(receiver, key, entry);
-        else if (!Reflect.set(receiver, key, entry))
-          throw new TypeError(`Cannot assign property '${key}'.`);
-        return true;
-      },
-      deleteProperty: (_target, key) => {
-        options.budget.visitNode();
-        if (typeof key === "string" && options.deleteProperty !== void 0)
-          return options.deleteProperty(receiver, key);
-        return Reflect.deleteProperty(receiver, key);
-      }
+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 = await readArrayElement(value, index, options);
+    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+      return entry;
+    }
+  }
+  return void 0;
+}
+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 = await readArrayElement(value, index, options);
+    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+      return index;
+    }
+  }
+  return -1;
+}
+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 = await readArrayElement(value, index, options);
+    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+      return entry;
+    }
+  }
+  return void 0;
+}
+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 = await readArrayElement(value, index, options);
+    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+      return index;
+    }
+  }
+  return -1;
+}
+async function someInArray(value, callback, options, stack, thisValue) {
+  const length = value.length;
+  for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
+    if (!(index in value)) {
+      continue;
+    }
+    if (await callArrayCallback(
+      callback,
+      await readArrayElement(value, index, options),
+      index,
+      value,
+      options,
+      stack,
+      thisValue
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+async function everyInArray(value, callback, options, stack, thisValue) {
+  const length = value.length;
+  for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
+    if (!(index in value)) {
+      continue;
+    }
+    if (!await callArrayCallback(
+      callback,
+      await readArrayElement(value, index, options),
+      index,
+      value,
+      options,
+      stack,
+      thisValue
+    )) {
+      return false;
     }
+  }
+  return true;
+}
+async function reduceArray(value, callback, hasInitialValue, initialValue, options, stack) {
+  const length = value.length;
+  if (hasInitialValue) {
+    return reduceFromLeft(value, callback, initialValue, 0, length, options, stack);
+  }
+  const start = findNextDefinedIndex(value, 0, 1, length, options.budget);
+  if (start < 0) {
+    throw new TypeError("Reduce of empty array with no initial value.");
+  }
+  return reduceFromLeft(
+    value,
+    callback,
+    await readArrayElement(value, start, options),
+    start + 1,
+    length,
+    options,
+    stack
   );
-  arrayLikeSources.set(view, receiver);
-  return view;
 }
-async function callArrayMethodUnlocked(value, methodName, args, options, stack) {
-  switch (methodName) {
-    case "map":
-      return budgetProducedValue(
-        await mapArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]),
-        options.budget
-      );
-    case "filter":
-      return budgetProducedValue(
-        await filterArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]),
-        options.budget
+async function reduceRightArray(value, callback, hasInitialValue, initialValue, options, stack) {
+  const length = value.length;
+  if (hasInitialValue) {
+    return reduceFromRight(value, callback, initialValue, length - 1, length, options, stack);
+  }
+  const start = findNextDefinedIndex(value, length - 1, -1, length, options.budget);
+  if (start < 0) {
+    throw new TypeError("Reduce of empty array with no initial value.");
+  }
+  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;
+  const retainedAccumulator = {};
+  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+  try {
+    for (let index = startIndex; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      current = await options.callClosure(
+        callback,
+        [
+          current,
+          await readArrayElement(value, index, options),
+          index,
+          arrayLikeSources.get(value) ?? value
+        ],
+        stack
       );
-    case "find":
-      return budgetProducedValue(
-        await findInArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]),
-        options.budget
+    }
+    return current;
+  } finally {
+    options.budget.setRetainedValues(retainedAccumulator, void 0);
+  }
+}
+async function reduceFromRight(value, callback, accumulator, startIndex, length, options, stack) {
+  let current = accumulator;
+  const retainedAccumulator = {};
+  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+  try {
+    for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      current = await options.callClosure(
+        callback,
+        [
+          current,
+          await readArrayElement(value, index, options),
+          index,
+          arrayLikeSources.get(value) ?? value
+        ],
+        stack
       );
-    case "findIndex":
-      return await findIndexInArray(
+    }
+    return current;
+  } finally {
+    options.budget.setRetainedValues(retainedAccumulator, void 0);
+  }
+}
+async function forEachArray(value, callback, options, stack, thisValue) {
+  const length = value.length;
+  for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
+    if (!(index in value)) {
+      continue;
+    }
+    await callArrayCallback(
+      callback,
+      await readArrayElement(value, index, options),
+      index,
+      value,
+      options,
+      stack,
+      thisValue
+    );
+  }
+}
+async function flatMapArray(value, callback, options, stack, thisValue) {
+  const length = value.length;
+  const result = [];
+  options.budget.setRetainedValues(result, () => [result]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      const mapped = await callArrayCallback(
+        callback,
+        await readArrayElement(value, index, options),
+        index,
         value,
-        getRequiredCallback(methodName, args[0]),
         options,
         stack,
-        args[1]
+        thisValue
       );
-    case "findLast":
-      return budgetProducedValue(
-        await findLastInArray(
-          value,
-          getRequiredCallback(methodName, args[0]),
-          options,
-          stack,
-          args[1]
-        ),
-        options.budget
-      );
-    case "findLastIndex":
-      return await findLastIndexInArray(
-        value,
-        getRequiredCallback(methodName, args[0]),
-        options,
-        stack,
-        args[1]
-      );
-    case "some":
-      return await someInArray(
-        value,
-        getRequiredCallback(methodName, args[0]),
-        options,
-        stack,
-        args[1]
-      );
-    case "every":
-      return await everyInArray(
-        value,
-        getRequiredCallback(methodName, args[0]),
-        options,
-        stack,
-        args[1]
-      );
-    case "reduce":
-      return budgetProducedValue(
-        await reduceArray(
-          value,
-          getRequiredCallback(methodName, args[0]),
-          args.length > 1,
-          args[1],
-          options,
-          stack
-        ),
-        options.budget
-      );
-    case "reduceRight":
-      return budgetProducedValue(
-        await reduceRightArray(
-          value,
-          getRequiredCallback(methodName, args[0]),
-          args.length > 1,
-          args[1],
-          options,
-          stack
-        ),
-        options.budget
-      );
-    case "forEach":
-      await forEachArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]);
-      return void 0;
-    case "flatMap":
-      return budgetProducedValue(
-        await flatMapArray(
-          value,
-          getRequiredCallback(methodName, args[0]),
-          options,
-          stack,
-          args[1]
-        ),
-        options.budget
-      );
-    case "flat":
-      return budgetProducedValue(
-        await flattenArray(
-          value,
-          args[0] === void 0 ? 1 : toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context)),
-          options
-        ),
-        options.budget
-      );
-    case "includes":
-    case "indexOf":
-    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] === void 0 ? "," : 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] === void 0 ? 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);
-      const release = retainValues(options.budget, () => [result]);
-      try {
-        for (let index = 0; index < count; index += 1) {
+      if (Array.isArray(mapped)) {
+        for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 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]) {
-          let spread = false;
-          if (entry !== null && (typeof entry === "object" || typeof entry === "function")) {
-            const flag = options.context?.getProperty !== void 0 ? await options.context.getProperty(entry, Symbol.isConcatSpreadable) : getSandboxDataProperty(entry, Symbol.isConcatSpreadable, options.budget);
-            spread = flag === void 0 ? Array.isArray(entry) : Boolean(flag);
-          }
-          if (!spread) {
-            options.budget.allocateArrayLength(result.length + 1);
-            result.push(entry);
+          if (!(mappedIndex in mapped)) {
             continue;
           }
-          const start = result.length;
-          const source = await arrayLikeView(entry, options);
-          const length = source.length;
-          options.budget.allocateArrayLength(start + length);
-          result.length += length;
-          for (let index = 0; index < length; index++) {
-            options.budget.visitNode();
-            if (index in source)
-              result[start + index] = await readArrayElement(source, index, options);
-          }
+          result.push(await readArrayElement(mapped, mappedIndex, options));
+          options.budget.allocateArrayLength(result.length);
         }
-        return budgetProducedValue(result, options.budget);
-      } finally {
-        options.budget.setRetainedValues(retained, void 0);
+        continue;
       }
+      result.push(mapped);
+      options.budget.allocateArrayLength(result.length);
     }
-    case "splice": {
-      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, void 0);
-      }
-      budgetProducedValue(removed, options.budget);
-      budgetProducedValue(value, options.budget);
-      return removed;
+    return result;
+  } finally {
+    options.budget.setRetainedValues(result, void 0);
+  }
+}
+async function flattenArray(value, depth, options) {
+  const result = [];
+  const retained = {};
+  options.budget.setRetainedValues(retained, () => [result]);
+  try {
+    await appendFlattenedEntries(value, depth, result, options);
+    return result;
+  } finally {
+    options.budget.setRetainedValues(retained, void 0);
+  }
+}
+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;
     }
-    case "fill": {
-      const length = value.length;
-      const start = toIntegerOrInfinity(
-        await sandboxNumber(args[1], options.budget, options.context)
-      );
-      const end = args[2] === void 0 ? 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;
+    const entry = await readArrayElement(value, index, options);
+    if (depth > 0 && Array.isArray(entry)) {
+      await appendFlattenedEntries(entry, depth - 1, result, options);
+      continue;
     }
-    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] === void 0 ? 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;
+    result.push(entry);
+    options.budget.allocateArrayLength(result.length);
+  }
+}
+async function sortArray(value, comparator, options, stack) {
+  const length = value.length;
+  const definedValues = [];
+  let undefinedCount = 0;
+  let currentEntry;
+  options.budget.setRetainedValues(definedValues, () => [definedValues, currentEntry]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
       }
-      while (count-- > 0) {
-        await moveArrayElement(value, from, to, options);
-        from += direction;
-        to += direction;
+      const entry = await readArrayElement(value, index, options);
+      if (entry === void 0) {
+        undefinedCount += 1;
+        continue;
       }
-      budgetProducedValue(value, options.budget);
-      return value;
-    }
-    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 ? void 0 : budgetProducedValue(await readArrayElement(value, actual, options), options.budget);
+      definedValues.push(entry);
     }
-    case "sort":
-      await sortArray(
-        value,
-        args[0] === void 0 ? void 0 : 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 = void 0;
-          const upper = length - lower - 1;
-          const lowerExists = lower in value;
-          lowerValue = lowerExists ? await readArrayElement(value, lower, options) : void 0;
-          const upperExists = upper in value;
-          upperValue = upperExists ? await readArrayElement(value, upper, options) : void 0;
-          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;
-      } finally {
-        release();
+    for (let index = 1; index < definedValues.length; index += 1) {
+      currentEntry = definedValues[index];
+      let cursor = index - 1;
+      while (cursor >= 0 && await compareEntries(definedValues[cursor], currentEntry, comparator, options, stack) > 0) {
+        definedValues[cursor + 1] = definedValues[cursor];
+        cursor -= 1;
       }
+      definedValues[cursor + 1] = currentEntry;
     }
-    case "toSorted": {
-      const length = value.length;
-      options.budget.allocateArrayLength(length);
-      const result = new Array(length);
-      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] === void 0 ? void 0 : getRequiredCallback(methodName, args[0]),
-          options,
-          stack
-        );
-        return budgetProducedValue(result, options.budget);
-      } finally {
-        release();
-      }
+    currentEntry = void 0;
+    for (let index = 0; index < definedValues.length; index += 1) {
+      await writeArrayProperty(value, index, definedValues[index], options);
     }
-    case "toReversed": {
-      const length = value.length;
-      options.budget.allocateArrayLength(length);
-      const result = new Array(length);
-      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();
-      }
+    for (let index = 0; index < undefinedCount; index += 1) {
+      await writeArrayProperty(value, definedValues.length + index, void 0, options);
     }
-    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 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);
-      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();
-      }
+    for (let index = definedValues.length + undefinedCount; index < length; index += 1) {
+      options.budget.visitNode();
+      deleteArrayElement(value, index, options);
+    }
+  } finally {
+    options.budget.setRetainedValues(definedValues, void 0);
+  }
+}
+async function compareEntries(left, right, comparator, options, stack) {
+  options.budget.visitNode();
+  if (comparator === void 0) {
+    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, array2, options, stack, thisValue) {
+  return options.callClosure(
+    callback,
+    [value, index, arrayLikeSources.get(array2) ?? array2],
+    stack,
+    thisValue
+  );
+}
+function findNextDefinedIndex(value, startIndex, direction, length, budget) {
+  for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {
+    budget.visitNode();
+    if (index in value) {
+      return index;
+    }
+  }
+  return -1;
+}
+function budgetProducedValue(value, budget) {
+  if (typeof value === "object" && value !== null) value = arrayLikeSources.get(value) ?? value;
+  allocateProducedValue(value, budget, /* @__PURE__ */ new WeakSet());
+  return value;
+}
+function allocateProducedValue(value, budget, seen) {
+  if (typeof value === "string") {
+    budget.allocateString(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    budget.allocateArrayLength(value.length);
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    for (const entry of value) {
+      allocateProducedValue(entry, budget, seen);
+    }
+    return;
+  }
+  if (isSandboxMap(value)) {
+    budget.allocateCollectionEntries(value.entries.size);
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    for (const [key, entry] of value.entries) {
+      allocateProducedValue(key, budget, seen);
+      allocateProducedValue(entry, budget, seen);
+    }
+    return;
+  }
+  if (isSandboxSet(value)) {
+    budget.allocateCollectionEntries(value.values.size);
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    for (const entry of value.values) {
+      allocateProducedValue(entry, budget, seen);
+    }
+    return;
+  }
+  if (typeof value !== "object" || value === null || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value)) {
+    return;
+  }
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+  for (const entry of Object.values(value)) {
+    allocateProducedValue(entry, budget, seen);
+  }
+}
+function toIntegerOrInfinity(value) {
+  const number = Number(value);
+  if (Number.isNaN(number) || Object.is(number, 0) || Object.is(number, -0)) {
+    return 0;
+  }
+  if (!Number.isFinite(number)) {
+    return number;
+  }
+  return Math.trunc(number);
+}
+
+// packages/safe-js/src/interp/globals/object-array.ts
+function createObjectArrayGlobals(options) {
+  return {
+    Object: createObjectGlobal(
+      {
+        keys: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => budgetSandboxValue(ownEnumerableSandboxKeys(value), options.budget),
+          name: "keys"
+        }),
+        values: createSandboxClosure({
+          sandbox: true,
+          call: ([value], context) => context === void 0 ? allocateProducedSandboxValue(
+            ownEnumerableSandboxEntries(value).map(([, entry]) => entry),
+            options.budget
+          ) : getOwnEnumerableEntries(value, options.budget, context).then(
+            (entries) => allocateProducedSandboxValue(
+              entries.map(([, entry]) => entry),
+              options.budget
+            )
+          ),
+          name: "values"
+        }),
+        entries: createSandboxClosure({
+          sandbox: true,
+          call: ([value], context) => context === void 0 ? allocateProducedSandboxValue(ownEnumerableSandboxEntries(value), options.budget) : getOwnEnumerableEntries(value, options.budget, context).then(
+            (entries) => allocateProducedSandboxValue(entries, options.budget)
+          ),
+          name: "entries"
+        }),
+        hasOwn: createSandboxClosure({
+          sandbox: true,
+          call: ([value, key], context) => {
+            if (value === null || value === void 0)
+              throw new TypeError("Cannot convert undefined or null to object.");
+            const name = toPropertyKey(key, options.budget, context);
+            return typeof name === "string" || typeof name === "symbol" ? hasOwnSandboxProperty(value, name, false) : name.then((property) => hasOwnSandboxProperty(value, property, false));
+          },
+          name: "hasOwn"
+        }),
+        getOwnPropertyDescriptor: createSandboxClosure({
+          sandbox: true,
+          call: async ([value, key], context) => {
+            const descriptor = Object.getOwnPropertyDescriptor(
+              reflectionProperties(value),
+              await toPropertyKey(key, options.budget, context)
+            );
+            if (descriptor === void 0) return void 0;
+            return allocateProducedSandboxValue(
+              exposePropertyDescriptor(descriptor),
+              options.budget
+            );
+          },
+          name: "getOwnPropertyDescriptor"
+        }),
+        getOwnPropertyDescriptors: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => {
+            const descriptors2 = /* @__PURE__ */ Object.create(null);
+            const properties = reflectionProperties(value);
+            for (const key of [...Object.getOwnPropertyNames(properties), ...ownSandboxSymbolKeys(value)])
+              defineOwnDataProperty(descriptors2, key, exposePropertyDescriptor(Object.getOwnPropertyDescriptor(properties, key)));
+            return allocateProducedSandboxValue(descriptors2, options.budget);
+          },
+          name: "getOwnPropertyDescriptors"
+        }),
+        getOwnPropertyNames: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => budgetSandboxValue(Object.getOwnPropertyNames(reflectionProperties(value)), options.budget),
+          name: "getOwnPropertyNames"
+        }),
+        getOwnPropertySymbols: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => allocateProducedSandboxValue(ownSandboxSymbolKeys(value), options.budget),
+          name: "getOwnPropertySymbols"
+        }),
+        defineProperty: createSandboxClosure({
+          sandbox: true,
+          call: async ([value, key, descriptor], context) => {
+            objectProperties(value, true);
+            const property = await toPropertyKey(key, options.budget, context);
+            defineDataProperty(
+              value,
+              property,
+              await propertyDescriptor(descriptor, options.budget, context),
+              options.budget
+            );
+            return value;
+          },
+          name: "defineProperty"
+        }),
+        defineProperties: createSandboxClosure({
+          sandbox: true,
+          call: async ([value, descriptors2], context) => {
+            await definePropertiesFromObject(value, descriptors2, options.budget, context);
+            return value;
+          },
+          name: "defineProperties"
+        }),
+        getPrototypeOf: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => {
+            if (isSandboxMap(value) || isSandboxSet(value))
+              return getSandboxPrototype(value, options.budget);
+            if (value !== null && value !== void 0 && typeof value !== "object")
+              value = createSandboxBox(value);
+            objectProperties(value);
+            return getSandboxPrototype(value, options.budget);
+          },
+          name: "getPrototypeOf"
+        }),
+        setPrototypeOf: createSandboxClosure({
+          sandbox: true,
+          call: ([value, prototype]) => {
+            if (value === null || value === void 0)
+              throw new TypeError("Cannot set the prototype of null or undefined.");
+            if (prototype !== null && typeof prototype !== "object")
+              throw new TypeError("Prototype must be an object or null.");
+            if (typeof value !== "object") return value;
+            objectProperties(value, true);
+            if (prototype !== null) objectProperties(prototype);
+            setSandboxPrototype(value, prototype, options.budget);
+            return value;
+          },
+          name: "setPrototypeOf"
+        }),
+        create: createSandboxClosure({
+          sandbox: true,
+          call: async ([prototype, descriptors2], context) => {
+            if (prototype !== null) objectProperties(prototype);
+            const value = /* @__PURE__ */ Object.create(null);
+            setSandboxPrototype(value, prototype, options.budget);
+            if (descriptors2 !== void 0) {
+              await definePropertiesFromObject(value, descriptors2, options.budget, context);
+            }
+            return allocateProducedSandboxValue(value, options.budget);
+          },
+          name: "create"
+        }),
+        is: createSandboxClosure({
+          sandbox: true,
+          call: ([left, right]) => Reflect.apply(Object.is, Object, [left, right]),
+          name: "is"
+        }),
+        fromEntries: createSandboxClosure({
+          sandbox: true,
+          call: ([value], context) => {
+            if (context !== void 0) return acquireSandboxIterator(value, options.budget, context).then((iterator2) => {
+              if (iterator2 === void 0) throw new TypeError("Object.fromEntries requires an iterable.");
+              return objectFromSandboxEntries(value, iterator2, options.budget, context);
+            });
+            const iterator = getSandboxIterator(value, options.budget, context);
+            if (iterator === void 0) {
+              throw new TypeError("Object.fromEntries requires an iterable.");
+            }
+            if (context === void 0 && !iterator.generator && !iterator.asynchronous) {
+              return allocateProducedSandboxValue(
+                Object.setPrototypeOf(
+                  Reflect.apply(Object.fromEntries, Object, [
+                    { [Symbol.iterator]: () => iterator }
+                  ]),
+                  null
+                ),
+                options.budget
+              );
+            }
+            return objectFromSandboxEntries(value, iterator, options.budget, context);
+          },
+          name: "fromEntries"
+        }),
+        preventExtensions: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => {
+            if (isGuestHostObject(value))
+              throw new TypeError("Live host objects cannot be made non-extensible.");
+            Object.preventExtensions(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
+            return value;
+          },
+          name: "preventExtensions"
+        }),
+        isExtensible: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => Object.isExtensible(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
+          name: "isExtensible"
+        }),
+        seal: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => {
+            if (isGuestHostObject(value))
+              throw new TypeError("Live host objects cannot be sealed.");
+            Object.seal(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
+            return value;
+          },
+          name: "seal"
+        }),
+        isSealed: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => Object.isSealed(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
+          name: "isSealed"
+        }),
+        freeze: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => {
+            if (isGuestHostObject(value))
+              throw new TypeError("Live host objects cannot be frozen.");
+            if (typeof value === "object" && value !== null) {
+              Object.freeze(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
+            }
+            return value;
+          },
+          name: "freeze"
+        }),
+        isFrozen: createSandboxClosure({
+          sandbox: true,
+          call: ([value]) => Object.isFrozen(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
+          name: "isFrozen"
+        }),
+        assign: createSandboxClosure({
+          sandbox: true,
+          call: ([target, ...sources], context) => assignSandboxValues(target, sources, options.budget, context),
+          name: "assign"
+        })
+      },
+      options.budget
+    ),
+    Array: createArrayGlobal(options.budget),
+    String: createPrimitiveConstructor(
+      {
+        call: (args, context) => typeof args[0] === "symbol" ? options.budget.allocateString(String(args[0])) : sandboxString(args.length === 0 ? "" : args[0], options.budget, context),
+        name: "String",
+        properties: {
+          raw: createSandboxClosure({
+            sandbox: true,
+            call: (args, context) => stringRaw(args, options.budget, context),
+            name: "raw"
+          }),
+          fromCharCode: createSandboxClosure({
+            sandbox: true,
+            call: (args, context) => stringFromCodes(args, String.fromCharCode, options.budget, context),
+            name: "fromCharCode"
+          }),
+          fromCodePoint: createSandboxClosure({
+            sandbox: true,
+            call: (args, context) => stringFromCodes(args, String.fromCodePoint, options.budget, context),
+            name: "fromCodePoint"
+          })
+        }
+      },
+      options.budget
+    ),
+    Number: createPrimitiveConstructor(
+      {
+        call: (args, context) => sandboxNumber(args.length === 0 ? 0 : args[0], options.budget, context, true),
+        name: "Number",
+        properties: {
+          isFinite: createSandboxClosure({
+            guest: true,
+            sandbox: true,
+            call: ([value]) => typeof value === "number" && Number.isFinite(value),
+            name: "isFinite"
+          }),
+          isNaN: createSandboxClosure({
+            guest: true,
+            sandbox: true,
+            call: ([value]) => typeof value === "number" && Number.isNaN(value),
+            name: "isNaN"
+          }),
+          isInteger: createSandboxClosure({
+            guest: true,
+            sandbox: true,
+            call: ([value]) => typeof value === "number" && Number.isInteger(value),
+            name: "isInteger"
+          }),
+          ...createNumericParsers(options.budget),
+          isSafeInteger: createSandboxClosure({
+            guest: true,
+            sandbox: true,
+            call: ([value]) => typeof value === "number" && Number.isSafeInteger(value),
+            name: "isSafeInteger"
+          }),
+          MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,
+          MIN_SAFE_INTEGER: Number.MIN_SAFE_INTEGER,
+          EPSILON: Number.EPSILON,
+          MAX_VALUE: Number.MAX_VALUE,
+          MIN_VALUE: Number.MIN_VALUE,
+          NaN: Number.NaN,
+          NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
+          POSITIVE_INFINITY: Number.POSITIVE_INFINITY
+        }
+      },
+      options.budget
+    ),
+    Boolean: createPrimitiveConstructor(
+      {
+        call: ([value]) => Boolean(value),
+        name: "Boolean"
+      },
+      options.budget
+    )
+  };
+}
+function createArrayGlobal(budget) {
+  const prototype = [];
+  const objectToString = Object.getOwnPropertyDescriptor(getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget), "toString").value;
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    call: (args) => createArrayFromConstructorArgs(args, budget),
+    construct: (args) => createArrayFromConstructorArgs(args, budget),
+    name: "Array",
+    length: 1
+  });
+  const properties = materializeFunctionProperties(constructor);
+  Object.defineProperty(properties, "prototype", { value: prototype, writable: false });
+  Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
+  for (const name of arrayMethodNames) {
+    const method = createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name,
+      length: Object.getOwnPropertyDescriptor(Array.prototype, name).value.length,
+      call: (args, context) => callArrayMethod(context?.thisValue, name, args, {
+        budget,
+        context,
+        hasProperty: (value, key) => hasOwnSandboxProperty(value, key, false) || getSandboxPropertyDescriptor(value, key, budget) !== void 0,
+        deleteProperty: deleteSandboxProperty,
+        setProperty: (value, key, entry) => setSandboxProperty(value, key, entry, budget, true, context),
+        callClosure: (closure, values, _stack, receiver) => invokeBuiltinClosure(closure, values, budget, context, receiver)
+      }, context?.stack ?? [])
+    });
+    Object.defineProperty(prototype, name, { value: method, writable: true, configurable: true });
+  }
+  Object.defineProperty(prototype, "toString", {
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "toString",
+      length: 0,
+      call: async (_args, context) => {
+        const receiver = context?.thisValue;
+        if (receiver === null || receiver === void 0) throw new TypeError("Array toString requires a receiver.");
+        const object = typeof receiver === "object" ? receiver : createSandboxBox(receiver);
+        const method = context?.getProperty === void 0 ? getSandboxDataProperty(object, "join", budget) : await context.getProperty(object, "join");
+        return invokeBuiltinClosure(isSandboxClosure(method) ? method : objectToString, [], budget, context, object);
+      }
+    }),
+    writable: true,
+    configurable: true
+  });
+  const statics = {
+    isArray: createSandboxClosure({ sandbox: true, name: "isArray", call: ([value]) => Array.isArray(value) }),
+    from: createSandboxClosure({ sandbox: true, name: "from", call: (args, context) => arrayFromSandboxValues(args, budget, context) }),
+    of: createSandboxClosure({ sandbox: true, name: "of", call: (args) => budgetSandboxValue(Reflect.apply(Array.of, Array, [...args]), budget) })
+  };
+  for (const [name, value] of Object.entries(statics))
+    Object.defineProperty(properties, name, { value, writable: true, configurable: true });
+  installArrayPrototype(budget, prototype, constructor);
+  return constructor;
+}
+async function objectFromSandboxEntries(items, iterator, budget, context) {
+  const object = /* @__PURE__ */ Object.create(null);
+  let entry;
+  let key;
+  let value;
+  let failure;
+  const retained = {};
+  budget.setRetainedValues(retained, () => [
+    items,
+    iterator.retainedValue,
+    object,
+    entry,
+    key,
+    value,
+    failure
+  ]);
+  const checkData = createDataCheckpoint(budget, context);
+  const closeOnThrow = async (error) => {
+    failure = isCapturedException(error) ? error.reason : error;
+    try {
+      await closeIterator(iterator, true);
+    } catch (closeError) {
+      if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
     }
-    case "with": {
-      const length = value.length;
-      const index = toIntegerOrInfinity(
-        options.context === void 0 ? 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 = [];
-      const release = retainValues(options.budget, () => [result]);
+    throw error;
+  };
+  try {
+    checkData(object, 0, true);
+    while (true) {
       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();
+        budget.visitNode();
+      } catch (error) {
+        await closeOnThrow(error);
       }
-    }
-    case "push": {
-      const nextLength = await appendArrayValues(value, args, options);
-      budgetProducedValue(value, options.budget);
-      return nextLength;
-    }
-    case "pop":
-    case "shift": {
-      const length = value.length;
-      if (length === 0) {
-        await writeArrayProperty(value, "length", 0, options);
-        return void 0;
+      const result = await iterator.next();
+      if (typeof result !== "object" || result === null) {
+        throw new TypeError("Iterator result must be an object.");
       }
-      const result = await readArrayElement(value, methodName === "pop" ? length - 1 : 0, options);
-      const retained = {};
-      options.budget.setRetainedValues(retained, () => [result]);
+      if ((await readIteratorResult(iterator, result, "done")).value) break;
+      entry = (await readIteratorResult(iterator, result, "value")).value;
       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, void 0);
+        if (typeof entry !== "object" || entry === null) {
+          throw new TypeError("Object.fromEntries requires entry objects.");
+        }
+        key = context?.getProperty !== void 0 ? await context.getProperty(entry, 0) : getSandboxDataProperty(entry, 0, budget);
+        value = context?.getProperty !== void 0 ? await context.getProperty(entry, 1) : getSandboxDataProperty(entry, 1, budget);
+        const property = await toPropertyKey(key, budget, context);
+        const growth = (typeof property === "symbol" ? property.description?.length ?? 0 : property.length) + 1 + (budget.limits.dataSize === void 0 ? 0 : measureSandboxData([value]));
+        budget.visitNode();
+        defineOwnDataProperty(object, property, value);
+        entry = key = value = void 0;
+        checkData(object, growth);
+      } catch (error) {
+        await closeOnThrow(error);
       }
     }
-    case "unshift": {
-      const nextLength = await prependArrayValues(value, args, options);
-      budgetProducedValue(value, options.budget);
-      return nextLength;
-    }
+    checkData(object, 0, true);
+    return allocateProducedSandboxValue(object, budget);
+  } finally {
+    budget.setRetainedValues(retained, void 0);
   }
 }
-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) {
-    await writeArrayProperty(target, length++, value, options);
+function assignSandboxValues(target, sources, budget, context) {
+  if (target === null || target === void 0) {
+    throw new TypeError("Object.assign(target, ...sources) requires a non-null target.");
   }
-  await writeArrayProperty(target, "length", length, options);
-  return length;
-}
-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;
-    await moveArrayElement(target, index, targetIndex, options);
+  if (typeof target !== "object") {
+    target = createSandboxBox(target);
+    budget.chargeDataUsage(measureSandboxData([target]));
   }
-  for (let index = 0; index < values.length; index += 1) {
-    await writeArrayProperty(target, index, values[index], options);
+  if (!isGuestHostObject(target)) objectProperties(target, true);
+  if (context === void 0) {
+    for (const source of sources) {
+      if (source === null || source === void 0) continue;
+      const properties = isGuestHostObject(source) ? void 0 : reflectionProperties(source);
+      const keys = properties === void 0 ? ownEnumerableSandboxKeys(source, true) : [...Object.getOwnPropertyNames(properties), ...ownSandboxSymbolKeys(source)];
+      for (const key of keys) {
+        if (!hasOwnSandboxProperty(source, key, true)) continue;
+        const value = properties === void 0 ? getSandboxDataProperty(source, key, budget) : Reflect.get(properties, key, source);
+        setSandboxProperty(target, key, value, budget);
+      }
+    }
+    return target;
   }
-  await writeArrayProperty(target, "length", length, options);
-  return length;
-}
-function isCallbackArrayMethod(methodName) {
-  return methodName === "map" || methodName === "filter" || methodName === "find" || methodName === "findIndex" || methodName === "findLast" || methodName === "findLastIndex" || methodName === "some" || methodName === "every" || methodName === "reduce" || methodName === "reduceRight" || methodName === "forEach" || methodName === "flatMap" || methodName === "sort";
+  return (async () => {
+    const release = retainValues(budget, () => [target, ...sources]);
+    try {
+      for (const source of sources) {
+        if (source === null || source === void 0) continue;
+        const properties = isGuestHostObject(source) ? void 0 : reflectionProperties(source);
+        const keys = properties === void 0 ? ownEnumerableSandboxKeys(source, true) : [...Object.getOwnPropertyNames(properties), ...ownSandboxSymbolKeys(source)];
+        for (const key of keys) {
+          if (!hasOwnSandboxProperty(source, key, true)) continue;
+          const value = await (context?.getProperty !== void 0 ? context.getProperty(source, key) : isGuestHostObject(source) ? getSandboxDataProperty(source, key, budget) : readPropertyDescriptor(Object.getOwnPropertyDescriptor(properties, key), source, context, true));
+          await setSandboxProperty(target, key, value, budget, true, context);
+        }
+      }
+      return target;
+    } finally {
+      release();
+    }
+  })();
 }
-function isMutatingArrayMethod(methodName) {
-  return methodName === "splice" || methodName === "fill" || methodName === "copyWithin" || methodName === "sort" || methodName === "reverse" || methodName === "push" || methodName === "pop" || methodName === "shift" || methodName === "unshift";
+function reflectionProperties(value) {
+  if (value !== null && value !== void 0 && typeof value !== "object")
+    value = createSandboxBox(value);
+  return objectProperties(value);
 }
-function getRequiredCallback(methodName, value) {
-  if (!isSandboxClosure(value)) {
-    throw new TypeError(`Array#${methodName} requires a sandbox closure callback.`);
+function objectProperties(value, mutable = false) {
+  if (isSandboxPromise(value)) return getPromiseProperties(value);
+  if (isSandboxMap(value) || isSandboxSet(value)) return getCollectionProperties(value);
+  if (isSandboxRegex(value)) return getRegexProperties(value);
+  if (isSandboxDate(value)) {
+    return value;
   }
-  return value;
-}
-function readArrayElement(value, index, options) {
-  const receiver = arrayLikeSources.get(value) ?? value;
-  return options.context?.getProperty !== void 0 ? 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 (isGuestHostObject(value))
+    throw new TypeError("Live host object descriptors are not supported.");
+  if (isGuestClosure(value)) return materializeFunctionProperties(value);
+  if (isSandboxClosure(value)) {
+    if (mutable) throw new TypeError("Host function properties are read only.");
+    return value.properties ?? /* @__PURE__ */ Object.create(null);
   }
-  if (options.setProperty !== void 0) 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 === void 0 ? 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);
+  if (!isAssignableSandboxTarget(value))
+    throw new TypeError("Expected a sandbox object or function.");
+  return value;
 }
-async function mapArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  options.budget.allocateArrayLength(length);
-  const result = new Array(length);
-  options.budget.setRetainedValues(result, () => [result]);
-  try {
-    for (let index = 0; index < length; index += 1) {
-      options.budget.visitNode();
-      if (!(index in value)) {
-        continue;
-      }
-      result[index] = await callArrayCallback(
-        callback,
-        await readArrayElement(value, index, options),
-        index,
-        value,
-        options,
-        stack,
-        thisValue
-      );
-    }
-    return result;
-  } finally {
-    options.budget.setRetainedValues(result, void 0);
-  }
+function exposePropertyDescriptor(descriptor) {
+  return "value" in descriptor ? descriptor : {
+    get: accessorClosure(descriptor.get),
+    set: accessorClosure(descriptor.set),
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable
+  };
 }
-async function filterArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  const result = [];
-  options.budget.setRetainedValues(result, () => [result]);
+async function propertyDescriptor(input, budget, context) {
+  objectProperties(input);
+  const descriptor = {};
+  const release = retainValues(budget, () => [
+    input,
+    descriptor.value,
+    ...retainedAccessorClosures(descriptor)
+  ]);
   try {
-    for (let index = 0; index < length; index += 1) {
-      options.budget.visitNode();
-      if (!(index in value)) {
+    for (const field of [
+      "enumerable",
+      "configurable",
+      "value",
+      "writable",
+      "get",
+      "set"
+    ]) {
+      if (getSandboxPropertyDescriptor(input, field, budget) === void 0 && !hasOwnSandboxProperty(input, field, false))
         continue;
-      }
-      const entry = await readArrayElement(value, index, options);
-      if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
-        result.push(entry);
+      const value = await (context?.getProperty !== void 0 ? context.getProperty(input, field) : getSandboxDataProperty(input, field, budget));
+      if (field === "get" || field === "set") {
+        if (value !== void 0 && !isSandboxClosure(value))
+          throw new TypeError("Accessor must be a function or undefined.");
+        descriptor[field] = value === void 0 ? void 0 : accessorAdapter(value, field);
+      } else if (field === "value") {
+        descriptor.value = value;
+      } else {
+        descriptor[field] = Boolean(value);
       }
     }
-    return result;
+    if (("get" in descriptor || "set" in descriptor) && ("value" in descriptor || "writable" in descriptor))
+      throw new TypeError("A property cannot be both a data property and an accessor.");
+    return descriptor;
   } finally {
-    options.budget.setRetainedValues(result, void 0);
+    release();
   }
 }
-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 = await readArrayElement(value, index, options);
-    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
-      return entry;
+async function definePropertiesFromObject(target, descriptors2, budget, context) {
+  objectProperties(target, true);
+  const properties = [];
+  const release = retainValues(budget, () => [
+    target,
+    descriptors2,
+    properties,
+    ...properties.flatMap(([, descriptor]) => retainedAccessorClosures(descriptor))
+  ]);
+  try {
+    for (const key of ownEnumerableSandboxKeys(descriptors2, true)) {
+      if (!hasOwnSandboxProperty(descriptors2, key, true)) continue;
+      const descriptor = await (context?.getProperty !== void 0 ? context.getProperty(descriptors2, key) : getSandboxDataProperty(descriptors2, key, budget));
+      properties.push([key, await propertyDescriptor(descriptor, budget, context)]);
     }
+    for (const [key, descriptor] of properties) defineDataProperty(target, key, descriptor, budget);
+  } finally {
+    release();
   }
-  return void 0;
 }
-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 = await readArrayElement(value, index, options);
-    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
-      return index;
+function defineDataProperty(target, key, descriptor, budget) {
+  budget.visitNode();
+  if (isFloat32Array(target))
+    throw new TypeError("Typed array property descriptors are not supported.");
+  const properties = objectProperties(target, true);
+  if (Array.isArray(properties)) {
+    if (key === "length" && "value" in descriptor)
+      budget.allocateArrayLength(Number(descriptor.value));
+    else if (typeof key !== "symbol") {
+      const index = Number(key);
+      if (Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key) {
+        budget.allocateArrayLength(index + 1);
+      }
     }
   }
-  return -1;
+  Object.defineProperty(properties, key, descriptor);
+  markDescriptorObject(properties);
 }
-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 = await readArrayElement(value, index, options);
-    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
-      return entry;
-    }
-  }
-  return void 0;
+function isAssignableSandboxTarget(value) {
+  return typeof value === "object" && value !== null && !isSandboxClosure(value) && !isSandboxGenerator(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isSandboxPromise(value) && !isSandboxRegex(value);
 }
-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 = await readArrayElement(value, index, options);
-    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
-      return index;
-    }
+async function arrayFromSandboxValues(args, budget, context) {
+  const [items, mapFn, thisValue] = args;
+  if (mapFn !== void 0 && !isSandboxClosure(mapFn)) {
+    throw new TypeError("Array.from mapping callback must be a function.");
   }
-  return -1;
-}
-async function someInArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  for (let index = 0; index < length; index += 1) {
-    options.budget.visitNode();
-    if (!(index in value)) {
-      continue;
-    }
-    if (await callArrayCallback(
-      callback,
-      await readArrayElement(value, index, options),
-      index,
-      value,
-      options,
-      stack,
-      thisValue
-    )) {
-      return true;
-    }
+  if (items === null || items === void 0) {
+    throw new TypeError("Array.from requires a non-null input.");
   }
-  return false;
-}
-async function everyInArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  for (let index = 0; index < length; index += 1) {
-    options.budget.visitNode();
-    if (!(index in value)) {
-      continue;
-    }
-    if (!await callArrayCallback(
-      callback,
-      await readArrayElement(value, index, options),
-      index,
-      value,
-      options,
-      stack,
-      thisValue
-    )) {
-      return false;
+  const read = (property) => context?.getProperty !== void 0 ? context.getProperty(items, property) : getSandboxDataProperty(items, property, budget);
+  const iterator = context === void 0 ? getSandboxIterator(items, budget) : await acquireSandboxIterator(items, budget, context);
+  const constructor = context?.thisValue;
+  let result;
+  let currentValue;
+  let failure;
+  const retained = {};
+  budget.setRetainedValues(retained, () => [
+    items,
+    iterator?.retainedValue,
+    mapFn,
+    constructor,
+    result,
+    currentValue,
+    failure
+  ]);
+  const checkData = createDataCheckpoint(budget, context);
+  const closeOnThrow = async (error) => {
+    failure = isCapturedException(error) ? error.reason : error;
+    try {
+      if (iterator !== void 0) await closeIterator(iterator, true);
+    } catch (closeError) {
+      if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
     }
-  }
-  return true;
-}
-async function reduceArray(value, callback, hasInitialValue, initialValue, options, stack) {
-  const length = value.length;
-  if (hasInitialValue) {
-    return reduceFromLeft(value, callback, initialValue, 0, length, options, stack);
-  }
-  const start = findNextDefinedIndex(value, 0, 1, length, options.budget);
-  if (start < 0) {
-    throw new TypeError("Reduce of empty array with no initial value.");
-  }
-  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;
-  if (hasInitialValue) {
-    return reduceFromRight(value, callback, initialValue, length - 1, length, options, stack);
-  }
-  const start = findNextDefinedIndex(value, length - 1, -1, length, options.budget);
-  if (start < 0) {
-    throw new TypeError("Reduce of empty array with no initial value.");
-  }
-  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;
-  const retainedAccumulator = {};
-  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+    throw error;
+  };
   try {
-    for (let index = startIndex; index < length; index += 1) {
-      options.budget.visitNode();
-      if (!(index in value)) {
-        continue;
+    let length = 0;
+    if (iterator === void 0) {
+      const number = await sandboxNumber(await read("length"), budget, context);
+      length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+    }
+    result = isSandboxClosure(constructor) && constructor.construct !== void 0 ? await invokeBuiltinClosure(
+      constructor,
+      iterator === void 0 ? [length] : [],
+      budget,
+      context,
+      void 0,
+      true
+    ) : createArrayFromConstructorArgs([length], budget);
+    checkData(result, 0, true);
+    let index = 0;
+    while (iterator !== void 0 || index < length) {
+      try {
+        budget.visitNode();
+        if (iterator !== void 0 && index >= Number.MAX_SAFE_INTEGER)
+          throw new TypeError("Array.from input is too long.");
+      } catch (error) {
+        await closeOnThrow(error);
       }
-      current = await options.callClosure(
-        callback,
-        [
-          current,
-          await readArrayElement(value, index, options),
-          index,
-          arrayLikeSources.get(value) ?? value
-        ],
-        stack
-      );
+      if (iterator !== void 0) {
+        const next = await iterator.next();
+        if (typeof next !== "object" || next === null)
+          throw new TypeError("Iterator result must be an object.");
+        if ((await readIteratorResult(iterator, next, "done")).value) break;
+        currentValue = (await readIteratorResult(iterator, next, "value")).value;
+      } else {
+        currentValue = await read(index);
+      }
+      try {
+        if (Array.isArray(result)) budget.allocateArrayLength(index + 1);
+        if (mapFn !== void 0)
+          currentValue = await invokeBuiltinClosure(
+            mapFn,
+            [currentValue, index],
+            budget,
+            context,
+            thisValue
+          );
+        const key = String(index);
+        const growth = key.length + 1 + (Array.isArray(result) ? Math.max(0, index + 1 - result.length) : 0) + (budget.limits.dataSize === void 0 ? 0 : measureSandboxData([currentValue]));
+        budget.visitNode();
+        defineOwnDataProperty(objectProperties(result, true), key, currentValue);
+        currentValue = void 0;
+        checkData(result, growth, isSandboxClosure(result));
+      } catch (error) {
+        await closeOnThrow(error);
+      }
+      index += 1;
     }
-    return current;
+    setSandboxProperty(result, "length", index, budget);
+    checkData(result, 0, true);
+    return allocateProducedSandboxValue(result, budget);
   } finally {
-    options.budget.setRetainedValues(retainedAccumulator, void 0);
+    budget.setRetainedValues(retained, void 0);
   }
 }
-async function reduceFromRight(value, callback, accumulator, startIndex, length, options, stack) {
-  let current = accumulator;
-  const retainedAccumulator = {};
-  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+function createArrayFromConstructorArgs(args, budget) {
+  if (args.length !== 1) {
+    return budgetSandboxValue(Reflect.apply(Array, Array, [...args]), budget);
+  }
+  const [lengthOrValue] = args;
+  if (typeof lengthOrValue !== "number") {
+    return budgetSandboxValue([lengthOrValue], budget);
+  }
+  if (!Number.isInteger(lengthOrValue) || lengthOrValue < 0 || lengthOrValue > 4294967295) {
+    throw new RangeError("Invalid array length.");
+  }
+  budget.allocateArrayLength(lengthOrValue);
+  const release = budget.provisionDataUsage(lengthOrValue + 1);
   try {
-    for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
-      options.budget.visitNode();
-      if (!(index in value)) {
-        continue;
-      }
-      current = await options.callClosure(
-        callback,
-        [
-          current,
-          await readArrayElement(value, index, options),
-          index,
-          arrayLikeSources.get(value) ?? value
-        ],
-        stack
-      );
-    }
-    return current;
+    return new Array(lengthOrValue);
   } finally {
-    options.budget.setRetainedValues(retainedAccumulator, void 0);
-  }
-}
-async function forEachArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  for (let index = 0; index < length; index += 1) {
-    options.budget.visitNode();
-    if (!(index in value)) {
-      continue;
-    }
-    await callArrayCallback(
-      callback,
-      await readArrayElement(value, index, options),
-      index,
-      value,
-      options,
-      stack,
-      thisValue
-    );
+    release();
   }
 }
-async function flatMapArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  const result = [];
-  options.budget.setRetainedValues(result, () => [result]);
+async function getOwnEnumerableEntries(value, budget, context) {
+  const entries = [];
+  const release = retainValues(budget, () => [value, entries]);
   try {
-    for (let index = 0; index < length; index += 1) {
-      options.budget.visitNode();
-      if (!(index in value)) {
-        continue;
-      }
-      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(await readArrayElement(mapped, mappedIndex, options));
-          options.budget.allocateArrayLength(result.length);
-        }
-        continue;
-      }
-      result.push(mapped);
-      options.budget.allocateArrayLength(result.length);
+    for (const key of ownEnumerableSandboxKeys(value)) {
+      if (!hasOwnSandboxProperty(value, key, true)) continue;
+      entries.push([
+        key,
+        await (context?.getProperty !== void 0 ? context.getProperty(value, key) : getSandboxDataProperty(value, key, budget))
+      ]);
     }
-    return result;
+    return entries;
   } finally {
-    options.budget.setRetainedValues(result, void 0);
+    release();
   }
 }
-async function flattenArray(value, depth, options) {
-  const result = [];
-  const retained = {};
-  options.budget.setRetainedValues(retained, () => [result]);
+function budgetSandboxValue(value, budget) {
+  const sandboxValue = deepCopyToSandbox(value);
+  return allocateProducedSandboxValue(sandboxValue, budget);
+}
+function stringFromCodes(args, convert, budget, context) {
+  let result = "";
+  let index = 0;
+  const release = retainValues(budget, () => [...args, result]);
   try {
-    await appendFlattenedEntries(value, depth, result, options);
+    const output = advance();
+    if (typeof output !== "string") return output.finally(release);
+    release();
+    return output;
+  } catch (error) {
+    release();
+    throw error;
+  }
+  function advance() {
+    while (index < args.length) {
+      budget.visitNode();
+      const number = sandboxNumber(args[index++], budget, context);
+      if (number instanceof Promise) return number.then((value) => {
+        result = budget.allocateString(result + convert(value));
+        return advance();
+      });
+      result = budget.allocateString(result + convert(number));
+    }
     return result;
-  } finally {
-    options.budget.setRetainedValues(retained, void 0);
   }
 }
-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 = await readArrayElement(value, index, options);
-    if (depth > 0 && Array.isArray(entry)) {
-      await appendFlattenedEntries(entry, depth - 1, result, options);
-      continue;
+function stringRaw(args, budget, context) {
+  const [template, ...substitutions] = args;
+  if (context?.getProperty !== void 0)
+    return (async () => {
+      if (template === null || template === void 0)
+        throw new TypeError("String.raw requires a template object.");
+      const raw2 = await context.getProperty(template, "raw");
+      if (raw2 === null || raw2 === void 0)
+        throw new TypeError("String.raw requires raw strings.");
+      const number = await sandboxNumber(
+        await context.getProperty(raw2, "length"),
+        budget,
+        context
+      );
+      const length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+      let result2 = "";
+      const retained = {};
+      budget.setRetainedValues(retained, () => [raw2, result2]);
+      try {
+        for (let index = 0; index < length; index++) {
+          budget.visitNode();
+          result2 = budget.allocateString(
+            result2 + await sandboxString(await context.getProperty(raw2, index), budget, context)
+          );
+          if (index + 1 < length && index < substitutions.length)
+            result2 = budget.allocateString(
+              result2 + await sandboxString(substitutions[index], budget, context)
+            );
+        }
+        return result2;
+      } finally {
+        budget.setRetainedValues(retained, void 0);
+      }
+    })();
+  const raw = getTemplateRawParts(template);
+  let result = "";
+  for (let index = 0; index < raw.length; index += 1) {
+    result += String(raw[index]);
+    if (index < raw.length - 1 && index < substitutions.length) {
+      result += String(substitutions[index]);
     }
-    result.push(entry);
-    options.budget.allocateArrayLength(result.length);
   }
+  return budget.allocateString(result);
 }
-async function sortArray(value, comparator, options, stack) {
-  const length = value.length;
-  const definedValues = [];
-  let undefinedCount = 0;
-  let currentEntry;
-  options.budget.setRetainedValues(definedValues, () => [definedValues, currentEntry]);
+function getTemplateRawParts(template) {
+  const raw = typeof template === "object" && template !== null ? template.raw : void 0;
+  if (typeof template !== "object" || template === null || isSandboxClosure(template) || isSandboxPromise(template) || !Array.isArray(raw)) {
+    throw new TypeError("String.raw requires a raw strings array.");
+  }
+  return raw;
+}
+
+// packages/safe-js/src/interp/classes.ts
+async function evaluateClass(node, context, evaluateNode2, callContext) {
+  const scope = context.scope.child();
+  if (node.id !== void 0) scope.predeclare(node.id.name, "const");
+  const classContext = { ...context, scope, inferredName: void 0 };
+  let parent;
+  let prototypeParent;
+  const fields2 = [];
+  const statics = [];
+  let constructor;
+  const release = retainValues(context.budget, () => [parent, prototypeParent, constructor, ...fields2.map((field) => field.key), ...statics.flatMap((field) => "key" in field ? [field.key] : [])]);
   try {
-    for (let index = 0; index < length; index += 1) {
-      options.budget.visitNode();
-      if (!(index in value)) {
+    if (node.superClass !== void 0) {
+      const result = await evaluateNode2(node.superClass, classContext);
+      if (result.kind !== "normal") return result;
+      parent = result.value;
+      if (parent !== null && (!isSandboxClosure(parent) || parent.construct === void 0))
+        throw new TypeError("Class extends value is not a constructor or null.");
+      prototypeParent = parent === null ? null : await callContext.getProperty(parent, "prototype");
+      if (prototypeParent !== null && typeof prototypeParent !== "object")
+        throw new TypeError("Class extends value has an invalid prototype.");
+    }
+    const derived = node.superClass !== void 0;
+    constructor = createClassConstructor(node, { ...classContext, inferredName: context.inferredName }, evaluateNode2, fields2);
+    const properties = materializeFunctionProperties(constructor);
+    const prototype = properties.prototype;
+    Object.defineProperty(properties, "prototype", { writable: false });
+    if (derived) setSandboxPrototype(prototype, prototypeParent, context.budget);
+    if (isSandboxClosure(parent)) setSandboxPrototype(constructor, parent, context.budget);
+    const pattern = createPatternContext(classContext, scope, evaluateNode2);
+    for (const element of node.body.body) {
+      context.budget.visitNode();
+      if (element.type === "StaticBlock") {
+        statics.push({ element });
         continue;
       }
-      const entry = await readArrayElement(value, index, options);
-      if (entry === void 0) {
-        undefinedCount += 1;
-        continue;
+      if (element.type === "MethodDefinition" && element.kind === "constructor") continue;
+      let key;
+      if (element.computed) {
+        const result = await evaluateNode2(element.key, classContext);
+        if (result.kind !== "normal") return result;
+        key = await pattern.toPropertyKey(result.value);
+      } else {
+        key = element.key.type === "Identifier" ? element.key.name : String(element.key.value);
       }
-      definedValues.push(entry);
-    }
-    for (let index = 1; index < definedValues.length; index += 1) {
-      currentEntry = definedValues[index];
-      let cursor = index - 1;
-      while (cursor >= 0 && await compareEntries(definedValues[cursor], currentEntry, comparator, options, stack) > 0) {
-        definedValues[cursor + 1] = definedValues[cursor];
-        cursor -= 1;
+      if (typeof key === "string") context.budget.allocateString(key);
+      if (element.type === "PropertyDefinition") {
+        (element.static ? statics : fields2).push({ element, key });
+      } else {
+        const home = element.static ? constructor : prototype;
+        const method = createInterpretedClosure(element.value, classContext, evaluateNode2, home);
+        const accessor = element.kind === "get" || element.kind === "set" ? element.kind : void 0;
+        Object.defineProperty(materializeFunctionProperties(method), "name", {
+          value: accessor === void 0 ? propertyFunctionName(key) : `${accessor} ${propertyFunctionName(key)}`
+        });
+        Object.defineProperty(
+          element.static ? properties : prototype,
+          key,
+          accessor === void 0 ? { value: method, configurable: true, writable: true, enumerable: false } : { [accessor]: accessorAdapter(method, accessor), configurable: true, enumerable: false }
+        );
       }
-      definedValues[cursor + 1] = currentEntry;
     }
-    currentEntry = void 0;
-    for (let index = 0; index < definedValues.length; index += 1) {
-      await writeArrayProperty(value, index, definedValues[index], options);
-    }
-    for (let index = 0; index < undefinedCount; index += 1) {
-      await writeArrayProperty(value, definedValues.length + index, void 0, options);
-    }
-    for (let index = definedValues.length + undefinedCount; index < length; index += 1) {
-      options.budget.visitNode();
-      deleteArrayElement(value, index, options);
+    if (node.id !== void 0) scope.declare(node.id.name, "const", constructor);
+    for (const element of statics) await initializeElement(element, constructor, constructor, classContext, evaluateNode2);
+    classOrigins.get(constructor).initialized = true;
+    if (node.type === "ClassDeclaration") {
+      context.scope.declare(node.id.name, "let", constructor);
+      return { kind: "normal", hasValue: false, value: void 0 };
     }
+    return { kind: "normal", hasValue: true, value: constructor };
   } finally {
-    options.budget.setRetainedValues(definedValues, void 0);
+    release();
   }
 }
-async function compareEntries(left, right, comparator, options, stack) {
-  options.budget.visitNode();
-  if (comparator === void 0) {
-    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();
+var classOrigins = /* @__PURE__ */ new WeakMap();
+function createClassConstructor(node, context, evaluateNode2, fields2) {
+  const scope = context.scope;
+  const classContext = { ...context, inferredName: void 0 };
+  const constructorElement = node.body.body.find((element) => element.type === "MethodDefinition" && element.kind === "constructor");
+  const derived = node.superClass !== void 0;
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: node.id?.name ?? context.inferredName ?? "",
+    length: constructorElement === void 0 ? 0 : getFunctionLength(constructorElement.value.params),
+    sourceRange: functionSources.get(node),
+    retainedValues: () => [...scope.retainedValues(), ...fields2.map((field) => field.key)],
+    call: () => {
+      throw new TypeError("Class constructor cannot be invoked without 'new'.");
+    },
+    construct: async (args, invocation) => {
+      const prototype = materializeFunctionProperties(constructor).prototype;
+      const newTarget = invocation?.newTarget ?? constructor;
+      let thisValue;
+      let thisScope;
+      let initialized = !derived;
+      const initializeFields = async (receiver) => {
+        for (const field of fields2) {
+          await initializeElement(field, receiver, prototype, classContext, evaluateNode2);
+        }
+      };
+      const superCall = async (argumentsList) => {
+        const superConstructor = getSandboxPrototype(constructor, context.budget);
+        if (!isSandboxClosure(superConstructor) || superConstructor.construct === void 0)
+          throw new TypeError("Super constructor is not a constructor.");
+        const receiver = await invocation.invokeClosure(superConstructor, argumentsList, void 0, true, newTarget);
+        if (initialized) throw new ReferenceError("Super constructor may only initialize this once.");
+        initialized = true;
+        thisValue = receiver;
+        thisScope?.declare("this", "const", receiver);
+        await initializeFields(receiver);
+        return receiver;
+      };
+      if (!derived) {
+        thisValue = {};
+        const targetPrototype = await invocation.getProperty(newTarget, "prototype");
+        if (typeof targetPrototype === "object" && targetPrototype !== null)
+          setSandboxPrototype(thisValue, targetPrototype, context.budget);
+      }
+      if (constructorElement === void 0) {
+        if (derived) return superCall(args);
+        await initializeFields(thisValue);
+        return thisValue;
+      }
+      const result = await executeClosure(constructorElement.value, args, thisValue, {
+        ...classContext,
+        compilation: invocation?.compilation ?? context.compilation,
+        callStack: [...invocation?.stack ?? context.callStack],
+        functionEnvironment: {
+          newTarget,
+          homeObject: prototype,
+          construction: {
+            derived,
+            superCall,
+            initialize: async (functionScope) => {
+              thisScope = functionScope;
+              if (!derived) await initializeFields(thisValue);
+            }
+          }
+        }
+      }, evaluateNode2);
+      if (typeof result === "object" && result !== null) return result;
+      if (derived && result !== void 0) throw new TypeError("Derived constructors may only return an object or undefined.");
+      if (!initialized) throw new ReferenceError("Must call super constructor before returning from derived constructor.");
+      return thisValue;
     }
-  }
-  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, array2, options, stack, thisValue) {
-  return options.callClosure(
-    callback,
-    [value, index, arrayLikeSources.get(array2) ?? array2],
-    stack,
-    thisValue
-  );
+  });
+  classOrigins.set(constructor, { node, scope, fields: fields2, initialized: false });
+  return constructor;
 }
-function findNextDefinedIndex(value, startIndex, direction, length, budget) {
-  for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {
-    budget.visitNode();
-    if (index in value) {
-      return index;
-    }
+async function initializeElement(definition, receiver, homeObject, context, evaluateNode2) {
+  const scope = context.scope.child({}, { functionBoundary: true });
+  scope.declare("this", "const", receiver);
+  const element = definition.element;
+  const initializer = element.type === "StaticBlock" ? element.body : element.value;
+  let value;
+  if (initializer !== void 0) {
+    if (element.type === "StaticBlock") hoistVarDeclarations(element.body, scope);
+    const result = await evaluateNode2(initializer, { ...context, scope, functionEnvironment: { homeObject }, inferredName: "key" in definition ? propertyFunctionName(definition.key) : void 0 });
+    if (result.kind === "error") throw result.error;
+    if (result.kind === "throw") throw result.value;
+    value = result.hasValue ? result.value : void 0;
   }
-  return -1;
-}
-function budgetProducedValue(value, budget) {
-  if (typeof value === "object" && value !== null) value = arrayLikeSources.get(value) ?? value;
-  allocateProducedValue(value, budget, /* @__PURE__ */ new WeakSet());
-  return value;
-}
-function allocateProducedValue(value, budget, seen) {
-  if (typeof value === "string") {
-    budget.allocateString(value);
-    return;
+  if ("key" in definition) {
+    defineDataProperty(receiver, definition.key, { value, configurable: true, writable: true, enumerable: true }, context.budget);
   }
-  if (Array.isArray(value)) {
-    budget.allocateArrayLength(value.length);
-    if (seen.has(value)) {
-      return;
-    }
-    seen.add(value);
-    for (const entry of value) {
-      allocateProducedValue(entry, budget, seen);
-    }
-    return;
+}
+
+// packages/safe-js/src/interp/resume-target.ts
+function containsResumeTarget(node, targetNodeIds) {
+  if (targetNodeIds === void 0 ? node.type === "YieldExpression" : node.nodeId !== void 0 && targetNodeIds.has(node.nodeId)) {
+    return true;
   }
-  if (isSandboxMap(value)) {
-    budget.allocateCollectionEntries(value.entries.size);
-    if (seen.has(value)) {
-      return;
-    }
-    seen.add(value);
-    for (const [key, entry] of value.entries) {
-      allocateProducedValue(key, budget, seen);
-      allocateProducedValue(entry, budget, seen);
-    }
-    return;
+  if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") {
+    return false;
   }
-  if (isSandboxSet(value)) {
-    budget.allocateCollectionEntries(value.values.size);
-    if (seen.has(value)) {
-      return;
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      if (value.some((entry) => isParseResult(entry) && containsResumeTarget(entry, targetNodeIds))) {
+        return true;
+      }
+      continue;
     }
-    seen.add(value);
-    for (const entry of value.values) {
-      allocateProducedValue(entry, budget, seen);
+    if (isParseResult(value) && containsResumeTarget(value, targetNodeIds)) {
+      return true;
     }
-    return;
-  }
-  if (typeof value !== "object" || value === null || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value)) {
-    return;
-  }
-  if (seen.has(value)) {
-    return;
-  }
-  seen.add(value);
-  for (const entry of Object.values(value)) {
-    allocateProducedValue(entry, budget, seen);
   }
+  return false;
 }
-function toIntegerOrInfinity(value) {
-  const number = Number(value);
-  if (Number.isNaN(number) || Object.is(number, 0) || Object.is(number, -0)) {
-    return 0;
-  }
-  if (!Number.isFinite(number)) {
-    return number;
-  }
-  return Math.trunc(number);
+function isParseResult(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string" && Object.hasOwn(value, "span");
 }
 
 // packages/safe-js/src/interp/function-string.ts
@@ -16632,7 +16810,7 @@ async function evaluateMemberCallExpression(node, context) {
       property: await toPropertyKey(reference.property, context.budget, createCoercionContext(context))
     };
     if (context.generatorYield !== void 0 && node.arguments.some((argument) => containsResumeTarget(argument.type === "SpreadElement" ? argument.argument : argument))) {
-      if (Array.isArray(member.object) && !hasExplicitSandboxPrototype(member.object) && typeof member.property !== "symbol" && isArrayMethodName(member.property) && !Object.hasOwn(member.object, member.property))
+      if (Array.isArray(member.object) && typeof member.property !== "symbol" && isArrayMethodName(member.property) && isDefaultArrayMethod(member.object, member.property, context.budget))
         return evaluateArrayMethodCall(node, member.object, member.property, context);
       const receiver = member.superReceiver?.value ?? member.object;
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context, receiver), context, receiver);
@@ -16645,6 +16823,8 @@ async function evaluateMemberCallExpression(node, context) {
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
     if (Array.isArray(member.object) && hasExplicitSandboxPrototype(member.object))
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
+    if (Array.isArray(member.object) && isArrayMethodName(member.property) && !isDefaultArrayMethod(member.object, member.property, context.budget))
+      return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
     if ((typeof member.object === "string" || typeof member.object === "number" || typeof member.object === "bigint" || typeof member.object === "boolean" || typeof member.object === "symbol") && getBoxedPrototype(member.object, context.budget) !== void 0) {
       if (isDefaultBoxedMethod(member.object, member.property, context.budget)) {
         if (typeof member.object === "string" && isStringMethodName(member.property))
@@ -16688,6 +16868,8 @@ async function evaluateMemberCallExpression(node, context) {
       );
     }
     if (Array.isArray(member.object) && !Object.hasOwn(member.object, member.property)) {
+      if (getSandboxPropertyDescriptor(member.object, member.property, context.budget) !== void 0)
+        return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
       return evaluatePrimitiveMemberCall(
         node,
         "Array",
@@ -17259,6 +17441,7 @@ function getArrayMemberValue(target, property, context) {
   if (property === "raw" && templateRawArrays.has(target)) {
     return templateRawArrays.get(target);
   }
+  if (getSandboxPrototype(target, context.budget) !== null) return void 0;
   return getArrayMember(target, property, createArrayMethodOptions(context));
 }
 function setSandboxProperty(target, property, value, budget, checkInherited = true, context) {
@@ -17911,7 +18094,7 @@ async function objectToPrimitive(value, budget, context, joining, hint, ordinary
   }
 }
 function conversionHook(value, name, budget, context) {
-  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) && getSandboxPrototype(value, budget) === null || isSandboxGenerator(value) || isGuestHostObject(value));
+  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) && getSandboxPrototype(value, budget) === null || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) && getSandboxPrototype(value, budget) === null || isSandboxGenerator(value) || isGuestHostObject(value));
   let current = value;
   let depth = 0;
   while (current !== null) {
@@ -18029,6 +18212,20 @@ function createObjectGlobal(methods, budget) {
     Object.defineProperty(properties, name, { value: method, writable: true, configurable: true });
   }
   const prototypeMethods = {
+    toLocaleString: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "toLocaleString",
+      length: 0,
+      call: async (_args, context) => {
+        const receiver = requireReceiver(context?.thisValue);
+        const object = construct([receiver]);
+        const descriptor = getSandboxPropertyDescriptor(object, "toString", budget);
+        const method = context?.getProperty === void 0 ? descriptor === void 0 ? void 0 : await readPropertyDescriptor(descriptor, receiver, context) : await context.getProperty(receiver, "toString");
+        if (!isSandboxClosure(method)) throw new TypeError("toString must be callable.");
+        return invokeBuiltinClosure(method, [], budget, context, receiver);
+      }
+    }),
     toString: createSandboxClosure({
       sandbox: true,
       name: "toString",
@@ -23642,6 +23839,17 @@ function createBigIntGlobal(budget) {
       writable: true,
       configurable: true
     },
+    toLocaleString: {
+      value: createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name: "toLocaleString",
+        length: 0,
+        call: (args, context) => formatNumberLocale(primitiveReceiver(context?.thisValue, "bigint"), args, budget, context)
+      }),
+      writable: true,
+      configurable: true
+    },
     [Symbol.toStringTag]: { value: "BigInt", configurable: true }
   });
   const properties = materializeFunctionProperties(constructor);
@@ -40519,4 +40727,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-ZOLHW4OV.js.map
+//# sourceMappingURL=chunk-SZZFUQKW.js.map