@poe-platform/safe-js 0.1.449 → 0.1.450

package/dist/safe-js/chunks/{chunk-FOE6VBOD.js → chunk-6BQOHEVM.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-264RHYEA.js";
+} from "./chunk-D5ZEIZYV.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-FOE6VBOD.js.map
+//# sourceMappingURL=chunk-6BQOHEVM.js.map

package/dist/safe-js/chunks/{chunk-264RHYEA.js → chunk-D5ZEIZYV.js}

@@ -11184,18 +11184,28 @@ function decodeBase64(text, alphabet, mode, budget, maxLength = Number.MAX_SAFE_
   }
 }
 
-// packages/safe-js/src/interp/number-locale.ts
+// packages/safe-js/src/interp/numberformat-backend.ts
 var NativeNumberFormat = Intl.NumberFormat;
+var modernNative = new NativeNumberFormat("en", { maximumFractionDigits: 0, ...{ roundingMode: "floor" } }).format(1.9) === "1" && typeof Object.getOwnPropertyDescriptor(NativeNumberFormat.prototype, "formatRange")?.value === "function";
+var portable = modernNative ? void 0 : await import("./numberformat-portable-TXZMY2EF.js");
+function createNumberFormatter(locales2, options) {
+  return portable === void 0 ? new NativeNumberFormat(locales2, options) : portable.createPortableNumberFormatter(locales2, options);
+}
+function numberFormatterOptions(formatter) {
+  return portable === void 0 ? { ...formatter.resolvedOptions() } : portable.numberFormatterOptions(formatter);
+}
+function numberFormatterResult(formatter, method, values) {
+  return portable === void 0 ? Reflect.apply(Reflect.get(formatter, method), formatter, values) : portable.numberFormatterResult(formatter, method, values);
+}
+
+// packages/safe-js/src/interp/number-locale.ts
 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 locales2 = [];
