@poe-platform/safe-js 0.1.115 → 0.1.117

package/dist/safe-js/chunks/{chunk-G2KH7I4M.js → chunk-L7PHF62H.js}

@@ -24826,63 +24826,42 @@ 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.");
-  }
-  return radix;
-}
-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.`);
+  const argument = args[0];
+  if (argument !== null && typeof argument === "object") {
+    return formatObjectArgument(value, methodName, argument, budget, context);
   }
-  return digits;
+  return formatNumber(value, methodName, argument === void 0 ? void 0 : Number(argument), budget);
 }
-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 formatNumber(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 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 Math.trunc(number);
+  return budget.allocateString(result);
 }
 
 // packages/safe-js/src/interp/methods/generator.ts
@@ -24956,14 +24935,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) {
@@ -28707,7 +28699,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 (error) {
     if (isFatalSandboxError(error)) {
@@ -33304,4 +33296,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-G2KH7I4M.js.map
+//# sourceMappingURL=chunk-L7PHF62H.js.map