@poe-platform/safe-js 0.1.469 → 0.1.471

package/dist/safe-js/chunks/{chunk-J72Q6BW5.js → chunk-D26DLMQR.js}

@@ -19873,8 +19873,37 @@ async function compareStringLocale(value, args, budget, context) {
   }
 }
 
+// packages/safe-js/src/interp/methods/string-html.ts
+var stringHtmlMethods = {
+  anchor: ["a", "name"],
+  big: ["big", ""],
+  blink: ["blink", ""],
+  bold: ["b", ""],
+  fixed: ["tt", ""],
+  fontcolor: ["font", "color"],
+  fontsize: ["font", "size"],
+  italics: ["i", ""],
+  link: ["a", "href"],
+  small: ["small", ""],
+  strike: ["strike", ""],
+  sub: ["sub", ""],
+  sup: ["sup", ""]
+};
+async function createStringHtml(value, [tag, attribute], argument, budget, context) {
+  const release = retainValues(budget, () => [value, argument]);
+  try {
+    const text = attribute === "" ? "" : await sandboxString(argument, budget, context);
+    budget.visitNode(value.length + text.length);
+    const opening = attribute === "" ? `<${tag}>` : `<${tag} ${attribute}="${text.replaceAll('"', "&quot;")}">`;
+    return budget.allocateString(`${opening}${value}</${tag}>`);
+  } finally {
+    release();
+  }
+}
+
 // packages/safe-js/src/interp/methods/string.ts
 var stringMethodLengths = {
+  ...Object.fromEntries(Object.entries(stringHtmlMethods).map(([name, [, attribute]]) => [name, attribute === "" ? 0 : 1])),
   at: 1,
   charAt: 1,
   charCodeAt: 1,
@@ -20012,6 +20041,9 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
   return dispatch();
 }
 function callStringMethodBody(value, methodName, args, budget, parent, context) {
+  if (Object.hasOwn(stringHtmlMethods, methodName)) {
+    return createStringHtml(value, stringHtmlMethods[methodName], args[0], budget, context);
+  }
   if (methodName === "concat" && args.some((argument) => argument !== null && typeof argument === "object")) {
     return callConcat(value, args, budget, context);
   }
@@ -28756,20 +28788,41 @@ function selectPlural2(value, inputs) {
   return Reflect.apply(inputs.length === 1 ? select : selectRange, pluralRulesState(value).native, inputs);
 }
 
-// packages/safe-js/src/interp/intl-numberformat.ts
+// packages/safe-js/src/interp/intl-durationformat.ts
 var states10 = /* @__PURE__ */ new WeakMap();
+function createSandboxDurationFormat(settings) {
+  const value = /* @__PURE__ */ Object.create(null);
+  const options = { locale: settings.locale, numberingSystem: settings.numberingSystem, style: settings.style };
+  for (const [unit, { style, display }] of Object.entries(settings.units)) {
+    options[unit] = style === "fractional" ? "numeric" : style;
+    options[`${unit}Display`] = display;
+  }
+  options.fractionalDigits = settings.fractionalDigits;
+  states10.set(value, { settings, options });
+  return value;
+}
+function isSandboxDurationFormat(value) {
+  return typeof value === "object" && value !== null && states10.has(value);
+}
+function durationFormatState(value) {
+  if (!isSandboxDurationFormat(value)) throw new TypeError("Intl.DurationFormat requires a DurationFormat receiver.");
+  return states10.get(value);
+}
+
+// packages/safe-js/src/interp/intl-numberformat.ts
+var states11 = /* @__PURE__ */ new WeakMap();
 function createSandboxNumberFormat(locales2, options) {
   const native = createNumberFormatter(locales2, options);
   const value = /* @__PURE__ */ Object.create(null);
-  states10.set(value, { native, options: numberFormatterOptions2(native) });
+  states11.set(value, { native, options: numberFormatterOptions2(native) });
   return value;
 }
 function isSandboxNumberFormat(value) {
-  return typeof value === "object" && value !== null && states10.has(value);
+  return typeof value === "object" && value !== null && states11.has(value);
 }
 function numberFormatState(value) {
   if (!isSandboxNumberFormat(value)) throw new TypeError("Intl.NumberFormat requires a NumberFormat receiver.");
-  return states10.get(value);
+  return states11.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;
@@ -28793,21 +28846,21 @@ var methods = {
   formatRange: NativeDateTimeFormat.prototype.formatRange,
   formatRangeToParts: NativeDateTimeFormat.prototype.formatRangeToParts
 };
-var states11 = /* @__PURE__ */ new WeakMap();
+var states12 = /* @__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);
-  states11.set(value, { native, options: { ...Reflect.apply(resolvedOptions6, native, []) } });
+  states12.set(value, { native, options: { ...Reflect.apply(resolvedOptions6, native, []) } });
   return value;
 }
 function isSandboxDateTimeFormat(value) {
-  return typeof value === "object" && value !== null && states11.has(value);
+  return typeof value === "object" && value !== null && states12.has(value);
 }
 function dateTimeFormatState(value) {
   if (!isSandboxDateTimeFormat(value)) throw new TypeError("Intl.DateTimeFormat requires a DateTimeFormat receiver.");
-  return states11.get(value);
+  return states12.get(value);
 }
 function formatDateTimeValue(receiver, method, values) {
   const { native } = dateTimeFormatState(receiver);
@@ -29171,6 +29224,14 @@ function captureGuestHeapNode(value, encode) {
     const options = pluralRulesState(value).options;
     return { kind: "guest-pluralrules", options: { ...options, pluralCategories: [...options.pluralCategories] }, state: captureObjectState(value, encode) };
   }
+  if (isSandboxDurationFormat(value)) {
+    const { fractionalDigits, ...settings } = durationFormatState(value).settings;
+    return { kind: "guest-durationformat", settings: {
+      ...settings,
+      ...fractionalDigits === void 0 ? {} : { fractionalDigits },
+      units: Object.fromEntries(Object.entries(settings.units).map(([unit, options]) => [unit, { ...options }]))
+    }, 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) };
@@ -30140,6 +30201,27 @@ function getEnumerableDataValues(value) {
   return getEnumerableDataEntries(value).map(([, entry]) => entry);
 }
 
+// packages/safe-js/src/interp/intl-duration-locale.ts
+import { DurationFormat } from "@formatjs/intl-durationformat";
+var NativeNumberFormat4 = Intl.NumberFormat;
+var NativeLocale2 = Intl.Locale;
+var patterns = new Map(Object.entries(DurationFormat.localeData).map(([locale, data]) => {
+  if (data === void 0) throw new TypeError(`Missing duration data for ${locale}.`);
+  return [locale, Object.freeze({ ...data.digitalFormat })];
+}));
+function resolveDurationLocale(locales2, options) {
+  const { locale, numberingSystem } = new NativeNumberFormat4(locales2, options).resolvedOptions();
+  const tag = new NativeLocale2(locale);
+  let selected = tag.baseName;
+  if (!patterns.has(selected)) selected = tag.minimize().baseName;
+  while (!patterns.has(selected) && selected.includes("-")) selected = selected.slice(0, selected.lastIndexOf("-"));
+  const pattern = patterns.get(selected);
+  if (pattern === void 0) throw new RangeError(`Missing DurationFormat locale data for ${locale}.`);
+  const separator = pattern[numberingSystem] ?? pattern.default;
+  if (separator === void 0) throw new TypeError("Missing duration separator.");
+  return { locale, numberingSystem, separator };
+}
+
 // packages/safe-js/src/interp/globals/json-parse.ts
 async function parseJsonWithReviver(text, reviver, budget, context) {
   budget.visitNode(text.length);
@@ -32004,7 +32086,7 @@ function createMiscGlobals(options) {
 }
 
 // packages/safe-js/src/interp/globals/uri.ts
-var conversions = { encodeURI, encodeURIComponent, decodeURI, decodeURIComponent };
+var conversions = { encodeURI, encodeURIComponent, decodeURI, decodeURIComponent, escape, unescape };
 function createUriGlobals(budget) {
   return Object.fromEntries(Object.entries(conversions).map(([name, conversion]) => {
     const closure = createSandboxClosure({
@@ -34376,6 +34458,262 @@ function createSegmenterConstructor(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/intl-duration-options.ts
+async function readDurationOptions(value, locales2, budget, context) {
+  if (value !== void 0 && (value === null || typeof value !== "object")) throw new TypeError("DurationFormat options must be an object.");
+  const input = intlOptionsObject(value, budget);
+  const converted = {};
+  const units = {};
+  let raw;
+  const release = retainValues(budget, () => [input, locales2, converted, units, raw]);
+  try {
+    for (const [key, type] of [["localeMatcher", ["lookup", "best fit"]], ["numberingSystem", "unicodeType"]]) {
+      raw = await readIntlProperty(input, key, budget, context);
+      if (raw !== void 0) converted[key] = await convertIntlOption(raw, key, type, budget, context);
+    }
+    const locale = resolveDurationLocale(locales2, { localeMatcher: converted.localeMatcher, numberingSystem: converted.numberingSystem });
+    raw = await readIntlProperty(input, "style", budget, context);
+    const style = raw === void 0 ? "short" : await convertIntlOption(raw, "style", ["long", "short", "narrow", "digital"], budget, context);
+    let previous = "";
+    for (const unit of ["years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"]) {
+      units[unit] = await readDurationUnitOptions(input, unit, style, previous, budget, context);
+      if (["hours", "minutes", "seconds", "milliseconds", "microseconds"].includes(unit)) previous = units[unit].style;
+    }
+    raw = await readIntlProperty(input, "fractionalDigits", budget, context);
+    let fractionalDigits;
+    if (raw !== void 0) {
+      const number = await sandboxNumber(raw, budget, context);
+      if (Number.isNaN(number) || number < 0 || number > 9) throw new RangeError("Invalid duration fractionalDigits.");
+      fractionalDigits = Math.floor(number);
+    }
+    return { ...locale, style, units, fractionalDigits };
+  } finally {
+    release();
+  }
+}
+async function readDurationUnitOptions(input, unit, base, previous, budget, context) {
+  const subsecond = ["milliseconds", "microseconds", "nanoseconds"].includes(unit);
+  const clock = ["hours", "minutes", "seconds"].includes(unit);
+  const styles = ["long", "short", "narrow", ...clock || subsecond ? ["numeric"] : [], ...clock ? ["2-digit"] : []];
+  let raw;
+  let style;
+  const release = retainValues(budget, () => [input, raw, style]);
+  try {
+    raw = await readIntlProperty(input, unit, budget, context);
+    style = raw === void 0 ? void 0 : await convertIntlOption(raw, unit, styles, budget, context);
+    let defaultDisplay = "always";
+    if (style === void 0) {
+      if (base === "digital") {
+        style = clock || subsecond ? "numeric" : "short";
+        if (!clock) defaultDisplay = "auto";
+      } else if (["numeric", "2-digit", "fractional"].includes(previous)) {
+        style = "numeric";
+        if (unit !== "minutes" && unit !== "seconds") defaultDisplay = "auto";
+      } else {
+        style = base;
+        defaultDisplay = "auto";
+      }
+    }
+    if (style === "numeric" && subsecond) {
+      style = "fractional";
+      defaultDisplay = "auto";
+    }
+    raw = await readIntlProperty(input, `${unit}Display`, budget, context);
+    const display = raw === void 0 ? defaultDisplay : await convertIntlOption(raw, `${unit}Display`, ["always", "auto"], budget, context);
+    if (display === "always" && style === "fractional" || previous === "fractional" && style !== "fractional" || ["numeric", "2-digit"].includes(previous) && !["numeric", "2-digit", "fractional"].includes(style))
+      throw new RangeError("Incompatible duration unit style or display.");
+    if (["minutes", "seconds"].includes(unit) && ["numeric", "2-digit"].includes(previous)) style = "2-digit";
+    return { style, display };
+  } finally {
+    release();
+  }
+}
+
+// packages/safe-js/src/interp/intl-duration-record.ts
+async function readDurationRecord(input, budget, context) {
+  if (typeof input === "string") throw new RangeError("Duration strings are not supported.");
+  if (typeof input !== "object" || input === null) throw new TypeError("Expected a duration object.");
+  const record4 = { years: 0, months: 0, weeks: 0, days: 0, hours: 0, minutes: 0, seconds: 0, milliseconds: 0, microseconds: 0, nanoseconds: 0 };
+  let raw;
+  let present = false;
+  const release = retainValues(budget, () => [input, record4, raw]);
+  try {
+    for (const key of ["days", "hours", "microseconds", "milliseconds", "minutes", "months", "nanoseconds", "seconds", "weeks", "years"]) {
+      raw = await readIntlProperty(input, key, budget, context);
+      if (raw === void 0) continue;
+      present = true;
+      const value = await sandboxNumber(raw, budget, context);
+      if (!Number.isInteger(value)) throw new RangeError("Duration fields must be finite integers.");
+      record4[key] = value === 0 ? 0 : value;
+    }
+    if (!present) throw new TypeError("Expected at least one duration field.");
+    let sign = 0;
+    for (const value of Object.values(record4)) {
+      const current = Math.sign(value);
+      if (current !== 0) {
+        if (sign !== 0 && sign !== current) throw new RangeError("Duration fields must have the same sign.");
+        sign = current;
+      }
+    }
+    if ([record4.years, record4.months, record4.weeks].some((value) => Math.abs(value) >= 2 ** 32))
+      throw new RangeError("Duration calendar fields exceed their limit.");
+    const nanoseconds = BigInt(record4.days) * 86400000000000n + BigInt(record4.hours) * 3600000000000n + BigInt(record4.minutes) * 60000000000n + BigInt(record4.seconds) * 1000000000n + BigInt(record4.milliseconds) * 1000000n + BigInt(record4.microseconds) * 1000n + BigInt(record4.nanoseconds);
+    const limit = 2n ** 53n * 1000000000n;
+    if (nanoseconds <= -limit || nanoseconds >= limit) throw new RangeError("Duration time fields exceed their limit.");
+    return record4;
+  } finally {
+    release();
+  }
+}
+
+// packages/safe-js/src/interp/intl-duration-parts.ts
+import { BigDecimal as BigDecimal2 } from "@formatjs/bigdecimal";
+var NativeListFormat2 = Intl.ListFormat;
+function formatDurationParts(settings, duration, separator) {
+  const units = Object.keys(duration);
+  const lists = [];
+  const negative = Object.values(duration).some((value) => value < 0);
+  let first = true;
+  const amount = (index2) => {
+    let value = new BigDecimal2(BigInt(duration[units[index2]]).toString());
+    for (let next = index2 + 1; next < units.length && settings.units[units[next]].style === "fractional"; next++)
+      value = value.plus(new BigDecimal2(BigInt(duration[units[next]]).toString()).div(new BigDecimal2(1e3).pow(next - index2)));
+    return value;
+  };
+  const numberParts = (index2, value, numeric) => {
+    const unit = units[index2];
+    const style = settings.units[unit].style;
+    const options = { numberingSystem: settings.numberingSystem, signDisplay: first ? "auto" : "never" };
+    if (numeric) {
+      options.useGrouping = false;
+      if (style === "2-digit") options.minimumIntegerDigits = 2;
+    } else {
+      options.style = "unit";
+      options.unit = unit.slice(0, -1);
+      options.unitDisplay = style;
+    }
+    if (settings.units[units[index2 + 1] ?? ""]?.style === "fractional") {
+      options.minimumFractionDigits = settings.fractionalDigits ?? 0;
+      options.maximumFractionDigits = settings.fractionalDigits ?? 9;
+      options.roundingMode = "trunc";
+    }
+    const input = first && negative && value.isZero() ? -0 : value.toString();
+    first = false;
+    const formatter = createPortableNumberFormatter(settings.locale, options);
+    const parts = numberFormatterResult(formatter, "formatToParts", [input]);
+    return parts.map((part) => ({ ...part, unit: unit.slice(0, -1) }));
+  };
+  for (let index2 = 0; index2 < units.length; index2++) {
+    const unit = units[index2];
+    const option = settings.units[unit];
+    if (option.style === "fractional") break;
+    if (["numeric", "2-digit"].includes(option.style)) {
+      const hours = index2 <= 4 && (duration.hours !== 0 || settings.units.hours.display === "always");
+      const secondsValue = amount(6);
+      const seconds = !secondsValue.isZero() || settings.units.seconds.display === "always";
+      const minutes = index2 <= 5 && (duration.minutes !== 0 || settings.units.minutes.display === "always" || hours && seconds);
+      const parts = [];
+      for (const [clockIndex, displayed] of [[4, hours], [5, minutes], [6, seconds]]) {
+        if (!displayed) continue;
+        if (parts.length) parts.push({ type: "literal", value: separator });
+        parts.push(...numberParts(clockIndex, clockIndex === 6 ? secondsValue : amount(clockIndex), true));
+      }
+      if (parts.length) lists.push(parts);
+      break;
+    }
+    const value = amount(index2);
+    if (!value.isZero() || option.display === "always") lists.push(numberParts(index2, value, false));
+    if (settings.units[units[index2 + 1] ?? ""]?.style === "fractional") break;
+  }
+  const list2 = new NativeListFormat2(settings.locale, { type: "unit", style: settings.style === "digital" ? "short" : settings.style });
+  let index = 0;
+  return list2.formatToParts(lists.map((parts) => parts.map((part) => part.value).join(""))).flatMap((part) => part.type === "element" ? lists[index++] : [{ type: "literal", value: part.value }]);
+}
+
+// packages/safe-js/src/interp/globals/intl-durationformat.ts
+var supportedLocalesOf10 = Intl.NumberFormat.supportedLocalesOf;
+function createDurationFormatConstructor(budget) {
+  const prototype = createIntrinsicObject();
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "DurationFormat",
+    length: 0,
+    call: () => {
+      throw new TypeError("Constructor DurationFormat 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 = [];
+      let settings;
+      const release = retainValues(budget, () => [selected, locales2, settings]);
+      try {
+        locales2 = await canonicalizeGuestLocales(input, budget, context);
+        settings = await readDurationOptions(options, locales2, budget, context);
+        const value = createSandboxDurationFormat(settings);
+        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(supportedLocalesOf10(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.DurationFormat", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => allocateProducedSandboxValue({ ...durationFormatState(context?.thisValue).options }, budget)
+    }), writable: true, configurable: true }
+  });
+  for (const method of ["format", "formatToParts"]) {
+    Object.defineProperty(prototype, method, { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: method,
+      length: 1,
+      call: async ([input], context) => {
+        const receiver = context?.thisValue;
+        const { settings } = durationFormatState(receiver);
+        const release = retainValues(budget, () => [receiver, input]);
+        try {
+          const record4 = await readDurationRecord(input, budget, context);
+          budget.visitNode(100);
+          const parts = formatDurationParts(settings, record4, settings.separator);
+          return allocateProducedSandboxValue(method === "format" ? parts.map((part) => part.value).join("") : parts, 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) {
@@ -34398,6 +34736,7 @@ function createIntlGlobal(budget, now) {
   const dateTimeFormat = createDateTimeFormatConstructor(budget, now);
   const pluralRules = createPluralRulesConstructor(budget);
   const segmenter = createSegmenterConstructor(budget);
+  const durationFormat = createDurationFormatConstructor(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 });
@@ -34407,13 +34746,14 @@ function createIntlGlobal(budget, now) {
   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 });
+  Object.defineProperty(intl, "DurationFormat", { value: durationFormat, 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, pluralRules, segmenter]) {
+  for (const constructor of [locale, collator, numberFormat, listFormat, relativeTimeFormat, displayNames, dateTimeFormat, pluralRules, segmenter, durationFormat]) {
     const prototype = constructor.properties.prototype;
     for (const owner of [prototype, constructor.properties])
       for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(owner)))
@@ -34531,7 +34871,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  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;
+  if (!["guest-durationformat", "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"]);
@@ -34861,6 +35201,30 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
         throw new TypeError("Invalid segment iterator boundary.");
     }
     state(node.state);
+  } else if (node.kind === "guest-durationformat") {
+    fields(node, ["kind", "settings", "state"]);
+    const settings = record2(node.settings);
+    fields(settings, ["locale", "numberingSystem", "separator", "style", "units"], ["fractionalDigits"]);
+    if (typeof settings.locale !== "string" || typeof settings.numberingSystem !== "string" || !["long", "short", "narrow", "digital"].includes(settings.style) || settings.fractionalDigits !== void 0 && (!Number.isInteger(settings.fractionalDigits) || settings.fractionalDigits < 0 || settings.fractionalDigits > 9))
+      throw new TypeError("Invalid duration settings.");
+    const locale = resolveDurationLocale([settings.locale], { numberingSystem: settings.numberingSystem });
+    if (locale.locale !== settings.locale || locale.numberingSystem !== settings.numberingSystem || locale.separator !== settings.separator)
+      throw new TypeError("Invalid resolved duration locale.");
+    const units = record2(settings.units);
+    const names = ["years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"];
+    fields(units, names);
+    let previous = "";
+    for (const name of names) {
+      const unit = record2(units[name]);
+      fields(unit, ["style", "display"]);
+      const clock = ["hours", "minutes", "seconds"].includes(name);
+      const subsecond = ["milliseconds", "microseconds", "nanoseconds"].includes(name);
+      const allowed = ["long", "short", "narrow", ...clock ? ["numeric", "2-digit"] : [], ...subsecond ? ["fractional"] : []];
+      if (typeof unit.style !== "string" || !allowed.includes(unit.style) || !["always", "auto"].includes(unit.display) || unit.style === "fractional" && unit.display !== "auto" || previous === "fractional" && unit.style !== "fractional" || ["numeric", "2-digit"].includes(previous) && !["numeric", "2-digit", "fractional"].includes(unit.style) || ["minutes", "seconds"].includes(name) && ["numeric", "2-digit"].includes(previous) && unit.style !== "2-digit")
+        throw new TypeError("Invalid duration unit options.");
+      if (clock || name === "milliseconds" || name === "microseconds") previous = unit.style;
+    }
+    state(node.state);
   } else if (node.kind === "guest-pluralrules") {
     fields(node, ["kind", "options", "state"]);
     const options = record2(node.options);
@@ -38446,7 +38810,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) || isSandboxSegmenter(value) || isSandboxSegments(value) || isSandboxLocale(value) || isSandboxCollator(value) || isSandboxDateTimeFormat(value) || isSandboxDisplayNames(value) || isSandboxListFormat(value) || isSandboxNumberFormat(value) || isSandboxPluralRules(value) || isSandboxRelativeTimeFormat(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) || isSandboxLocale(value) || isSandboxCollator(value) || isSandboxDateTimeFormat(value) || isSandboxDisplayNames(value) || isSandboxDurationFormat(value) || isSandboxListFormat(value) || isSandboxNumberFormat(value) || isSandboxPluralRules(value) || isSandboxRelativeTimeFormat(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))
@@ -38654,6 +39018,11 @@ function measureSandboxData(values, options = {}) {
     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 (isSandboxDurationFormat(value)) {
+      const state = durationFormatState(value);
+      visit(state.settings, depth + 1);
+      visit(state.options, depth + 1);
+    }
     if (isSandboxNumberFormat(value)) {
       const state = numberFormatState(value);
       visit(state.options, depth + 1);
@@ -56706,4 +57075,4 @@ authorization of the copyright holder.
 SPDX-License-Identifier: Unicode-3.0
 
 */
-//# sourceMappingURL=chunk-J72Q6BW5.js.map
+//# sourceMappingURL=chunk-D26DLMQR.js.map