@poe-platform/safe-js 0.1.448 → 0.1.450

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

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-D32JKK5K.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-HPTZH7MW.js.map
+//# sourceMappingURL=chunk-6BQOHEVM.js.map

package/dist/safe-js/chunks/{chunk-D32JKK5K.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();
@@ -12376,8 +12399,12 @@ function formatNumber(value, methodName, argument, budget) {
 // packages/safe-js/src/interp/methods/string.ts
 import { types as types7 } from "node:util";
 
-// packages/safe-js/src/interp/methods/string-locale.ts
-var collatorOptions = [
+// packages/safe-js/src/interp/intl-collator.ts
+var NativeCollator = Intl.Collator;
+var nativeResolvedOptions = NativeCollator.prototype.resolvedOptions;
+var nativeCompare = Object.getOwnPropertyDescriptor(NativeCollator.prototype, "compare").get;
+var states5 = /* @__PURE__ */ new WeakMap();
+var optionTypes = [
   ["usage", ["sort", "search"]],
   ["localeMatcher", ["lookup", "best fit"]],
   ["collation", "unicodeType"],
@@ -12386,6 +12413,50 @@ var collatorOptions = [
   ["sensitivity", ["base", "accent", "case", "variant"]],
   ["ignorePunctuation", "boolean"]
 ];
+async function readCollatorOptions(input, budget, context, invalid) {
+  const source = intlOptionsObject(input, budget);
+  const options = /* @__PURE__ */ Object.create(null);
+  const release = retainValues(budget, () => [source, options]);
+  try {
+    for (const [key, type] of optionTypes) {
+      const value = await readIntlProperty(source, key, budget, context);
+      if (value !== void 0) options[key] = await convertIntlOption(
+        value,
+        key,
+        type,
+        budget,
+        context,
+        (text) => {
+          invalid?.(key, text);
+          new NativeCollator([], { [key]: text });
+        }
+      );
+    }
+    return options;
+  } finally {
+    release();
+  }
+}
+function createSandboxCollator(locales2, options) {
+  const native = new NativeCollator(locales2, options);
+  const value = /* @__PURE__ */ Object.create(null);
+  states5.set(value, { native, options: Reflect.apply(nativeResolvedOptions, native, []) });
+  return value;
+}
+function isSandboxCollator(value) {
+  return typeof value === "object" && value !== null && states5.has(value);
+}
+function collatorState(value) {
+  if (!isSandboxCollator(value)) throw new TypeError("Intl.Collator requires a Collator receiver.");
+  return states5.get(value);
+}
+function compareCollatorStrings(value, first, second) {
+  const state = collatorState(value);
+  const compare = Reflect.apply(nativeCompare, state.native, []);
+  return Reflect.apply(compare, void 0, [first, second]);
+}
+
+// packages/safe-js/src/interp/methods/string-locale.ts
 async function changeStringLocaleCase(value, method, args, budget, context) {
   let locales2 = [];
   const release = retainValues(budget, () => [value, locales2]);
@@ -12400,19 +12471,15 @@ async function changeStringLocaleCase(value, method, args, budget, context) {
 async function compareStringLocale(value, args, budget, context) {
   let comparison = "";
   let locales2 = [];
-  const options = /* @__PURE__ */ Object.create(null);
+  let options = /* @__PURE__ */ Object.create(null);
   const release = retainValues(budget, () => [value, comparison, locales2, options]);
   try {
     comparison = await sandboxString(args[0], budget, context);
     locales2 = await canonicalizeGuestLocales(args[1], budget, context);
     if (args[2] === null) return Reflect.apply(String.prototype.localeCompare, value, [comparison, locales2, null]);
-    const inputOptions = intlOptionsObject(args[2], budget);
-    for (const [key, type] of collatorOptions) {
-      const option = await readIntlProperty(inputOptions, key, budget, context);
-      if (option !== void 0) options[key] = await convertIntlOption(option, key, type, budget, context, (text) => {
-        Reflect.apply(String.prototype.localeCompare, "", ["", [], { [key]: text }]);
-      });
-    }
+    options = await readCollatorOptions(args[2], budget, context, (key, text) => {
+      Reflect.apply(String.prototype.localeCompare, "", ["", [], { [key]: text }]);
+    });
     budget.visitNode(value.length + comparison.length);
     return Reflect.apply(String.prototype.localeCompare, value, [comparison, locales2, options]);
   } finally {
@@ -21172,7 +21239,7 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
   }
   const updated = Object.values(base).filter((value) => value !== void 0).join("-") + canonical.slice(native.baseName.length);
   const extension = unicodeKeywords(updated);
-  const optionTypes = [
+  const optionTypes2 = [
     ["calendar", "ca", "unicodeType"],
     ["collation", "co", "unicodeType"],
     ["firstDayOfWeek", "fw", "unicodeType"],
@@ -21181,7 +21248,7 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
     ["numeric", "kn", "boolean"],
     ["numberingSystem", "nu", "unicodeType"]
   ];
-  for (const [key, extensionKey, type] of optionTypes) {
+  for (const [key, extensionKey, type] of optionTypes2) {
     let value = await readIntlProperty(options, key, budget, context);
     if (value === void 0) continue;
     if (key === "firstDayOfWeek") {
@@ -21201,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();
 
@@ -21540,6 +21635,14 @@ 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) };
+  }
   if (hasGuestObjectState(value) || privateElements.has(value)) {
     if (isSandboxRegex(value)) return { kind: "guest-regex", source: value.source, flags: value.flags, state: captureObjectState(value, encode) };
     if (isSandboxBox(value)) return { kind: "guest-boxed", value: encode(boxedValue(value)), state: captureObjectState(value, encode) };
@@ -25742,6 +25845,229 @@ function createLocaleConstructor(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/intl-collator.ts
+var supportedLocalesOf = Intl.Collator.supportedLocalesOf;
+function createCollatorConstructor(budget) {
+  const prototype = createIntrinsicObject();
+  const compareTarget = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "",
+    length: 2,
+    call: async ([first, second], context) => {
+      let left = "";
+      const release = retainValues(budget, () => [context?.thisValue, left]);
+      try {
+        left = await sandboxString(first, budget, context);
+        const right = await sandboxString(second, budget, context);
+        budget.visitNode(left.length + right.length);
+        return compareCollatorStrings(context?.thisValue, left, right);
+      } finally {
+        release();
+      }
+    }
+  });
+  registerBuiltinIdentities(budget, { "%CollatorCompare%": compareTarget });
+  registerIntrinsicFunction(budget, compareTarget);
+  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 readCollatorOptions(options, budget, context);
+      const value = createSandboxCollator(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: "Collator",
+    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 option = await readIntlProperty(source, "localeMatcher", budget, context);
+        const matcher = option === void 0 ? void 0 : await convertIntlOption(option, "localeMatcher", ["lookup", "best fit"], budget, context);
+        return allocateProducedSandboxValue(supportedLocalesOf(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.Collator", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => allocateProducedSandboxValue({ ...collatorState(context?.thisValue).options }, budget)
+    }), writable: true, configurable: true },
+    compare: { get: accessorAdapter(createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "get compare",
+      length: 0,
+      call: (_args, context) => {
+        const receiver = context?.thisValue;
+        const state = collatorState(receiver);
+        if (state.compare === void 0) {
+          state.compare = createBoundFunction(
+            { target: compareTarget, thisValue: receiver, args: [] },
+            "",
+            2,
+            (target, args, stack, thisValue) => invokeBuiltinClosure(target, args, budget, { stack, thisValue }, thisValue)
+          );
+          allocateProducedSandboxValue(state.compare, budget);
+        }
+        return state.compare;
+      }
+    }), "get"), configurable: true }
+  });
+  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) {
@@ -25755,18 +26081,25 @@ 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 });
-  const prototype = locale.properties.prototype;
-  for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(prototype)))
-    for (const closure of [descriptor.value, ...retainedAccessorClosures(descriptor)])
-      if (isSandboxClosure(closure)) registerIntrinsicFunction(budget, closure);
-  registerIntrinsicObject(budget, prototype);
+  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)))
+        for (const closure of [descriptor.value, ...retainedAccessorClosures(descriptor)])
+          if (isSandboxClosure(closure)) registerIntrinsicFunction(budget, closure);
+    registerIntrinsicObject(budget, prototype);
+  }
   for (const name of Object.keys(methods2)) registerIntrinsicFunction(budget, intl[name]);
   registerIntrinsicObject(budget, intl);
   return intl;
