@poe-platform/safe-js 0.1.291 → 0.1.292

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

@@ -10446,62 +10446,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 +10501,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"]],
@@ -23642,6 +23742,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 +40630,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-ZOLHW4OV.js.map
+//# sourceMappingURL=chunk-4MMZLA7N.js.map