poe-code 14.0.52 → 14.0.54

package/dist/index.js

@@ -144043,7 +144043,7 @@ function getArrayMember(value, property, options) {
     return createSandboxClosure({
       sandbox: true,
       name: `Array#${property}`,
-      call: (args, context) => callArrayMethod(value, property, args, options, context?.stack ?? [])
+      call: (args, context) => callArrayMethod(context?.thisValue, property, args, { ...options, context }, context?.stack ?? [])
     });
   }
   return void 0;
@@ -144058,28 +144058,75 @@ function getArrayIndex(property) {
 function isArrayMethodName(property) {
   return typeof property === "string" && arrayMethodNames.has(property);
 }
-async function callArrayMethod(value, methodName, args, options, stack = []) {
-  if (isMutatingArrayMethod(methodName)) {
-    assertCollectionMutable(value);
-  }
-  if (isCallbackArrayMethod(methodName)) {
-    let callbackState = activeArrayCallbacks.get(value);
-    if (callbackState === void 0) {
-      callbackState = { depth: 0, leave: enterRunningState(value) };
-      activeArrayCallbacks.set(value, callbackState);
+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") throw new TypeError("Object primitive boxing is not supported.");
+  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);
     }
-    callbackState.depth += 1;
-    try {
-      return await callArrayMethodUnlocked(value, methodName, args, options, stack);
-    } finally {
-      callbackState.depth -= 1;
-      if (callbackState.depth === 0) {
-        activeArrayCallbacks.delete(value);
-        callbackState.leave();
+    if (isCallbackArrayMethod(methodName)) {
+      let callbackState = activeArrayCallbacks.get(receiver);
+      if (callbackState === void 0) {
+        callbackState = { depth: 0, leave: enterRunningState(receiver) };
+        activeArrayCallbacks.set(receiver, callbackState);
+      }
+      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);
   }
-  return callArrayMethodUnlocked(value, methodName, args, options, stack);
+}
+async function arrayLikeView(receiver, options) {
+  const rawLength = options.context?.getProperty !== void 0 ? 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, key3) => {
+      options.budget.visitNode();
+      if (key3 === "length") return length;
+      if (typeof key3 !== "string") return void 0;
+      return options.context?.getProperty !== void 0 ? options.context.getProperty(receiver, key3) : getSandboxDataProperty(receiver, key3, options.budget);
+    },
+    has: (_target, key3) => {
+      options.budget.visitNode();
+      if (typeof key3 === "string" && options.hasProperty !== void 0) return options.hasProperty(receiver, key3);
+      for (let current = receiver; current !== null; current = getSandboxPrototype(current, options.budget)) {
+        options.budget.visitNode();
+        if (Object.hasOwn(current, key3)) return true;
+      }
+      return false;
+    },
+    set: (_target, key3, entry) => {
+      options.budget.visitNode();
+      if (typeof key3 !== "string") throw new TypeError("Array indices must be string keys.");
+      if (options.setProperty !== void 0) options.setProperty(receiver, key3, entry);
+      else if (!Reflect.set(receiver, key3, entry)) throw new TypeError(`Cannot assign property '${key3}'.`);
+      return true;
+    },
+    deleteProperty: (_target, key3) => {
+      options.budget.visitNode();
+      if (typeof key3 === "string" && options.deleteProperty !== void 0) return options.deleteProperty(receiver, key3);
+      return Reflect.deleteProperty(receiver, key3);
+    }
+  });
+  arrayLikeSources.set(view, receiver);
+  return view;
 }
 async function callArrayMethodUnlocked(value, methodName, args, options, stack) {
   switch (methodName) {
@@ -144192,11 +144239,21 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       return Reflect.apply(Array.prototype.lastIndexOf, value, [...args]);
     case "join":
       return options.budget.allocateString(Reflect.apply(Array.prototype.join, value, [...args]));
-    case "slice":
-      return budgetProducedValue(
-        Reflect.apply(Array.prototype.slice, value, [...args]),
-        options.budget
-      );
+    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);
+      for (let index = 0; index < count; index += 1) {
+        options.budget.visitNode();
+        if (first + index in value) result[index] = value[first + index];
+      }
+      return budgetProducedValue(result, options.budget);
+    }
     case "concat":
       return budgetProducedValue(
         Reflect.apply(Array.prototype.concat, value, [...args]),
@@ -144223,7 +144280,7 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       );
     case "sort":
       if (args[0] === void 0) {
-        value.sort();
+        Reflect.apply(Array.prototype.sort, value, []);
         budgetProducedValue(value, options.budget);
         return value;
       }