@@ -25876,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-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"]);
@@ -26145,6 +26478,38 @@ 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);
+    const names = ["locale", "usage", "sensitivity", "ignorePunctuation", "collation", "numeric", "caseFirst"];
+    fields(options, names);
+    for (const key of names)
+      if (typeof options[key] !== (key === "numeric" || key === "ignorePunctuation" ? "boolean" : "string"))
+        throw new TypeError("Invalid Collator option type.");
+    const restored = collatorState(createSandboxCollator(options.locale, options)).options;
+    for (const key of names)
+      if (options[key] !== restored[key]) throw new TypeError("Invalid resolved Collator options.");
+    if (node.compare !== void 0) {
+      const compare = reference(node.compare, ["bound-function"]);
+      if (reference(compare.thisValue) !== node || array(compare.args).length !== 0 || compare.name !== "" || compare.length !== 2 || reference(compare.target, ["intrinsic"]).id !== '["%CollatorCompare%"]')
+        throw new TypeError("Invalid cached Collator comparison.");
+    }
+    state(node.state);
   } else if (node.kind === "guest-locale") {
     fields(node, ["kind", "tag", "state"]);
     if (typeof node.tag !== "string" || localeTag(createSandboxLocale(node.tag)) !== node.tag)
@@ -29883,6 +30248,16 @@ 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);
+      visit(state.compare, depth + 1);
+    }
     if (isGuestHostObject(value)) {
       usage += measureHostObjectData(value);
       return;
@@ -47846,4 +48221,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-D32JKK5K.js.map
+//# sourceMappingURL=chunk-D5ZEIZYV.js.map