@poe-platform/safe-js 0.1.462 → 0.1.464

package/dist/safe-js/chunks/{chunk-2PVMLKJL.js → chunk-N45AVH5W.js}

@@ -6288,11 +6288,11 @@ function assertBareImportSpecifier(specifier) {
   }
 }
 function hasInvalidImportPathDots(value) {
-  const segments = value.split(".");
-  if (segments.some((segment) => segment.length === 0)) {
+  const segments2 = value.split(".");
+  if (segments2.some((segment) => segment.length === 0)) {
     return true;
   }
-  return segments.length > 1 && ["js", "mjs", "cjs", "ts", "mts", "cts", "json"].includes(segments.at(-1) ?? "");
+  return segments2.length > 1 && ["js", "mjs", "cjs", "ts", "mts", "cts", "json"].includes(segments2.at(-1) ?? "");
 }
 function hasProtocolPrefix(value) {
   const colonIndex = value.indexOf(":");
@@ -9036,6 +9036,48 @@ function nextStringIterator(value, budget) {
   return { value: entry, done: false };
 }
 
+// packages/safe-js/src/interp/intl-segmenter.ts
+var NativeSegmenter = Intl.Segmenter;
+var nativeSegment = NativeSegmenter.prototype.segment;
+var nativeResolvedOptions = NativeSegmenter.prototype.resolvedOptions;
+var nativeContaining = Object.getPrototypeOf(new NativeSegmenter("en").segment("")).containing;
+var segmenters = /* @__PURE__ */ new WeakMap();
+var segments = /* @__PURE__ */ new WeakMap();
+function createSandboxSegmenter(locales2, options) {
+  const native = new NativeSegmenter(locales2, options);
+  const value = /* @__PURE__ */ Object.create(null);
+  segmenters.set(value, { native, options: Reflect.apply(nativeResolvedOptions, native, []) });
+  return value;
+}
+function isSandboxSegmenter(value) {
+  return typeof value === "object" && value !== null && segmenters.has(value);
+}
+function segmenterState(value) {
+  if (!isSandboxSegmenter(value)) throw new TypeError("Intl.Segmenter requires a Segmenter receiver.");
+  return segmenters.get(value);
+}
+function createSandboxSegments(state) {
+  const native = Reflect.apply(nativeSegment, segmenterState(state.segmenter).native, [state.input]);
+  const value = /* @__PURE__ */ Object.create(null);
+  segments.set(value, { ...state, native });
+  return value;
+}
+function isSandboxSegments(value) {
+  return typeof value === "object" && value !== null && segments.has(value);
+}
+function segmentState(value, iterator) {
+  if (!isSandboxSegments(value) || iterator !== void 0 && segments.get(value).index !== void 0 !== iterator)
+    throw new TypeError(iterator ? "Segment iterator requires a segment iterator receiver." : "Segments method requires a Segments receiver.");
+  return segments.get(value);
+}
+function containingSegment(value, index, iterator, budget) {
+  const state = segmentState(value, iterator);
+  budget.visitNode(state.input.length + 1);
+  const result = Reflect.apply(nativeContaining, state.native, [index]);
+  if (iterator && result !== void 0) state.index = result.index + result.segment.length;
+  return result === void 0 ? void 0 : { ...result };
+}
+
 // packages/safe-js/src/interp/iterator-wrapper.ts
 var iteratorWrapperStates = /* @__PURE__ */ new WeakMap();
 
@@ -18508,14 +18550,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 +18575,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 +18606,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);
@@ -19785,7 +19850,7 @@ import { types as types7 } from "node:util";
 
 // packages/safe-js/src/interp/intl-collator.ts
 var NativeCollator = Intl.Collator;
-var nativeResolvedOptions = NativeCollator.prototype.resolvedOptions;
+var nativeResolvedOptions2 = NativeCollator.prototype.resolvedOptions;
 var nativeCompare = Object.getOwnPropertyDescriptor(NativeCollator.prototype, "compare").get;
 var states5 = /* @__PURE__ */ new WeakMap();
 var optionTypes = [
@@ -19824,7 +19889,7 @@ async function readCollatorOptions(input, budget, context, invalid) {
 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, []) });
