@poe-platform/safe-js 0.1.288 → 0.1.290

package/README.md

@@ -103,8 +103,6 @@ Current-time reads are recorded for replay; replay does not call `now()` again.
 
 Date values copy by value across host bindings, preserving aliases within a graph. Checkpoints preserve epoch values, invalid dates and mutations rather than converting dates to strings. Parsing is limited to 4,096 characters and consumes the work/string budgets; retained values consume data budget. Local methods and non-ISO parsing follow the host timezone/runtime, so use explicit-zone ISO strings and UTC methods for portable output.
 
-Unsupported: locale formatting, legacy `getYear`/`setYear`/`toGMTString`, subclassing, custom argument coercion, Date-instance own properties and prototype modification. These are restrictions, not stubs; no native constructor or prototype is exposed to guest code.
-
 </details>
 
 ## Add a host capability

package/dist/safe-js/chunks/{chunk-K45MDTVS.js → chunk-GK6XA4H4.js}

@@ -6966,6 +6966,9 @@ var methodNames = [
   "setUTCSeconds",
   "toDateString",
   "toISOString",
+  "toLocaleString",
+  "toLocaleDateString",
+  "toLocaleTimeString",
   "toString",
   "toTimeString",
   "toUTCString",
@@ -10498,6 +10501,96 @@ function formatNumber(value, methodName, argument, budget) {
 
 // packages/safe-js/src/interp/methods/string.ts
 import { types as types5 } from "node:util";
+
+// packages/safe-js/src/interp/intl-options.ts
+var canonicalLocales = Intl.getCanonicalLocales;
+function readIntlProperty(value, key, budget, context) {
+  budget.visitNode();
+  if (context?.getProperty !== void 0) return context.getProperty(value, key);
+  const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+  return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+}
+function intlOptionsObject(value, budget) {
+  if (value === void 0) return /* @__PURE__ */ Object.create(null);
+  if (value === null) throw new TypeError("Cannot convert null to an object.");
+  if (typeof value === "object") return value;
+  const box = createSandboxBox(value);
+  allocateProducedSandboxValue(box, budget);
+  return box;
+}
+async function canonicalizeGuestLocales(input, budget, context) {
+  const locales = [];
+  if (input === void 0) return locales;
+  if (input === null) return Reflect.apply(canonicalLocales, Intl, [input]);
+  const release = retainValues(budget, () => [locales]);
+  try {
+    const list2 = typeof input === "string" ? [input] : intlOptionsObject(input, budget);
+    const count = await sandboxNumber(await readIntlProperty(list2, "length", budget, context), budget, context);
+    const length = Number.isNaN(count) || count <= 0 ? 0 : Math.min(Math.floor(count), Number.MAX_SAFE_INTEGER);
+    for (let index = 0; index < length; index++) {
+      budget.visitNode();
+      const key = String(index);
+      if (getSandboxPropertyDescriptor(list2, key, budget) === void 0 && !(isFloat32Array(list2) && Object.hasOwn(list2, key))) continue;
+      const value = await readIntlProperty(list2, key, budget, context);
+      if (typeof value !== "string" && (typeof value !== "object" || value === null))
+        return Reflect.apply(canonicalLocales, Intl, [[value]]);
+      const tag = await sandboxString(value, budget, context);
+      budget.visitNode(tag.length);
+      const canonical = canonicalLocales(tag)[0];
+      budget.visitNode(locales.length);
+      if (!locales.includes(canonical)) locales.push(budget.allocateString(canonical));
+    }
+    return locales;
+  } finally {
+    release();
+  }
+}
+async function convertIntlOption(value, key, type, budget, context, invalid) {
+  if (type === "boolean") return Boolean(value);
+  const text = await sandboxString(value, budget, context);
+  budget.visitNode(text.length);
+  if (type === "unicodeType") {
+    const valid = text.split("-").every((part) => part.length >= 3 && part.length <= 8 && [...part].every((char) => char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9"));
+    if (valid) return text;
+  } else if (type.includes(text)) return text;
+  invalid?.(text);
+  throw new RangeError(`Invalid ${key} option.`);
+}
+
+// packages/safe-js/src/interp/methods/string-locale.ts
+var collatorOptions = [
+  ["usage", ["sort", "search"]],
+  ["localeMatcher", ["lookup", "best fit"]],
+  ["collation", "unicodeType"],
+  ["numeric", "boolean"],
+  ["caseFirst", ["upper", "lower", "false"]],
+  ["sensitivity", ["base", "accent", "case", "variant"]],
+  ["ignorePunctuation", "boolean"]
+];
+async function compareStringLocale(value, args, budget, context) {
+  let comparison = "";
+  let locales = [];
+  const options = /* @__PURE__ */ Object.create(null);
+  const release = retainValues(budget, () => [value, comparison, locales, options]);
+  try {
+    comparison = await sandboxString(args[0], budget, context);
+    locales = await canonicalizeGuestLocales(args[1], budget, context);
+    if (args[2] === null) return Reflect.apply(String.prototype.localeCompare, value, [comparison, locales, null]);
+    const inputOptions = intlOptionsObject(args[2], budget);
+    for (const [key, type] of collatorOptions) {
+      const option = await readIntlProperty(inputOptions, key, budget, context);
+      if (option !== void 0) options[key] = await convertIntlOption(option, key, type, budget, context, (text) => {
+        Reflect.apply(String.prototype.localeCompare, "", ["", [], { [key]: text }]);
+      });
+    }
+    budget.visitNode(value.length + comparison.length);
+    return Reflect.apply(String.prototype.localeCompare, value, [comparison, locales, options]);
+  } finally {
+    release();
+  }
+}
+
+// packages/safe-js/src/interp/methods/string.ts
 var stringMethodNames = /* @__PURE__ */ new Set([
   "at",
   "charAt",
@@ -10682,6 +10775,8 @@ function callStringMethodBody(value, methodName, args, budget, parent, context)
   if ((methodName === "match" || methodName === "matchAll" || methodName === "search") && !isSandboxRegex(args[0])) {
     return callStringPattern(value, methodName, args[0], budget, parent, context);
   }
+  if (methodName === "localeCompare" && context?.getProperty !== void 0)
+    return compareStringLocale(value, args, budget, context);
   const operation = budget.acquireCompileOwner(false, parent?.owner);
   const compilation = new CompileScope(operation.owner);
   try {
@@ -20366,6 +20461,73 @@ async function parseJsonWithReviver(text, reviver, budget, context) {
   }
 }
 
+// packages/safe-js/src/interp/date-locale.ts
+var NativeDateTimeFormat = Intl.DateTimeFormat;
+var dateTimeOptions = [
+  ["localeMatcher", ["lookup", "best fit"]],
+  ["calendar", "unicodeType"],
+  ["numberingSystem", "unicodeType"],
+  ["hour12", "boolean"],
+  ["hourCycle", ["h11", "h12", "h23", "h24"]],
+  ["timeZone", "zone"],
+  ["weekday", ["narrow", "short", "long"]],
+  ["era", ["narrow", "short", "long"]],
+  ["year", ["2-digit", "numeric"]],
+  ["month", ["2-digit", "numeric", "narrow", "short", "long"]],
+  ["day", ["2-digit", "numeric"]],
+  ["dayPeriod", ["narrow", "short", "long"]],
+  ["hour", ["2-digit", "numeric"]],
+  ["minute", ["2-digit", "numeric"]],
+  ["second", ["2-digit", "numeric"]],
+  ["fractionalSecondDigits", "number"],
+  ["timeZoneName", ["short", "long", "shortOffset", "longOffset", "shortGeneric", "longGeneric"]],
+  ["formatMatcher", ["basic", "best fit"]],
+  ["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 locales = [];
+  const options = /* @__PURE__ */ Object.create(null);
+  const release = retainValues(budget, () => [locales, options]);
+  try {
+    locales = await canonicalizeGuestLocales(args[0], budget, context);
+    const inputOptions = intlOptionsObject(args[1], budget);
+    for (const [key, type] of dateTimeOptions) {
+      const value = await readIntlProperty(inputOptions, key, budget, context);
+      if (value === void 0) continue;
+      if (type === "number") {
+        const number = await sandboxNumber(value, budget, context);
+        if (!Number.isFinite(number) || number < 1 || number > 3)
+          throw new RangeError("fractionalSecondDigits must be between 1 and 3.");
+        options[key] = Math.floor(number);
+      } else if (type === "zone") {
+        const text = await sandboxString(value, budget, context);
+        budget.visitNode(text.length);
+        new NativeDateTimeFormat("en", { timeZone: text });
+        options[key] = text;
+      } else options[key] = await convertIntlOption(value, key, type, budget, context);
+    }
+    const date = name !== "toLocaleTimeString";
+    const clock = name !== "toLocaleDateString";
+    if (options.dateStyle !== void 0 || options.timeStyle !== void 0) {
+      if (!date && options.dateStyle !== void 0 || !clock && options.timeStyle !== void 0)
+        throw new TypeError("Date/time style is incompatible with this locale method.");
+    } else {
+      const hasDate = date && ["weekday", "year", "month", "day"].some((key) => options[key] !== void 0);
+      const hasTime = clock && ["dayPeriod", "hour", "minute", "second", "fractionalSecondDigits"].some((key) => options[key] !== void 0);
+      if (!hasDate && !hasTime) {
+        if (date) for (const key of ["year", "month", "day"]) options[key] = "numeric";
+        if (clock) for (const key of ["hour", "minute", "second"]) options[key] = "numeric";
+      }
+    }
+    const formatter = new NativeDateTimeFormat(locales, options);
+    return budget.allocateString(formatter.format(time));
+  } finally {
+    release();
+  }
+}
+
 // packages/safe-js/src/snapshot/replay-data.ts
 var MissingReplayCapabilityError = class extends TypeError {
 };
@@ -21943,6 +22105,7 @@ function createDateGlobal(options) {
           if (!isSandboxDate(receiver))
             throw new TypeError(`Date#${name} requires a Date receiver.`);
           options.budget.visitNode();
+          if (name.startsWith("toLocale")) return formatDateLocale(name, dateTime(receiver), args, options.budget, context);
           if (name.startsWith("set")) return coerceDateSetter(name, receiver, args, options.budget, context);
           const value = method.invoke(receiver, args);
           return typeof value === "string" ? options.budget.allocateString(value) : value;
@@ -40340,4 +40503,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-K45MDTVS.js.map
+//# sourceMappingURL=chunk-GK6XA4H4.js.map