@poe-platform/safe-js 0.1.457 → 0.1.458

package/dist/safe-js/chunks/{chunk-OXTOMAYL.js → chunk-GPAQUL2B.js}

@@ -8258,13 +8258,13 @@ function createLiveHostObject(definition, controller) {
   controller.chargeWork(properties.size + Object.keys(operations).length + 1);
   const host = Object.freeze(/* @__PURE__ */ Object.create(null));
   const guest = Object.freeze(/* @__PURE__ */ Object.create(null));
-  const methods2 = new Map(
+  const methods3 = new Map(
     Object.entries(operations).map(([name, operation]) => [
       name,
       controller.method(operation)
     ])
   );
-  const state = { host, guest, controller, properties, methods: methods2, indexed, named };
+  const state = { host, guest, controller, properties, methods: methods3, indexed, named };
   hostObjects.set(host, state);
   guestObjects.set(guest, state);
   return host;
@@ -8691,11 +8691,11 @@ function isIntrinsicFunction(value) {
 function registerIntrinsicPrototype(budget, prototype, constructor) {
   if (constructor.name === void 0) throw new TypeError("Intrinsic constructors require an installation name.");
   registerBuiltinIdentities(budget, { [constructor.name]: constructor });
-  const methods2 = [prototype, materializeFunctionProperties(constructor)].flatMap((owner) => Reflect.ownKeys(owner).flatMap((key) => {
+  const methods3 = [prototype, materializeFunctionProperties(constructor)].flatMap((owner) => Reflect.ownKeys(owner).flatMap((key) => {
     const descriptor = Object.getOwnPropertyDescriptor(owner, key);
     return [descriptor.value, ...retainedAccessorClosures(descriptor)];
   })).filter(isGuestClosure);
-  trackIntrinsicState(budget, prototype, constructor, [prototype, constructor, ...methods2]);
+  trackIntrinsicState(budget, prototype, constructor, [prototype, constructor, ...methods3]);
 }
 function registerIntrinsicFunction(budget, closure) {
   if (closure.name === void 0) throw new TypeError("Intrinsic functions require an installation name.");
@@ -8704,8 +8704,8 @@ function registerIntrinsicFunction(budget, closure) {
   trackIntrinsicState(budget, closure, closure, [closure]);
 }
 function registerIntrinsicObject(budget, value, trackMethods = true) {
-  const methods2 = trackMethods ? Object.values(Object.getOwnPropertyDescriptors(value)).map((descriptor) => descriptor.value).filter(isGuestClosure) : [];
-  trackIntrinsicState(budget, value, value, [value, ...methods2]);
+  const methods3 = trackMethods ? Object.values(Object.getOwnPropertyDescriptors(value)).map((descriptor) => descriptor.value).filter(isGuestClosure) : [];
+  trackIntrinsicState(budget, value, value, [value, ...methods3]);
 }
 function completeIntrinsicObjectInitialization(budget, value) {
   for (const records of intrinsicRetentionGroups.get(budget)?.values() ?? []) {
@@ -10199,7 +10199,7 @@ async function nextArrayIterator(value, budget, context) {
 }
 
 // packages/safe-js/src/interp/globals/object.ts
-function createObjectGlobal(methods2, budget) {
+function createObjectGlobal(methods3, budget) {
   const construct = ([value]) => {
     if (value === null || value === void 0) {
       budget.chargeDataUsage(1);
@@ -10235,7 +10235,7 @@ function createObjectGlobal(methods2, budget) {
   const prototype = createIntrinsicObject(properties.prototype);
   properties.prototype = prototype;
   Object.defineProperty(properties, "prototype", { writable: false });
-  for (const [name, method] of Object.entries(methods2)) {
+  for (const [name, method] of Object.entries(methods3)) {
     Object.defineProperty(properties, name, { value: method, writable: true, configurable: true });
   }
   const prototypeMethods = {
@@ -20723,7 +20723,7 @@ function createPrimitiveConstructor(options, budget) {
       writable: isSandboxClosure(value),
       configurable: isSandboxClosure(value)
     });
-  const methods2 = /* @__PURE__ */ new Map([
+  const methods3 = /* @__PURE__ */ new Map([
     [
       "valueOf",
       createSandboxClosure({
@@ -20735,9 +20735,9 @@ function createPrimitiveConstructor(options, budget) {
     ]
   ]);
   if (kind === "number") {
-    for (const name of numberMethodNames) methods2.set(name, getNumberMember(name, budget));
+    for (const name of numberMethodNames) methods3.set(name, getNumberMember(name, budget));
   } else {
-    methods2.set(
+    methods3.set(
       "toString",
       createSandboxClosure({
         sandbox: true,
@@ -20747,9 +20747,9 @@ function createPrimitiveConstructor(options, budget) {
       })
     );
     if (kind === "string")
-      for (const name of stringMethodNames) methods2.set(name, getStringMember("", name, budget));
+      for (const name of stringMethodNames) methods3.set(name, getStringMember("", name, budget));
   }
-  for (const [name, value] of methods2)
+  for (const [name, value] of methods3)
     Object.defineProperty(prototype, name, { value, writable: true, configurable: true });
   if (kind === "string") {
     const iteratorPrototype = createIntrinsicObject();
@@ -28744,6 +28744,36 @@ function formatNumberValue(receiver, method, values) {
   return numberFormatterResult2(native, method, values);
 }
 
+// packages/safe-js/src/interp/intl-datetimeformat.ts
+var NativeDateTimeFormat = Intl.DateTimeFormat;
+var resolvedOptions5 = 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();
+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, []) } });
+  return value;
+}
+function isSandboxDateTimeFormat(value) {
+  return typeof value === "object" && value !== null && states10.has(value);
+}
+function dateTimeFormatState(value) {
+  if (!isSandboxDateTimeFormat(value)) throw new TypeError("Intl.DateTimeFormat requires a DateTimeFormat receiver.");
+  return states10.get(value);
+}
+function formatDateTimeValue(receiver, method, values) {
+  const { native } = dateTimeFormatState(receiver);
+  return method === "format" ? Reflect.apply(format3, native, [])(values[0]) : Reflect.apply(methods[method], native, values);
+}
+
 // packages/safe-js/src/interp/iterator-helper.ts
 var iteratorHelperStates = /* @__PURE__ */ new WeakMap();
 
@@ -29086,9 +29116,13 @@ 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 (isSandboxDateTimeFormat(value)) {
+    const { options, format: format4 } = dateTimeFormatState(value);
+    return { kind: "guest-datetimeformat", options: { ...options }, ...format4 === void 0 ? {} : { format: encode(format4) }, state: captureObjectState(value, encode) };
+  }
   if (isSandboxNumberFormat(value)) {
-    const { options, format: format3 } = numberFormatState(value);
-    return { kind: "guest-numberformat", options: { ...options }, ...format3 === void 0 ? {} : { format: encode(format3) }, state: captureObjectState(value, encode) };
+    const { options, format: format4 } = numberFormatState(value);
+    return { kind: "guest-numberformat", options: { ...options }, ...format4 === void 0 ? {} : { format: encode(format4) }, state: captureObjectState(value, encode) };
   }
   if (isSandboxCollator(value)) {
     const { options, compare } = collatorState(value);
@@ -30166,7 +30200,7 @@ async function parseJsonWithReviver(text, reviver, budget, context) {
 }
 
 // packages/safe-js/src/interp/date-locale.ts
-var NativeDateTimeFormat = Intl.DateTimeFormat;
+var NativeDateTimeFormat2 = Intl.DateTimeFormat;
 var dateTimeOptions = [
   ["localeMatcher", ["lookup", "best fit"]],
   ["calendar", "unicodeType"],
@@ -30189,14 +30223,11 @@ var dateTimeOptions = [
   ["dateStyle", ["full", "long", "medium", "short"]],
   ["timeStyle", ["full", "long", "medium", "short"]]
 ];
-async function formatDateLocale(name, time, args, budget, context) {
-  if (Number.isNaN(time)) return budget.allocateString("Invalid Date");
-  let locales2 = [];
+async function readDateTimeFormatOptions(input, budget, context) {
   const options = /* @__PURE__ */ Object.create(null);
-  const release = retainValues(budget, () => [locales2, options]);
+  const release = retainValues(budget, () => [input, options]);
   try {
-    locales2 = await canonicalizeGuestLocales(args[0], budget, context);
-    const inputOptions = intlOptionsObject(args[1], budget);
+    const inputOptions = intlOptionsObject(input, budget);
     for (const [key, type] of dateTimeOptions) {
       const value = await readIntlProperty(inputOptions, key, budget, context);
       if (value === void 0) continue;
@@ -30208,10 +30239,23 @@ async function formatDateLocale(name, time, args, budget, context) {
       } else if (type === "zone") {
         const text = await sandboxString(value, budget, context);
         budget.visitNode(text.length);
-        new NativeDateTimeFormat("en", { timeZone: text });
+        new NativeDateTimeFormat2("en", { timeZone: text });
         options[key] = text;
       } else options[key] = await convertIntlOption(value, key, type, budget, context);
     }
+    return options;
+  } finally {
+    release();
+  }
+}
+async function formatDateLocale(name, time, args, budget, context) {
+  if (Number.isNaN(time)) return budget.allocateString("Invalid Date");
+  let locales2 = [];
+  let options = /* @__PURE__ */ Object.create(null);
+  const release = retainValues(budget, () => [locales2, options]);
+  try {
+    locales2 = await canonicalizeGuestLocales(args[0], budget, context);
+    options = await readDateTimeFormatOptions(args[1], budget, context);
     const date = name !== "toLocaleTimeString";
     const clock = name !== "toLocaleDateString";
     if (options.dateStyle !== void 0 || options.timeStyle !== void 0) {
@@ -30225,7 +30269,7 @@ async function formatDateLocale(name, time, args, budget, context) {
         if (clock) for (const key of ["hour", "minute", "second"]) options[key] = "numeric";
       }
     }
-    const formatter = new NativeDateTimeFormat(locales2, options);
+    const formatter = new NativeDateTimeFormat2(locales2, options);
     return budget.allocateString(formatter.format(time));
   } finally {
     release();
@@ -30310,9 +30354,9 @@ function createDateGlobal(options) {
       call: (args, context) => coerceDateParts(args, true, options.budget, context)
     })
   };
-  const methods2 = /* @__PURE__ */ new Map();
+  const methods3 = /* @__PURE__ */ new Map();
   for (const [name, method] of dateMethods)
-    methods2.set(
+    methods3.set(
       name,
       createSandboxClosure({
         guest: true,
@@ -30332,8 +30376,8 @@ function createDateGlobal(options) {
         }
       })
     );
-  methods2.set("toGMTString", methods2.get("toUTCString"));
-  methods2.set(Symbol.toPrimitive, createSandboxClosure({
+  methods3.set("toGMTString", methods3.get("toUTCString"));
+  methods3.set(Symbol.toPrimitive, createSandboxClosure({
     guest: true,
     sandbox: true,
     name: "[Symbol.toPrimitive]",
@@ -30349,7 +30393,7 @@ function createDateGlobal(options) {
   for (const [key, value] of Object.entries(staticProperties))
     Object.defineProperty(properties, key, { value, writable: key !== "prototype", configurable: key !== "prototype" });
   Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
-  for (const [key, value] of methods2)
+  for (const [key, value] of methods3)
     Object.defineProperty(prototype, key, { value, writable: key !== Symbol.toPrimitive, configurable: true });
   installDatePrototype(options.budget, prototype, constructor);
   return constructor;
@@ -30889,7 +30933,7 @@ function installCollectionPrototypes(budget, mapConstructor, setConstructor) {
       return context.thisValue.values.size;
     }
   });
-  for (const { name, constructor, methods: methods2, size, iterator } of [
+  for (const { name, constructor, methods: methods3, size, iterator } of [
     { name: "Map", constructor: mapConstructor, methods: mapMethods, size: mapSize, iterator: mapMethods.entries },
     { name: "Set", constructor: setConstructor, methods: setMethods, size: setSize, iterator: setMethods.values }
   ]) {
@@ -30904,13 +30948,13 @@ function installCollectionPrototypes(budget, mapConstructor, setConstructor) {
     Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
     Object.defineProperty(materializeFunctionProperties(constructor), Symbol.species, { get: accessorAdapter(species, "get"), configurable: true });
     Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
-    for (const [key, method] of Object.entries(methods2))
+    for (const [key, method] of Object.entries(methods3))
       Object.defineProperty(prototype, key, { value: method, writable: true, configurable: true });
     Object.defineProperty(prototype, "size", { get: accessorAdapter(size, "get"), configurable: true });
     Object.defineProperty(prototype, Symbol.toStringTag, { value: name, configurable: true });
     Object.defineProperty(prototype, Symbol.iterator, { value: iterator, writable: true, configurable: true });
     installCollectionPrototype(budget, name, prototype, constructor);
-    for (const method of /* @__PURE__ */ new Set([...Object.values(methods2), size, species])) registerIntrinsicFunction(budget, method);
+    for (const method of /* @__PURE__ */ new Set([...Object.values(methods3), size, species])) registerIntrinsicFunction(budget, method);
   }
 }
 function installCollectionIteratorPrototypes(budget) {
@@ -32793,7 +32837,7 @@ function createSymbolGlobal(budget) {
   });
   const properties = materializeFunctionProperties(constructor);
   Object.defineProperty(properties, "prototype", { value: prototype });
-  const methods2 = {
+  const methods3 = {
     for: createSandboxClosure({
       sandbox: true,
       name: "for",
@@ -32821,7 +32865,7 @@ function createSymbolGlobal(budget) {
       }
     })
   };
-  for (const [name, method] of Object.entries(methods2)) {
+  for (const [name, method] of Object.entries(methods3)) {
     symbolRegistryOrigins.set(method, entries);
     Object.defineProperty(properties, name, { value: method, writable: true, configurable: true });
   }
@@ -33084,17 +33128,17 @@ function createArrayBufferGlobal(budget) {
 }
 
 // packages/safe-js/src/interp/globals/data-view.ts
-var methods = Object.fromEntries(["Int8", "Uint8", "Int16", "Uint16", "Int32", "Uint32", "Float32", "Float64", "BigInt64", "BigUint64"].flatMap((type) => ["get", "set"].map((operation) => [operation + type, Object.getOwnPropertyDescriptor(DataView.prototype, operation + type).value])));
+var methods2 = Object.fromEntries(["Int8", "Uint8", "Int16", "Uint16", "Int32", "Uint32", "Float32", "Float64", "BigInt64", "BigUint64"].flatMap((type) => ["get", "set"].map((operation) => [operation + type, Object.getOwnPropertyDescriptor(DataView.prototype, operation + type).value])));
 var readUint16 = DataView.prototype.getUint16;
 var writeUint16 = DataView.prototype.setUint16;
-methods.getFloat16 = function(...args) {
+methods2.getFloat16 = function(...args) {
   const bits = Reflect.apply(readUint16, this, args);
   const sign = bits & 32768 ? -1 : 1;
   const exponent = bits >> 10 & 31, fraction = bits & 1023;
   if (exponent === 31) return fraction === 0 ? sign * Infinity : NaN;
   return sign * (exponent === 0 ? fraction * 2 ** -24 : (1 + fraction / 1024) * 2 ** (exponent - 15));
 };
-methods.setFloat16 = function(...args) {
+methods2.setFloat16 = function(...args) {
   const rounded = f16round(args[1]);
   const sign = rounded < 0 || Object.is(rounded, -0) ? 32768 : 0;
   const magnitude = Math.abs(rounded);
@@ -33166,7 +33210,7 @@ function createDataViewGlobal(budget) {
     Object.defineProperty(prototype, name, { get: accessorAdapter(closure, "get"), configurable: true });
     getters.push(closure);
   }
-  for (const [name, method] of Object.entries(methods)) {
+  for (const [name, method] of Object.entries(methods2)) {
     const setter = name.startsWith("set");
     Object.defineProperty(prototype, name, {
       writable: true,
@@ -33209,7 +33253,7 @@ async function dataViewIndex(value, budget, context) {
 // packages/safe-js/src/interp/globals/reflect.ts
 var nativeReflectPropertyNames = Object.getOwnPropertyNames(Reflect);
 function createReflectGlobal(budget) {
-  const methods2 = {
+  const methods3 = {
     ownKeys: { length: 1, call: ([target]) => {
       const properties = objectProperties(target);
       return allocateProducedSandboxValue([...Object.getOwnPropertyNames(properties), ...ownSandboxSymbolKeys(target)], budget);
@@ -33308,7 +33352,7 @@ function createReflectGlobal(budget) {
   };
   const reflect = createIntrinsicObject({});
   for (const name of nativeReflectPropertyNames) {
-    const method = methods2[name];
+    const method = methods3[name];
     if (method === void 0) continue;
     const closure = createSandboxClosure({
       guest: true,
@@ -33365,9 +33409,9 @@ function createLocaleConstructor(budget) {
   Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false, configurable: false });
   Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
   Object.defineProperty(prototype, Symbol.toStringTag, { value: "Intl.Locale", configurable: true });
-  const methods2 = ["toString", "maximize", "minimize", "getCalendars", "getCollations", "getHourCycles", "getNumberingSystems", "getTimeZones", "getTextInfo", "getWeekInfo"];
+  const methods3 = ["toString", "maximize", "minimize", "getCalendars", "getCollations", "getHourCycles", "getNumberingSystems", "getTimeZones", "getTextInfo", "getWeekInfo"];
   const getters = ["baseName", "language", "script", "region", "variants", "calendar", "collation", "firstDayOfWeek", "hourCycle", "caseFirst", "numeric", "numberingSystem"];
-  for (const name of [...methods2, ...getters]) {
+  for (const name of [...methods3, ...getters]) {
     const getter = getters.includes(name);
     const closure = createSandboxClosure({
       guest: true,
@@ -33909,10 +33953,132 @@ function createDisplayNamesConstructor(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/intl-datetimeformat.ts
+var supportedLocalesOf7 = Intl.DateTimeFormat.supportedLocalesOf;
+function createDateTimeFormatConstructor(budget, now) {
+  const prototype = createIntrinsicObject();
+  const formatTarget = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "",
+    length: 1,
+    call: async ([input], context) => {
+      dateTimeFormatState(context?.thisValue);
+      let value = 0;
+      const release = retainValues(budget, () => [context?.thisValue, value]);
+      try {
+        value = input === void 0 ? await now.call([], context) : await sandboxNumber(input, budget, context);
+        return allocateProducedSandboxValue(formatDateTimeValue(context?.thisValue, "format", [value]), budget);
+      } finally {
+        release();
+      }
+    }
+  });
+  registerBuiltinIdentities(budget, { "%DateTimeFormatFormat%": formatTarget });
+  registerIntrinsicFunction(budget, formatTarget);
+  const initialize = async ([input, options], context) => {
+    const target = context?.newTarget;
+    const selected = target === void 0 || target === constructor ? prototype : context?.getProperty !== void 0 ? await context.getProperty(target, "prototype") : await readPropertyDescriptor(getSandboxPropertyDescriptor(target, "prototype", budget) ?? { value: void 0 }, target, context);
+    let locales2 = [];
+    const release = retainValues(budget, () => [selected, locales2]);
+    try {
+      locales2 = await canonicalizeGuestLocales(input, budget, context);
+      const converted = await readDateTimeFormatOptions(options, budget, context);
+      const value = createSandboxDateTimeFormat(locales2, converted);
+      setSandboxPrototype(value, typeof selected === "object" && selected !== null ? selected : prototype, budget);
+      return allocateProducedSandboxValue(value, budget);
+    } finally {
+      release();
+    }
+  };
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "DateTimeFormat",
+    length: 0,
+    construct: initialize,
+    call: (args, context) => initialize(args, { ...context, stack: context?.stack ?? [], thisValue: context?.thisValue, newTarget: void 0 })
+  });
+  const properties = materializeFunctionProperties(constructor);
+  Object.defineProperty(properties, "prototype", { value: prototype, writable: false, configurable: false });
+  Object.defineProperty(properties, "supportedLocalesOf", { value: createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "supportedLocalesOf",
+    length: 1,
+    call: async ([input, options], context) => {
+      const locales2 = await canonicalizeGuestLocales(input, budget, context);
+      const release = retainValues(budget, () => [locales2]);
+      try {
+        const source = intlOptionsObject(options, budget);
+        const raw = await readIntlProperty(source, "localeMatcher", budget, context);
+        const matcher = raw === void 0 ? void 0 : await convertIntlOption(raw, "localeMatcher", ["lookup", "best fit"], budget, context);
+        return allocateProducedSandboxValue(supportedLocalesOf7(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.DateTimeFormat", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => allocateProducedSandboxValue({ ...dateTimeFormatState(context?.thisValue).options }, budget)
+    }), writable: true, configurable: true },
+    format: { get: accessorAdapter(createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "get format",
+      length: 0,
+      call: (_args, context) => {
+        const receiver = context?.thisValue;
+        const state = dateTimeFormatState(receiver);
+        if (state.format === void 0) {
+          state.format = createBoundFunction(
+            { target: formatTarget, thisValue: receiver, args: [] },
+            "",
+            1,
+            (target, args, stack, thisValue) => invokeBuiltinClosure(target, args, budget, { stack, thisValue }, thisValue)
+          );
+          allocateProducedSandboxValue(state.format, budget);
+        }
+        return state.format;
+      }
+    }), "get"), configurable: true }
+  });
+  for (const method of ["formatToParts", "formatRange", "formatRangeToParts"]) {
+    const range = method !== "formatToParts";
+    Object.defineProperty(prototype, method, { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: method,
+      length: range ? 2 : 1,
+      call: async ([first, second], context) => {
+        dateTimeFormatState(context?.thisValue);
+        if (range && (first === void 0 || second === void 0)) throw new TypeError("DateTimeFormat range requires both values.");
+        const values = [];
+        const release = retainValues(budget, () => [context?.thisValue, values]);
+        try {
+          values.push(!range && first === void 0 ? await now.call([], context) : await sandboxNumber(first, budget, context));
+          if (range) values.push(await sandboxNumber(second, budget, context));
+          return allocateProducedSandboxValue(formatDateTimeValue(context?.thisValue, method, values), budget);
+        } finally {
+          release();
+        }
+      }
+    }), writable: true, configurable: true });
+  }
+  return constructor;
+}
+
 // packages/safe-js/src/interp/globals/intl.ts
 var supportedValuesOf = Intl.supportedValuesOf;
-function createIntlGlobal(budget) {
-  const methods2 = {
+function createIntlGlobal(budget, now) {
+  const methods3 = {
     getCanonicalLocales: async ([locales2], context) => allocateProducedSandboxValue(await canonicalizeGuestLocales(locales2, budget, context), budget),
     supportedValuesOf: async ([key], context) => {
       const text = await sandboxString(key, budget, context);
@@ -33927,19 +34093,21 @@ function createIntlGlobal(budget) {
   const listFormat = createListFormatConstructor(budget);
   const relativeTimeFormat = createRelativeTimeFormatConstructor(budget);
   const displayNames = createDisplayNamesConstructor(budget);
+  const dateTimeFormat = createDateTimeFormatConstructor(budget, now);
   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 });
   Object.defineProperty(intl, "ListFormat", { value: listFormat, writable: true, configurable: true });
   Object.defineProperty(intl, "RelativeTimeFormat", { value: relativeTimeFormat, writable: true, configurable: true });
   Object.defineProperty(intl, "DisplayNames", { value: displayNames, writable: true, configurable: true });
-  for (const [name, call] of Object.entries(methods2)) {
+  Object.defineProperty(intl, "DateTimeFormat", { value: dateTimeFormat, 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]) {
+  for (const constructor of [locale, collator, numberFormat, listFormat, relativeTimeFormat, displayNames, dateTimeFormat]) {
     const prototype = constructor.properties.prototype;
     for (const owner of [prototype, constructor.properties])
       for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(owner)))
@@ -33947,18 +34115,19 @@ function createIntlGlobal(budget) {
           if (isSandboxClosure(closure)) registerIntrinsicFunction(budget, closure);
     registerIntrinsicObject(budget, prototype);
   }
-  for (const name of Object.keys(methods2)) registerIntrinsicFunction(budget, intl[name]);
+  for (const name of Object.keys(methods3)) registerIntrinsicFunction(budget, intl[name]);
   registerIntrinsicObject(budget, intl);
   return intl;
 }
 
 // packages/safe-js/src/interp/globals.ts
 function createBuiltinBindings(options) {
+  const date = createDateGlobal(options);
   const bindings = {
     ...createConsoleJsonGlobals(options),
     ...createCollectionGlobals(options),
     ...Object.fromEntries(Object.entries(numericTypedArrayConstructors).map(([name, Native]) => [name, createNumericTypedArrayGlobal(options.budget, options.typedArrayPrototypes !== false, Native)])),
-    Date: createDateGlobal(options),
+    Date: date,
     Symbol: createSymbolGlobal(options.budget),
     BigInt: createBigIntGlobal(options.budget),
     ...createErrorGlobals({ ...options, errorPrototypes: options.errorPrototypes !== false }),
@@ -33968,7 +34137,7 @@ function createBuiltinBindings(options) {
     DisposableStack: createDisposableStackGlobal(options.budget),
     AsyncDisposableStack: createAsyncDisposableStackGlobal(options.budget),
     Reflect: createReflectGlobal(options.budget),
-    Intl: createIntlGlobal(options.budget),
+    Intl: createIntlGlobal(options.budget, date.properties.now),
     ArrayBuffer: createArrayBufferGlobal(options.budget),
     DataView: createDataViewGlobal(options.budget),
     ...createMiscGlobals(options),
@@ -34056,7 +34225,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-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-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"]);
@@ -34325,6 +34494,21 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     fields(node, ["kind", "source", "flags", "state"]);
     if (typeof node.source !== "string" || typeof node.flags !== "string") throw new TypeError("Invalid guest RegExp payload.");
     state(node.state);
+  } else if (node.kind === "guest-datetimeformat") {
+    fields(node, ["kind", "options", "state"], ["format"]);
+    const options = record2(node.options);
+    fields(options, ["locale", "calendar", "numberingSystem", "timeZone"], ["hourCycle", "hour12", "weekday", "era", "year", "month", "day", "dayPeriod", "hour", "minute", "second", "fractionalSecondDigits", "timeZoneName", "dateStyle", "timeStyle"]);
+    if (typeof options.locale !== "string" || Object.values(options).some((value) => !["string", "number", "boolean"].includes(typeof value)))
+      throw new TypeError("Invalid DateTimeFormat option type.");
+    const restored = dateTimeFormatState(createSandboxDateTimeFormat(options.locale, options, true)).options;
+    if (Object.keys(options).length !== Object.keys(restored).length || Object.keys(restored).some((key) => options[key] !== restored[key]))
+      throw new TypeError("Invalid resolved DateTimeFormat options.");
+    if (node.format !== void 0) {
+      const format4 = reference(node.format, ["bound-function"]);
+      if (reference(format4.thisValue) !== node || array(format4.args).length !== 0 || format4.name !== "" || format4.length !== 1 || reference(format4.target, ["intrinsic"]).id !== '["%DateTimeFormatFormat%"]')
+        throw new TypeError("Invalid cached DateTimeFormat function.");
+    }
+    state(node.state);
   } else if (node.kind === "guest-numberformat") {
     fields(node, ["kind", "options", "state"], ["format"]);
     const options = record2(node.options);
@@ -34335,8 +34519,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     if (Object.keys(options).length !== Object.keys(restored).length || Object.keys(restored).some((key) => options[key] !== restored[key]))
       throw new TypeError("Invalid resolved NumberFormat options.");
     if (node.format !== void 0) {
-      const format3 = reference(node.format, ["bound-function"]);
-      if (reference(format3.thisValue) !== node || array(format3.args).length !== 0 || format3.name !== "" || format3.length !== 1 || reference(format3.target, ["intrinsic"]).id !== '["%NumberFormatFormat%"]')
+      const format4 = reference(node.format, ["bound-function"]);
+      if (reference(format4.thisValue) !== node || array(format4.args).length !== 0 || format4.name !== "" || format4.length !== 1 || reference(format4.target, ["intrinsic"]).id !== '["%NumberFormatFormat%"]')
         throw new TypeError("Invalid cached NumberFormat function.");
     }
     state(node.state);
@@ -38130,6 +38314,11 @@ function measureSandboxData(values, options = {}) {
       visit(state.options, depth + 1);
       visit(state.format, depth + 1);
     }
+    if (isSandboxDateTimeFormat(value)) {
+      const state = dateTimeFormatState(value);
+      visit(state.options, depth + 1);
+      visit(state.format, depth + 1);
+    }
     if (isSandboxCollator(value)) {
       const state = collatorState(value);
       visit(state.options, depth + 1);
@@ -56110,4 +56299,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-OXTOMAYL.js.map
+//# sourceMappingURL=chunk-GPAQUL2B.js.map