+  states5.set(value, { native, options: Reflect.apply(nativeResolvedOptions2, native, []) });
   return value;
 }
 function isSandboxCollator(value) {
@@ -28629,7 +28694,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 optionTypes7 = [
     ["calendar", "ca", "unicodeType"],
     ["collation", "co", "unicodeType"],
     ["firstDayOfWeek", "fw", "unicodeType"],
@@ -28638,7 +28703,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 optionTypes7) {
     let value = await readIntlProperty(options, key, budget, context);
     if (value === void 0) continue;
     if (key === "firstDayOfWeek") {
@@ -28726,20 +28791,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 +28849,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);
@@ -29124,8 +29217,23 @@ function captureGuestHeapNode(value, encode) {
   }
   if (isSandboxLocale(value)) return { kind: "guest-locale", tag: localeTag(value), state: captureObjectState(value, encode) };
   if (isSandboxListFormat(value)) return { kind: "guest-listformat", options: { ...listFormatState(value).options }, state: captureObjectState(value, encode) };
+  if (isSandboxSegmenter(value)) return { kind: "guest-segmenter", options: { ...segmenterState(value).options }, state: captureObjectState(value, encode) };
+  if (isSandboxSegments(value)) {
+    const state2 = segmentState(value);
+    return {
+      kind: "guest-segments",
+      segmenter: encode(state2.segmenter),
+      input: state2.input,
+      ...state2.index === void 0 ? {} : { index: state2.index },
+      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 +34193,252 @@ 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-segmenter.ts
+var supportedLocalesOf9 = Intl.Segmenter.supportedLocalesOf;
+var optionTypes6 = [
+  ["localeMatcher", ["lookup", "best fit"]],
+  ["granularity", ["grapheme", "word", "sentence"]]
+];
+function createSegmenterConstructor(budget) {
+  const prototype = createIntrinsicObject();
+  const segmentsPrototype = createIntrinsicObject();
+  const iteratorPrototype = createIntrinsicObject();
+  setSandboxPrototype(iteratorPrototype, resolveIntrinsicIdentity(budget, '["%IteratorPrototype%"]'));
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "Segmenter",
+    length: 0,
+    call: () => {
+      throw new TypeError("Constructor Segmenter 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 optionTypes6) {
+          const raw = await readIntlProperty(source, key, budget, context);
+          if (raw !== void 0) converted[key] = await convertIntlOption(raw, key, type, budget, context);
+        }
+        const value = createSandboxSegmenter(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(supportedLocalesOf9(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.Segmenter", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => allocateProducedSandboxValue({ ...segmenterState(context?.thisValue).options }, budget)
+    }), writable: true, configurable: true },
+    segment: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "segment",
+      length: 1,
+      call: async ([input], context) => {
+        const receiver = context?.thisValue;
+        segmenterState(receiver);
+        const release = retainValues(budget, () => [receiver, input]);
+        try {
+          const text = await sandboxString(input, budget, context);
+          budget.visitNode(text.length);
+          const value = createSandboxSegments({ segmenter: receiver, input: text });
+          setSandboxPrototype(value, segmentsPrototype, budget);
+          return allocateProducedSandboxValue(value, budget);
+        } finally {
+          release();
+        }
+      }
+    }), writable: true, configurable: true }
+  });
+  const containing = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "containing",
+    length: 1,
+    call: async ([input], context) => {
+      const receiver = context?.thisValue;
+      segmentState(receiver, false);
+      const release = retainValues(budget, () => [receiver, input]);
+      try {
+        const number = await sandboxNumber(input, budget, context);
+        const index = Number.isNaN(number) ? 0 : Math.trunc(number);
+        return allocateProducedSandboxValue(containingSegment(receiver, index, false, budget), budget);
+      } finally {
+        release();
+      }
+    }
+  });
+  const iterate = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "[Symbol.iterator]",
+    length: 0,
+    call: (_args, context) => {
+      const state = segmentState(context?.thisValue, false);
+      budget.visitNode(state.input.length);
+      const value = createSandboxSegments({ segmenter: state.segmenter, input: state.input, index: 0 });
+      setSandboxPrototype(value, iteratorPrototype, budget);
+      return allocateProducedSandboxValue(value, budget);
+    }
+  });
+  const next = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "next",
+    length: 0,
+    call: (_args, context) => {
+      const receiver = context?.thisValue;
+      const state = segmentState(receiver, true);
+      const value = containingSegment(receiver, state.index, true, budget);
+      return allocateProducedSandboxValue({ value, done: value === void 0 }, budget);
+    }
+  });
+  Object.defineProperties(segmentsPrototype, {
+    containing: { value: containing, writable: true, configurable: true },
+    [Symbol.iterator]: { value: iterate, writable: true, configurable: true }
+  });
+  Object.defineProperties(iteratorPrototype, {
+    next: { value: next, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Segmenter String Iterator", configurable: true }
+  });
+  registerBuiltinIdentities(budget, { "%IntlSegmentsPrototype%": segmentsPrototype, "%IntlSegmentIteratorPrototype%": iteratorPrototype });
+  for (const closure of [containing, iterate, next]) registerIntrinsicFunction(budget, closure);
+  for (const value of [segmentsPrototype, iteratorPrototype]) registerIntrinsicObject(budget, value);
+  return constructor;
+}
+
 // packages/safe-js/src/interp/globals/intl.ts
 var supportedValuesOf = Intl.supportedValuesOf;
 function createIntlGlobal(budget, now) {
@@ -34104,6 +34458,8 @@ function createIntlGlobal(budget, now) {
   const relativeTimeFormat = createRelativeTimeFormatConstructor(budget);
   const displayNames = createDisplayNamesConstructor(budget);
   const dateTimeFormat = createDateTimeFormatConstructor(budget, now);
+  const pluralRules = createPluralRulesConstructor(budget);
+  const segmenter = createSegmenterConstructor(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 +34467,15 @@ 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 });
+  Object.defineProperty(intl, "Segmenter", { value: segmenter, 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, segmenter]) {
     const prototype = constructor.properties.prototype;
     for (const owner of [prototype, constructor.properties])
       for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(owner)))