@@ -144231,11 +144288,17 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       budgetProducedValue(value, options.budget);
       return value;
     case "reverse":
-      value.reverse();
+      Reflect.apply(Array.prototype.reverse, value, []);
       budgetProducedValue(value, options.budget);
       return value;
     case "toSorted": {
-      const result = Array.from(value);
+      const length = value.length;
+      options.budget.allocateArrayLength(length);
+      const result = new Array(length);
+      for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
+        result[index] = value[index];
+      }
       if (args[0] === void 0) {
         result.sort();
       } else {
@@ -144244,13 +144307,29 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       return budgetProducedValue(result, options.budget);
     }
     case "toReversed": {
-      const result = Array.from(value);
-      result.reverse();
+      const length = value.length;
+      options.budget.allocateArrayLength(length);
+      const result = new Array(length);
+      for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
+        result[index] = value[length - index - 1];
+      }
       return budgetProducedValue(result, options.budget);
     }
     case "toSpliced": {
-      const result = Array.from(value);
-      Reflect.apply(Array.prototype.splice, result, [...args]);
+      const length = value.length;
+      const start = toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context));
+      const first = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
+      const inserted = Math.max(args.length - 2, 0);
+      const deleted = args.length === 0 ? 0 : args.length === 1 ? length - first : Math.min(Math.max(toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context)), 0), length - first);
+      const resultLength = length + inserted - deleted;
+      if (resultLength > Number.MAX_SAFE_INTEGER) throw new TypeError("Array-like length exceeds the safe integer limit.");
+      options.budget.allocateArrayLength(resultLength);
+      const result = new Array(resultLength);
+      for (let index = 0; index < resultLength; index += 1) {
+        options.budget.visitNode();
+        result[index] = index < first ? value[index] : index < first + inserted ? args[index - first + 2] : value[index - inserted + deleted];
+      }
       return budgetProducedValue(result, options.budget);
     }
     case "with": {
@@ -144264,39 +144343,42 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       const result = [];
       for (let position = 0; position < length; position += 1) {
         options.budget.visitNode();
-        result[position] = position === actualIndex ? args[1] : Object.hasOwn(value, position) ? value[position] : void 0;
+        result[position] = position === actualIndex ? args[1] : Array.isArray(value) && !Object.hasOwn(value, position) ? void 0 : value[position];
       }
       return budgetProducedValue(result, options.budget);
     }
     case "push": {
-      appendArrayValues(value, args);
-      const nextLength = value.length;
+      const nextLength = appendArrayValues(value, args);
       budgetProducedValue(value, options.budget);
       return nextLength;
     }
     case "pop":
-      return budgetProducedValue(value.pop(), options.budget);
+      return budgetProducedValue(Reflect.apply(Array.prototype.pop, value, []), options.budget);
     case "shift":