+async function readNumberFormatOptions(inputValue, locales2, budget, context) {
   const options = /* @__PURE__ */ Object.create(null);
   const digits = /* @__PURE__ */ Object.create(null);
-  const release = retainValues(budget, () => [value, locales2, options, digits]);
-  const allocation = {};
+  const release = retainValues(budget, () => [inputValue, locales2, options, digits]);
   try {
-    locales2 = await canonicalizeGuestLocales(args[0], budget, context);
-    const input = intlOptionsObject(args[1], budget);
+    const input = intlOptionsObject(inputValue, budget);
     const readString = async (key, type) => {
       const raw = await readIntlProperty(input, key, budget, context);
       if (raw === void 0) return void 0;
@@ -11224,13 +11234,13 @@ async function formatNumberLocale(value, args, budget, context) {
     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 });
+    } else createNumberFormatter("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();
+      const currencyDefaults = numberFormatterOptions(createNumberFormatter("en", { style: "currency", currency }));
       minimumDefault = currencyDefaults.minimumFractionDigits;
       maximumDefault = currencyDefaults.maximumFractionDigits;
     }
@@ -11265,16 +11275,29 @@ async function formatNumberLocale(value, args, budget, context) {
       options.minimumFractionDigits = minimum;
       options.maximumFractionDigits = maximum;
     }
-    new NativeNumberFormat(locales2, options);
+    createNumberFormatter(locales2, 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"]);
+    return options;
+  } finally {
+    release();
+  }
+}
+async function formatNumberLocale(value, args, budget, context) {
+  let locales2 = [];
+  let options = /* @__PURE__ */ Object.create(null);
+  const release = retainValues(budget, () => [value, locales2, options]);
+  const allocation = {};
+  try {
+    locales2 = await canonicalizeGuestLocales(args[0], budget, context);
+    options = await readNumberFormatOptions(args[1], locales2, budget, context);
     const size = typeof value === "bigint" ? value.toString(16).length * 4 : 64;
     budget.visitNode(size);
     budget.setRetainedDataUsage(allocation, size);
-    const formatter = new NativeNumberFormat(locales2, options);
-    return budget.allocateString(formatter.format(value));
+    const formatter = createNumberFormatter(locales2, options);
+    return budget.allocateString(numberFormatterResult(formatter, "format", [value]));
   } finally {
     budget.setRetainedDataUsage(allocation, 0);
     release();
@@ -21245,6 +21268,34 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
   return budget.allocateString(Reflect.apply(nativeToString, result, []));
 }
 
+// packages/safe-js/src/interp/intl-numberformat.ts
+var states6 = /* @__PURE__ */ new WeakMap();
+function createSandboxNumberFormat(locales2, options) {
+  const native = createNumberFormatter(locales2, options);
+  const value = /* @__PURE__ */ Object.create(null);
+  states6.set(value, { native, options: numberFormatterOptions(native) });
+  return value;
+}
+function isSandboxNumberFormat(value) {
+  return typeof value === "object" && value !== null && states6.has(value);
+}
+function numberFormatState(value) {
+  if (!isSandboxNumberFormat(value)) throw new TypeError("Intl.NumberFormat requires a NumberFormat receiver.");
+  return states6.get(value);
+}
+async function numberFormatValue(value, budget, context) {
+  const primitive = typeof value === "object" && value !== null ? await objectToPrimitive(value, budget, context, /* @__PURE__ */ new Set(), "number") : value;
+  if (typeof primitive === "string" || typeof primitive === "bigint") {
+    budget.visitNode(typeof primitive === "string" ? primitive.length : primitive.toString(16).length * 4);
+    return primitive;
+  }
+  return Number(primitive);
+}
+function formatNumberValue(receiver, method, values) {
+  const { native } = numberFormatState(receiver);
+  return numberFormatterResult(native, method, values);
+}
+
 // packages/safe-js/src/interp/iterator-helper.ts
 var iteratorHelperStates = /* @__PURE__ */ new WeakMap();
 
@@ -21584,6 +21635,10 @@ function captureGuestHeapNode(value, encode) {
     return void 0;
   }
   if (isSandboxLocale(value)) return { kind: "guest-locale", tag: localeTag(value), state: captureObjectState(value, encode) };
+  if (isSandboxNumberFormat(value)) {
+    const { options, format } = numberFormatState(value);
+    return { kind: "guest-numberformat", options: { ...options }, ...format === void 0 ? {} : { format: encode(format) }, state: captureObjectState(value, encode) };
+  }
   if (isSandboxCollator(value)) {
     const { options, compare } = collatorState(value);
     return { kind: "guest-collator", options: { ...options }, ...compare === void 0 ? {} : { compare: encode(compare) }, state: captureObjectState(value, encode) };
@@ -25891,6 +25946,128 @@ function createCollatorConstructor(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/intl-numberformat.ts
+var supportedLocalesOf2 = Intl.NumberFormat.supportedLocalesOf;
+function createNumberFormatConstructor(budget) {
+  const prototype = createIntrinsicObject();
+  const formatTarget = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "",
+    length: 1,
+    call: async ([input], context) => {
+      numberFormatState(context?.thisValue);
+      let value = 0;
+      const release = retainValues(budget, () => [context?.thisValue, value]);
+      try {
+        value = await numberFormatValue(input, budget, context);
+        return allocateProducedSandboxValue(formatNumberValue(context?.thisValue, "format", [value]), budget);
+      } finally {
+        release();
+      }
+    }
+  });
+  registerBuiltinIdentities(budget, { "%NumberFormatFormat%": formatTarget });
+  registerIntrinsicFunction(budget, formatTarget);
+  const initialize = async ([input, options], context) => {
+    const target = context?.newTarget;
+    const selected = target === void 0 || target === constructor ? prototype : context?.getProperty !== void 0 ? await context.getProperty(target, "prototype") : await readPropertyDescriptor(getSandboxPropertyDescriptor(target, "prototype", budget) ?? { value: void 0 }, target, context);
+    let locales2 = [];
+    const release = retainValues(budget, () => [selected, locales2]);
+    try {
+      locales2 = await canonicalizeGuestLocales(input, budget, context);
+      const converted = await readNumberFormatOptions(options, locales2, budget, context);
+      const value = createSandboxNumberFormat(locales2, converted);
+      setSandboxPrototype(value, typeof selected === "object" && selected !== null ? selected : prototype, budget);
+      return allocateProducedSandboxValue(value, budget);
+    } finally {
+      release();
+    }
+  };
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "NumberFormat",
+    length: 0,
+    construct: initialize,
+    call: (args, context) => initialize(args, { ...context, stack: context?.stack ?? [], thisValue: context?.thisValue, newTarget: void 0 })
+  });
+  const properties = materializeFunctionProperties(constructor);
+  Object.defineProperty(properties, "prototype", { value: prototype, writable: false, configurable: false });
+  Object.defineProperty(properties, "supportedLocalesOf", { value: createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "supportedLocalesOf",
+    length: 1,
+    call: async ([input, options], context) => {
+      const locales2 = await canonicalizeGuestLocales(input, budget, context);
+      const release = retainValues(budget, () => [locales2]);
+      try {
+        const source = intlOptionsObject(options, budget);
+        const raw = await readIntlProperty(source, "localeMatcher", budget, context);
+        const matcher = raw === void 0 ? void 0 : await convertIntlOption(raw, "localeMatcher", ["lookup", "best fit"], budget, context);
+        return allocateProducedSandboxValue(supportedLocalesOf2(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.NumberFormat", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => allocateProducedSandboxValue({ ...numberFormatState(context?.thisValue).options }, budget)
+    }), writable: true, configurable: true },
+    format: { get: accessorAdapter(createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "get format",
+      length: 0,
+      call: (_args, context) => {
+        const receiver = context?.thisValue;
+        const state = numberFormatState(receiver);
+        if (state.format === void 0) {
+          state.format = createBoundFunction(
+            { target: formatTarget, thisValue: receiver, args: [] },
+            "",
+            1,
+            (target, args, stack, thisValue) => invokeBuiltinClosure(target, args, budget, { stack, thisValue }, thisValue)
+          );
+          allocateProducedSandboxValue(state.format, budget);
+        }
+        return state.format;
+      }
+    }), "get"), configurable: true }
+  });
+  for (const method of ["formatToParts", "formatRange", "formatRangeToParts"]) {
+    const range = method !== "formatToParts";
+    Object.defineProperty(prototype, method, { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: method,
+      length: range ? 2 : 1,
+      call: async ([first, second], context) => {
+        numberFormatState(context?.thisValue);
+        if (range && (first === void 0 || second === void 0)) throw new TypeError("NumberFormat range requires both values.");
+        const values = [];
+        const release = retainValues(budget, () => [context?.thisValue, values]);
+        try {
+          values.push(await numberFormatValue(first, budget, context));
+          if (range) values.push(await numberFormatValue(second, budget, context));
+          return allocateProducedSandboxValue(formatNumberValue(context?.thisValue, method, values), budget);
+        } finally {
+          release();
+        }
+      }
+    }), writable: true, configurable: true });
+  }
+  return constructor;
+}
+
 // packages/safe-js/src/interp/globals/intl.ts
 var supportedValuesOf = Intl.supportedValuesOf;
 function createIntlGlobal(budget) {
@@ -25905,15 +26082,17 @@ function createIntlGlobal(budget) {
   const intl = createIntrinsicObject();
   const locale = createLocaleConstructor(budget);
   const collator = createCollatorConstructor(budget);
+  const numberFormat = createNumberFormatConstructor(budget);
   Object.defineProperty(intl, "Locale", { value: locale, writable: true, configurable: true });
   Object.defineProperty(intl, "Collator", { value: collator, writable: true, configurable: true });
+  Object.defineProperty(intl, "NumberFormat", { value: numberFormat, writable: true, configurable: true });
   for (const [name, call] of Object.entries(methods2)) {
     const closure = createSandboxClosure({ guest: true, sandbox: true, name, length: 1, call });
     Object.defineProperty(intl, name, { value: closure, writable: true, configurable: true });
   }
   Object.defineProperty(intl, Symbol.toStringTag, { value: "Intl", configurable: true });
   registerBuiltinIdentities(budget, { Intl: intl });
-  for (const constructor of [locale, collator]) {
+  for (const constructor of [locale, collator, numberFormat]) {
     const prototype = constructor.properties.prototype;
     for (const owner of [prototype, constructor.properties])
       for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(owner)))
@@ -26030,7 +26209,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["module-function", "async-generator-driver", "async-generator-handler", "async-function-driver", "async-function-handler", "thenable-state", "thenable-resolver", "construction-environment", "capability-executor", "promise-aggregate", "aggregate-entry", "aggregate-handler", "intrinsic", "bound-function", "promise-resolver", "pending-promise", "promise-reaction", "promise-adoption", "adoption-resolver", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-locale", "guest-collator", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "async-disposable-stack", "async-cleanup", "async-cleanup-handler", "disposable-stack", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
+  if (!["module-function", "async-generator-driver", "async-generator-handler", "async-function-driver", "async-function-handler", "thenable-state", "thenable-resolver", "construction-environment", "capability-executor", "promise-aggregate", "aggregate-entry", "aggregate-handler", "intrinsic", "bound-function", "promise-resolver", "pending-promise", "promise-reaction", "promise-adoption", "adoption-resolver", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-locale", "guest-numberformat", "guest-collator", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "async-disposable-stack", "async-cleanup", "async-cleanup-handler", "disposable-stack", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
     const ref = record2(value);
     fields(ref, ["kind", "id"]);
@@ -26299,6 +26478,21 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     fields(node, ["kind", "source", "flags", "state"]);
     if (typeof node.source !== "string" || typeof node.flags !== "string") throw new TypeError("Invalid guest RegExp payload.");
     state(node.state);
+  } else if (node.kind === "guest-numberformat") {
+    fields(node, ["kind", "options", "state"], ["format"]);
+    const options = record2(node.options);
+    fields(options, ["locale"], ["numberingSystem", "style", "currency", "currencyDisplay", "currencySign", "unit", "unitDisplay", "minimumIntegerDigits", "minimumFractionDigits", "maximumFractionDigits", "minimumSignificantDigits", "maximumSignificantDigits", "useGrouping", "notation", "compactDisplay", "signDisplay", "roundingIncrement", "roundingMode", "roundingPriority", "trailingZeroDisplay"]);
+    if (typeof options.locale !== "string" || Object.values(options).some((value) => !["string", "number", "boolean"].includes(typeof value)))
+      throw new TypeError("Invalid NumberFormat option type.");
+    const restored = numberFormatState(createSandboxNumberFormat(options.locale, options)).options;
+    if (Object.keys(options).length !== Object.keys(restored).length || Object.keys(restored).some((key) => options[key] !== restored[key]))
+      throw new TypeError("Invalid resolved NumberFormat options.");
+    if (node.format !== void 0) {
+      const format = reference(node.format, ["bound-function"]);
+      if (reference(format.thisValue) !== node || array(format.args).length !== 0 || format.name !== "" || format.length !== 1 || reference(format.target, ["intrinsic"]).id !== '["%NumberFormatFormat%"]')
+        throw new TypeError("Invalid cached NumberFormat function.");
+    }
+    state(node.state);
   } else if (node.kind === "guest-collator") {
     fields(node, ["kind", "options", "state"], ["compare"]);
     const options = record2(node.options);
@@ -30054,6 +30248,11 @@ function measureSandboxData(values, options = {}) {
     }
     if (isSandboxDate(value)) usage += 8;
     if (isSandboxLocale(value)) usage += localeTag(value).length;
+    if (isSandboxNumberFormat(value)) {
+      const state = numberFormatState(value);
+      visit(state.options, depth + 1);
+      visit(state.format, depth + 1);
+    }
     if (isSandboxCollator(value)) {
       const state = collatorState(value);
       visit(state.options, depth + 1);
@@ -48022,4 +48221,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-264RHYEA.js.map
+//# sourceMappingURL=chunk-D5ZEIZYV.js.map