@@ -34235,7 +34593,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 (!["guest-segmenter", "guest-segments", "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 +34901,44 @@ 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-segmenter") {
+    fields(node, ["kind", "options", "state"]);
+    const options = record2(node.options);
+    fields(options, ["locale", "granularity"]);
+    if (typeof options.locale !== "string" || typeof options.granularity !== "string") throw new TypeError("Invalid Segmenter options.");
+    const restored = segmenterState(createSandboxSegmenter(options.locale, options)).options;
+    if (options.locale !== restored.locale || options.granularity !== restored.granularity) throw new TypeError("Invalid resolved Segmenter options.");
+    state(node.state);
+  } else if (node.kind === "guest-segments") {
+    fields(node, ["kind", "segmenter", "input", "state"], ["index"]);
+    const segmenter = reference(node.segmenter, ["guest-segmenter"]);
+    if (typeof node.input !== "string") throw new TypeError("Invalid segments input.");
+    if (node.index !== void 0) {
+      if (!Number.isSafeInteger(node.index) || node.index < 0 || node.index > node.input.length)
+        throw new TypeError("Invalid segment iterator index.");
+      const options = record2(segmenter.options);
+      const owner = createSandboxSegmenter(options.locale, options);
+      const value = createSandboxSegments({ segmenter: owner, input: node.input });
+      if (node.index < node.input.length && segmentState(value).native.containing(node.index)?.index !== node.index)
+        throw new TypeError("Invalid segment iterator boundary.");
+    }
+    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);
@@ -38112,7 +38508,7 @@ var structuredCloneErrorNames = ["Error", "EvalError", "RangeError", "ReferenceE
 function* cloneStructuredGraph(value, state, budget, depth = 0) {
   assertSandboxDataDepth(depth);
   budget.visitNode();
-  if (typeof value === "symbol" || isSandboxModuleNamespace(value) || isSandboxClosure(value) || isSandboxPromise(value) || isSandboxGenerator(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxArrayIterator(value) || isSandboxStringIterator(value) || isSandboxArguments(value))
+  if (typeof value === "symbol" || isSandboxModuleNamespace(value) || isSandboxClosure(value) || isSandboxPromise(value) || isSandboxGenerator(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxArrayIterator(value) || isSandboxStringIterator(value) || isSandboxArguments(value) || isSandboxSegmenter(value) || isSandboxSegments(value))
     throw new DOMException("Value cannot be structured cloned.", "DataCloneError");
   if (typeof value !== "object" || value === null) return allocateProducedSandboxValue(value, budget);
   if (iteratorHelperStates.has(value) || iteratorWrapperStates.has(value))
@@ -38319,6 +38715,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);
@@ -38386,6 +38783,12 @@ function measureSandboxData(values, options = {}) {
     }
     if (isSandboxArrayIterator(value)) visit(arrayIteratorState(value).source, depth + 1);
     if (isSandboxStringIterator(value)) visit(stringIteratorState(value).input, depth + 1);
+    if (isSandboxSegmenter(value)) visit(segmenterState(value).options, depth + 1);
+    if (isSandboxSegments(value)) {
+      const state = segmentState(value);
+      visit(state.segmenter, depth + 1);
+      visit(state.input, depth + 1);
+    }
     if (isSandboxRegExpIterator(value)) {
       const state = regexpIteratorState(value);
       visit(state.matcher, depth + 1);
@@ -56309,4 +56712,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-2PVMLKJL.js.map
+//# sourceMappingURL=chunk-N45AVH5W.js.map