@poe-platform/safe-js 0.1.461 → 0.1.463

package/dist/safe-js/chunks/{chunk-N63L3JON.js → chunk-KCQ7OJWN.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-RMMSTECW.js";
+} from "./chunk-NYT6Z4RI.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-N63L3JON.js.map
+//# sourceMappingURL=chunk-KCQ7OJWN.js.map

package/dist/safe-js/chunks/{chunk-RMMSTECW.js → chunk-NYT6Z4RI.js}

@@ -11854,7 +11854,7 @@ function ResolvePlural(pl, n, { getInternalSlots: getInternalSlots3, PluralRuleS
   }).pluralCategory;
 }
 function ResolvePluralRange(pluralRules, x, y, { getInternalSlots: getInternalSlots3, PluralRuleSelect: PluralRuleSelect2, PluralRuleSelectRange: PluralRuleSelectRange2 }) {
-  if (!x.isFinite() || !y.isFinite()) throw new RangeError("selectRange requires start and end values to be finite numbers");
+  if (x.isNaN() || y.isNaN()) throw new RangeError("selectRange endpoints must not be NaN");
   const internalSlots = getInternalSlots3(pluralRules);
   invariant$1(Type(internalSlots) === "Object", "pluralRules has to be an object");
   invariant$1("initializedPluralRules" in internalSlots, "pluralrules must be initialized");
@@ -18508,14 +18508,16 @@ function numberFormatterResult2(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
+// packages/safe-js/src/interp/intl-digit-options.ts
 var roundingIncrements = [1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1e3, 2e3, 2500, 5e3];
-async function readNumberFormatOptions(inputValue, locales2, budget, context) {
+async function readIntlDigitOptions(input, defaults, budget, context) {
   const options = /* @__PURE__ */ Object.create(null);
   const digits = /* @__PURE__ */ Object.create(null);
-  const release = retainValues(budget, () => [inputValue, locales2, options, digits]);
+  const minimumDefault = defaults.minimum;
+  let maximumDefault = defaults.maximum;
+  const notation = defaults.notation;
+  const release = retainValues(budget, () => [input, options, digits]);
   try {
-    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;
@@ -18531,29 +18533,6 @@ async function readNumberFormatOptions(inputValue, locales2, budget, context) {
         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 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 = numberFormatterOptions2(createNumberFormatter("en", { style: "currency", currency }));
-      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);
@@ -18585,6 +18564,50 @@ async function readNumberFormatOptions(inputValue, locales2, budget, context) {
       options.minimumFractionDigits = minimum;
       options.maximumFractionDigits = maximum;
     }
+    return options;
+  } finally {
+    release();
+  }
+}
+
+// packages/safe-js/src/interp/number-locale.ts
+async function readNumberFormatOptions(inputValue, locales2, budget, context) {
+  const options = /* @__PURE__ */ Object.create(null);
+  const release = retainValues(budget, () => [inputValue, locales2, options]);
+  try {
+    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;
+      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;
+    };
+    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 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 = numberFormatterOptions2(createNumberFormatter("en", { style: "currency", currency }));
+      minimumDefault = currencyDefaults.minimumFractionDigits;
+      maximumDefault = currencyDefaults.maximumFractionDigits;
+    }
+    Object.assign(options, await readIntlDigitOptions(input, { minimum: minimumDefault, maximum: maximumDefault, notation }, budget, context));
     createNumberFormatter(locales2, options);
     await readString("compactDisplay", ["short", "long"]);
     const grouping = await readIntlProperty(input, "useGrouping", budget, context);
@@ -28629,7 +28652,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 optionTypes5 = [
+  const optionTypes6 = [
     ["calendar", "ca", "unicodeType"],
     ["collation", "co", "unicodeType"],
     ["firstDayOfWeek", "fw", "unicodeType"],
@@ -28638,7 +28661,7 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
     ["numeric", "kn", "boolean"],
     ["numberingSystem", "nu", "unicodeType"]
   ];
-  for (const [key, extensionKey, type] of optionTypes5) {
+  for (const [key, extensionKey, type] of optionTypes6) {
     let value = await readIntlProperty(options, key, budget, context);
     if (value === void 0) continue;
     if (key === "firstDayOfWeek") {
@@ -28726,20 +28749,48 @@ function displayName(value, code) {
   return Reflect.apply(of, displayNamesState(value).native, [code]);
 }
 
-// packages/safe-js/src/interp/intl-numberformat.ts
+// packages/safe-js/src/interp/intl-pluralrules.ts
+var PortablePluralRules = numberFormatIntl.PluralRules;
+var select = PortablePluralRules.prototype.select;
+var selectRange = PortablePluralRules.prototype.selectRange;
+var resolvedOptions5 = PortablePluralRules.prototype.resolvedOptions;
 var states9 = /* @__PURE__ */ new WeakMap();
+function createSandboxPluralRules(locales2, options) {
+  const native = new PortablePluralRules(locales2, options);
+  const value = /* @__PURE__ */ Object.create(null);
+  states9.set(value, { native, options: { ...Reflect.apply(resolvedOptions5, native, []) } });
+  return value;
+}
+function isSandboxPluralRules(value) {
+  return typeof value === "object" && value !== null && states9.has(value);
+}
+function pluralRulesState(value) {
+  if (!isSandboxPluralRules(value)) throw new TypeError("Intl.PluralRules requires a PluralRules receiver.");
+  return states9.get(value);
+}
+function selectPlural2(value, inputs) {
+  inputs = inputs.map((input) => {
+    if (typeof input !== "string") return input;
+    const number = Number(input);
+    return !Number.isFinite(number) || number === 0 ? number : input.trim();
+  });
+  return Reflect.apply(inputs.length === 1 ? select : selectRange, pluralRulesState(value).native, inputs);
+}
+
+// packages/safe-js/src/interp/intl-numberformat.ts
+var states10 = /* @__PURE__ */ new WeakMap();
 function createSandboxNumberFormat(locales2, options) {
   const native = createNumberFormatter(locales2, options);
   const value = /* @__PURE__ */ Object.create(null);
-  states9.set(value, { native, options: numberFormatterOptions2(native) });
+  states10.set(value, { native, options: numberFormatterOptions2(native) });
   return value;
 }
 function isSandboxNumberFormat(value) {
-  return typeof value === "object" && value !== null && states9.has(value);
+  return typeof value === "object" && value !== null && states10.has(value);
 }
 function numberFormatState(value) {
   if (!isSandboxNumberFormat(value)) throw new TypeError("Intl.NumberFormat requires a NumberFormat receiver.");
-  return states9.get(value);
+  return states10.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;
@@ -28756,28 +28807,28 @@ function formatNumberValue(receiver, method, values) {
 
 // packages/safe-js/src/interp/intl-datetimeformat.ts
 var NativeDateTimeFormat = Intl.DateTimeFormat;
-var resolvedOptions5 = NativeDateTimeFormat.prototype.resolvedOptions;
+var resolvedOptions6 = NativeDateTimeFormat.prototype.resolvedOptions;
 var format3 = Object.getOwnPropertyDescriptor(NativeDateTimeFormat.prototype, "format").get;
 var methods = {
   formatToParts: NativeDateTimeFormat.prototype.formatToParts,
   formatRange: NativeDateTimeFormat.prototype.formatRange,
   formatRangeToParts: NativeDateTimeFormat.prototype.formatRangeToParts
 };
-var states10 = /* @__PURE__ */ new WeakMap();
+var states11 = /* @__PURE__ */ new WeakMap();
 function createSandboxDateTimeFormat(locales2, options, restoring = false) {
   const input = { ...options };
   if (restoring) delete input.hour12;
   const native = new NativeDateTimeFormat(locales2, input);
   const value = /* @__PURE__ */ Object.create(null);
-  states10.set(value, { native, options: { ...Reflect.apply(resolvedOptions5, native, []) } });
+  states11.set(value, { native, options: { ...Reflect.apply(resolvedOptions6, native, []) } });
   return value;
 }
 function isSandboxDateTimeFormat(value) {
-  return typeof value === "object" && value !== null && states10.has(value);
+  return typeof value === "object" && value !== null && states11.has(value);
 }
 function dateTimeFormatState(value) {
   if (!isSandboxDateTimeFormat(value)) throw new TypeError("Intl.DateTimeFormat requires a DateTimeFormat receiver.");
-  return states10.get(value);
+  return states11.get(value);
 }
 function formatDateTimeValue(receiver, method, values) {
   const { native } = dateTimeFormatState(receiver);
@@ -29126,6 +29177,10 @@ function captureGuestHeapNode(value, encode) {
   if (isSandboxListFormat(value)) return { kind: "guest-listformat", options: { ...listFormatState(value).options }, state: captureObjectState(value, encode) };
   if (isSandboxRelativeTimeFormat(value)) return { kind: "guest-relativetimeformat", options: { ...relativeTimeFormatState(value).options }, state: captureObjectState(value, encode) };
   if (isSandboxDisplayNames(value)) return { kind: "guest-displaynames", options: { ...displayNamesState(value).options }, state: captureObjectState(value, encode) };
+  if (isSandboxPluralRules(value)) {
+    const options = pluralRulesState(value).options;
+    return { kind: "guest-pluralrules", options: { ...options, pluralCategories: [...options.pluralCategories] }, state: captureObjectState(value, encode) };
+  }
   if (isSandboxDateTimeFormat(value)) {
     const { options, format: format4 } = dateTimeFormatState(value);
     return { kind: "guest-datetimeformat", options: { ...options }, ...format4 === void 0 ? {} : { format: encode(format4) }, state: captureObjectState(value, encode) };
@@ -34085,6 +34140,104 @@ function createDateTimeFormatConstructor(budget, now) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/intl-pluralrules.ts
+var supportedLocalesOf8 = Intl.PluralRules.supportedLocalesOf;
+var optionTypes5 = [
+  ["localeMatcher", ["lookup", "best fit"]],
+  ["type", ["cardinal", "ordinal"]]
+];
+function createPluralRulesConstructor(budget) {
+  const prototype = createIntrinsicObject();
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "PluralRules",
+    length: 0,
+    call: () => {
+      throw new TypeError("Constructor PluralRules requires 'new'.");
+    },
+    construct: 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 converted = /* @__PURE__ */ Object.create(null);
+      const release = retainValues(budget, () => [selected, locales2, converted]);
+      try {
+        locales2 = await canonicalizeGuestLocales(input, budget, context);
+        const source = intlOptionsObject(options, budget);
+        for (const [key, type] of optionTypes5) {
+          const raw = await readIntlProperty(source, key, budget, context);
+          if (raw !== void 0) converted[key] = await convertIntlOption(raw, key, type, budget, context);
+        }
+        Object.assign(converted, await readIntlDigitOptions(source, { minimum: 0, maximum: 3, notation: "standard" }, budget, context));
+        const value = createSandboxPluralRules(locales2, converted);
+        setSandboxPrototype(value, typeof selected === "object" && selected !== null ? selected : prototype, budget);
+        return allocateProducedSandboxValue(value, budget);
+      } finally {
+        release();
+      }
+    }
+  });
+  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(supportedLocalesOf8(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.PluralRules", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => {
+        const options = pluralRulesState(context?.thisValue).options;
+        return allocateProducedSandboxValue({ ...options, pluralCategories: [...options.pluralCategories] }, budget);
+      }
+    }), writable: true, configurable: true }
+  });
+  for (const method of ["select", "selectRange"]) {
+    const range = method === "selectRange";
+    Object.defineProperty(prototype, method, { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: method,
+      length: range ? 2 : 1,
+      call: async ([first, second], context) => {
+        const receiver = context?.thisValue;
+        pluralRulesState(receiver);
+        if (range && (first === void 0 || second === void 0)) throw new TypeError("PluralRules range requires both values.");
+        const inputs = [];
+        const release = retainValues(budget, () => [receiver, first, second, inputs]);
+        try {
+          inputs.push(await numberFormatValue(first, budget, context));
+          if (range) inputs.push(await numberFormatValue(second, budget, context));
+          return allocateProducedSandboxValue(selectPlural2(receiver, inputs), budget);
+        } finally {
+          release();
+        }
+      }
+    }), writable: true, configurable: true });
+  }
+  return constructor;
+}
+
 // packages/safe-js/src/interp/globals/intl.ts
 var supportedValuesOf = Intl.supportedValuesOf;
 function createIntlGlobal(budget, now) {
@@ -34104,6 +34257,7 @@ function createIntlGlobal(budget, now) {
   const relativeTimeFormat = createRelativeTimeFormatConstructor(budget);
   const displayNames = createDisplayNamesConstructor(budget);
   const dateTimeFormat = createDateTimeFormatConstructor(budget, now);
+  const pluralRules = createPluralRulesConstructor(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 });
@@ -34111,13 +34265,14 @@ function createIntlGlobal(budget, now) {
   Object.defineProperty(intl, "RelativeTimeFormat", { value: relativeTimeFormat, writable: true, configurable: true });
   Object.defineProperty(intl, "DisplayNames", { value: displayNames, writable: true, configurable: true });
   Object.defineProperty(intl, "DateTimeFormat", { value: dateTimeFormat, writable: true, configurable: true });
+  Object.defineProperty(intl, "PluralRules", { value: pluralRules, writable: true, configurable: true });
   for (const [name, call] of Object.entries(methods3)) {
     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, numberFormat, listFormat, relativeTimeFormat, displayNames, dateTimeFormat]) {
+  for (const constructor of [locale, collator, numberFormat, listFormat, relativeTimeFormat, displayNames, dateTimeFormat, pluralRules]) {
     const prototype = constructor.properties.prototype;
     for (const owner of [prototype, constructor.properties])
       for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(owner)))
@@ -34235,7 +34390,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-listformat", "guest-displaynames", "guest-relativetimeformat", "guest-datetimeformat", "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;
+  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-listformat", "guest-pluralrules", "guest-displaynames", "guest-relativetimeformat", "guest-datetimeformat", "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"]);
@@ -34543,6 +34698,22 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     const restored = listFormatState(createSandboxListFormat(options.locale, options)).options;
     if (names.some((key) => options[key] !== restored[key])) throw new TypeError("Invalid resolved ListFormat options.");
     state(node.state);
+  } else if (node.kind === "guest-pluralrules") {
+    fields(node, ["kind", "options", "state"]);
+    const options = record2(node.options);
+    fields(
+      options,
+      ["locale", "type", "minimumIntegerDigits", "pluralCategories", "roundingIncrement", "roundingMode", "roundingPriority", "trailingZeroDisplay"],
+      ["minimumFractionDigits", "maximumFractionDigits", "minimumSignificantDigits", "maximumSignificantDigits"]
+    );
+    if (typeof options.locale !== "string" || !Array.isArray(options.pluralCategories) || options.pluralCategories.some((value) => typeof value !== "string") || Object.entries(options).some(([key, value]) => key !== "pluralCategories" && typeof value !== "string" && typeof value !== "number"))
+      throw new TypeError("Invalid PluralRules option type.");
+    const restored = pluralRulesState(createSandboxPluralRules(options.locale, options)).options;
+    if (Object.keys(options).length !== Object.keys(restored).length || Object.keys(restored).some((key) => {
+      const value = restored[key];
+      return Array.isArray(value) ? options[key].length !== value.length || value.some((item, index) => options[key][index] !== item) : options[key] !== value;
+    })) throw new TypeError("Invalid resolved PluralRules options.");
+    state(node.state);
   } else if (node.kind === "guest-displaynames") {
     fields(node, ["kind", "options", "state"]);
     const options = record2(node.options);
@@ -38319,6 +38490,7 @@ function measureSandboxData(values, options = {}) {
     if (isSandboxListFormat(value)) visit(listFormatState(value).options, depth + 1);
     if (isSandboxRelativeTimeFormat(value)) visit(relativeTimeFormatState(value).options, depth + 1);
     if (isSandboxDisplayNames(value)) visit(displayNamesState(value).options, depth + 1);
+    if (isSandboxPluralRules(value)) visit(pluralRulesState(value).options, depth + 1);
     if (isSandboxNumberFormat(value)) {
       const state = numberFormatState(value);
       visit(state.options, depth + 1);
@@ -56309,4 +56481,4 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 */
-//# sourceMappingURL=chunk-RMMSTECW.js.map
+//# sourceMappingURL=chunk-NYT6Z4RI.js.map