-      return budgetProducedValue(value.shift(), options.budget);
+      return budgetProducedValue(Reflect.apply(Array.prototype.shift, value, []), options.budget);
     case "unshift": {
-      prependArrayValues(value, args);
-      const nextLength = value.length;
+      const nextLength = prependArrayValues(value, args);
       budgetProducedValue(value, options.budget);
       return nextLength;
     }
   }
 }
 function appendArrayValues(target, values) {
+  let length = target.length;
+  if (length + values.length > Number.MAX_SAFE_INTEGER) throw new TypeError("Array-like length exceeds the safe integer limit.");
   for (const value of values) {
-    target.push(value);
+    target[length++] = value;
   }
+  target.length = length;
+  return length;
 }
 function prependArrayValues(target, values) {
   const originalLength = target.length;
-  target.length = originalLength + values.length;
-  for (let index = originalLength - 1; index >= 0; index -= 1) {
+  const length = originalLength + values.length;
+  if (length > Number.MAX_SAFE_INTEGER) throw new TypeError("Array-like length exceeds the safe integer limit.");
+  for (let index = values.length === 0 ? -1 : originalLength - 1; index >= 0; index -= 1) {
     const targetIndex = index + values.length;
-    if (Object.hasOwn(target, index)) {
+    if (index in target) {
       target[targetIndex] = target[index];
     } else {
       delete target[targetIndex];
@@ -144305,6 +144387,8 @@ function prependArrayValues(target, values) {
   for (let index = 0; index < values.length; index += 1) {
     target[index] = values[index];
   }
+  target.length = length;
+  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";
@@ -144320,6 +144404,7 @@ function getRequiredCallback(methodName, 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 {
@@ -144465,7 +144550,7 @@ async function reduceFromLeft(value, callback, accumulator, startIndex, length,
       if (!(index in value)) {
         continue;
       }
-      current = await options.callClosure(callback, [current, value[index], index, value], stack);
+      current = await options.callClosure(callback, [current, value[index], index, arrayLikeSources.get(value) ?? value], stack);
     }
     return current;
   } finally {
@@ -144482,7 +144567,7 @@ async function reduceFromRight(value, callback, accumulator, startIndex, length,
       if (!(index in value)) {
         continue;
       }
-      current = await options.callClosure(callback, [current, value[index], index, value], stack);
+      current = await options.callClosure(callback, [current, value[index], index, arrayLikeSources.get(value) ?? value], stack);
     }
     return current;
   } finally {
@@ -144605,7 +144690,7 @@ async function compareEntries(left, right, comparator, options, stack) {
   return Number.isNaN(result) ? 0 : result;
 }
 async function callArrayCallback(callback, value, index, array, options, stack, thisValue) {
-  return options.callClosure(callback, [value, index, array], stack, thisValue);
+  return options.callClosure(callback, [value, index, arrayLikeSources.get(array) ?? array], stack, thisValue);
 }
 function findNextDefinedIndex(value, startIndex, direction, length, budget) {
   for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {
@@ -144617,6 +144702,7 @@ function findNextDefinedIndex(value, startIndex, direction, length, budget) {
   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;
 }
@@ -144680,12 +144766,15 @@ function toIntegerOrInfinity(value) {
   }
   return Math.trunc(number);
 }
-var activeArrayCallbacks, arrayMethodNames;
+var arrayLikeSources, activeArrayCallbacks, arrayMethodNames;
 var init_array = __esm({
   "packages/safe-js/src/interp/methods/array.ts"() {
     "use strict";
     init_values();
     init_running_state();
+    init_object_model();
+    init_string_coercion();
+    arrayLikeSources = /* @__PURE__ */ new WeakMap();
     activeArrayCallbacks = /* @__PURE__ */ new WeakMap();
     arrayMethodNames = /* @__PURE__ */ new Set([
       "map",
@@ -144967,68 +145056,48 @@ function getNumberMember(property, budget) {
   return createSandboxClosure({
     sandbox: true,
     name: `Number#${property}`,
-    call: (args, context) => callNumberMethod(context?.thisValue, property, args, budget)
+    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) {
+function callNumberMethod(value, methodName, args, budget, context) {
   if (typeof value !== "number") {
     throw new TypeError(`Number#${methodName} requires a number receiver.`);
   }
-  return budget.allocateString(callNativeNumberMethod(value, methodName, args));
-}
-function callNativeNumberMethod(value, methodName, args) {
-  switch (methodName) {
-    case "toString":
-      return value.toString(asValidatedRadix(args[0]));
-    case "toExponential":
-      return args[0] === void 0 ? value.toExponential() : value.toExponential(asValidatedFractionDigits(args[0], methodName));
-    case "toFixed":
-      return value.toFixed(asValidatedFractionDigits(args[0], methodName));
-    case "toPrecision":
-      return args[0] === void 0 ? value.toPrecision() : value.toPrecision(asValidatedPrecision(args[0]));
-  }
-}
-function asValidatedRadix(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const radix = toIntegerOrInfinity2(value);
-  if (radix < 2 || radix > 36) {
-    throw new RangeError("Number#toString radix must be between 2 and 36.");
+  const argument = args[0];
+  if (argument !== null && typeof argument === "object") {
+    return formatObjectArgument(value, methodName, argument, budget, context);
   }
-  return radix;
+  return formatNumber3(value, methodName, argument === void 0 ? void 0 : Number(argument), budget);
 }
-function asValidatedFractionDigits(value, methodName) {
-  const digits = toIntegerOrInfinity2(value);
-  if (digits < 0 || digits > 100) {
-    throw new RangeError(`Number#${methodName} digits must be between 0 and 100.`);
-  }
-  return digits;
-}
-function asValidatedPrecision(value) {
-  const precision = toIntegerOrInfinity2(value);
-  if (precision < 1 || precision > 100) {
-    throw new RangeError("Number#toPrecision precision must be between 1 and 100.");
+async function formatObjectArgument(value, methodName, argument, budget, context) {
+  const retainedArgument = {};
+  budget.setRetainedValues(retainedArgument, () => [argument]);
+  try {
+    const number = await sandboxNumber(argument, budget, context);
+    return formatNumber3(value, methodName, number, budget);
+  } finally {
+    budget.setRetainedValues(retainedArgument, void 0);
   }
-  return precision;
 }
-function toIntegerOrInfinity2(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;
+function formatNumber3(value, methodName, argument, budget) {
+  let result;
+  try {
+    result = value[methodName](argument);
+  } catch (error3) {
+    if (!(error3 instanceof RangeError)) throw error3;
+    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 Math.trunc(number);
+  return budget.allocateString(result);
 }
 var numberMethodNames;
 var init_number = __esm({
   "packages/safe-js/src/interp/methods/number.ts"() {
     "use strict";
+    init_string_coercion();
     init_values();
     numberMethodNames = /* @__PURE__ */ new Set([
       "toExponential",
@@ -145084,14 +145153,27 @@ function getStringMember(value, property, budget) {
     name: `String#${property}`,
     ...property === "localeCompare" ? { length: 1 } : {},
     ...property === "isWellFormed" || property === "toWellFormed" ? { length: 0 } : {},
-    call: (args, context) => callStringMethod(
-      value,
-      property,
-      args,
-      budget,
-      context === void 0 ? void 0 : async (closure, closureArgs) => await closure.call(closureArgs, { ...context, thisValue: void 0 }),
-      context?.compilation
-    )
+    call: async (args, context) => {
+      const receiver = context?.thisValue;
+      if (receiver === null || receiver === void 0) {
+        throw new TypeError(`String#${property} requires a non-null receiver.`);
+      }
+      const retainedReceiver = {};
+      budget.setRetainedValues(retainedReceiver, () => [receiver]);
+      try {
+        const string = await sandboxString(receiver, budget, context);
+        return await callStringMethod(
+          string,
+          property,
+          args,
+          budget,
+          (closure, closureArgs) => invokeBuiltinClosure(closure, closureArgs, budget, context, void 0),
+          context?.compilation
+        );
+      } finally {
+        budget.setRetainedValues(retainedReceiver, void 0);
+      }
+    }
   });
 }
 function getStringIndex(property) {
@@ -145463,7 +145545,9 @@ var SPLIT_STRING_MESSAGE, stringMethodNames;
 var init_string = __esm({
   "packages/safe-js/src/interp/methods/string.ts"() {
     "use strict";
+    init_builtin_call();
     init_compile_guard();
+    init_string_coercion();
     init_values();
     init_regex();
     SPLIT_STRING_MESSAGE = "String#split only supports string separator values.";
@@ -148909,7 +148993,7 @@ async function evaluateNumberMethodCall(node, target, methodName, context) {
     return {
       kind: "normal",
       hasValue: true,
-      value: callNumberMethod(target, methodName, args.value, context.budget)
+      value: await callNumberMethod(target, methodName, args.value, context.budget, createCoercionContext(context))
     };
   } catch (error3) {
     if (isFatalSandboxError(error3)) {
@@ -148921,6 +149005,10 @@ async function evaluateNumberMethodCall(node, target, methodName, context) {
 function createArrayMethodOptions(context) {
   return {
     budget: context.budget,
+    context: createCoercionContext(context),
+    hasProperty: (value, property) => hasSandboxProperty(value, property, context),
+    setProperty: (value, property, entry) => setSandboxProperty(value, property, entry, context.budget),
+    deleteProperty: deleteSandboxProperty,
     callClosure: (closure, args, stack, thisValue) => invokeSandboxClosure(closure, args, context, stack, void 0, thisValue)
   };
 }