@poe-platform/safe-js 0.1.455 → 0.1.457

package/dist/safe-js/chunks/{chunk-JB2Z6L3C.js → chunk-ENSU5YTC.js}

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

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

@@ -28619,7 +28619,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 optionTypes4 = [
+  const optionTypes5 = [
     ["calendar", "ca", "unicodeType"],
     ["collation", "co", "unicodeType"],
     ["firstDayOfWeek", "fw", "unicodeType"],
@@ -28628,7 +28628,7 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
     ["numeric", "kn", "boolean"],
     ["numberingSystem", "nu", "unicodeType"]
   ];
-  for (const [key, extensionKey, type] of optionTypes4) {
+  for (const [key, extensionKey, type] of optionTypes5) {
     let value = await readIntlProperty(options, key, budget, context);
     if (value === void 0) continue;
     if (key === "firstDayOfWeek") {
@@ -28694,20 +28694,42 @@ function formatRelativeTime(value, amount, unit, parts) {
   return Reflect.apply(parts ? formatToParts3 : format2, relativeTimeFormatState(value).native, [amount, unit]);
 }
 
-// packages/safe-js/src/interp/intl-numberformat.ts
+// packages/safe-js/src/interp/intl-displaynames.ts
+var NativeDisplayNames = Intl.DisplayNames;
+var resolvedOptions4 = NativeDisplayNames.prototype.resolvedOptions;
+var of = NativeDisplayNames.prototype.of;
 var states8 = /* @__PURE__ */ new WeakMap();
+function createSandboxDisplayNames(locales2, options) {
+  const native = new NativeDisplayNames(locales2, options);
+  const value = /* @__PURE__ */ Object.create(null);
+  states8.set(value, { native, options: Reflect.apply(resolvedOptions4, native, []) });
+  return value;
+}
+function isSandboxDisplayNames(value) {
+  return typeof value === "object" && value !== null && states8.has(value);
+}
+function displayNamesState(value) {
+  if (!isSandboxDisplayNames(value)) throw new TypeError("Intl.DisplayNames requires a DisplayNames receiver.");
+  return states8.get(value);
+}
+function displayName(value, code) {
+  return Reflect.apply(of, displayNamesState(value).native, [code]);
+}
+
+// packages/safe-js/src/interp/intl-numberformat.ts
+var states9 = /* @__PURE__ */ new WeakMap();
 function createSandboxNumberFormat(locales2, options) {
   const native = createNumberFormatter(locales2, options);
   const value = /* @__PURE__ */ Object.create(null);
-  states8.set(value, { native, options: numberFormatterOptions2(native) });
+  states9.set(value, { native, options: numberFormatterOptions2(native) });
   return value;
 }
 function isSandboxNumberFormat(value) {
-  return typeof value === "object" && value !== null && states8.has(value);
+  return typeof value === "object" && value !== null && states9.has(value);
 }
 function numberFormatState(value) {
   if (!isSandboxNumberFormat(value)) throw new TypeError("Intl.NumberFormat requires a NumberFormat receiver.");
-  return states8.get(value);
+  return states9.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;
@@ -29063,6 +29085,7 @@ 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 (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 (isSandboxNumberFormat(value)) {
     const { options, format: format3 } = numberFormatState(value);
     return { kind: "guest-numberformat", options: { ...options }, ...format3 === void 0 ? {} : { format: encode(format3) }, state: captureObjectState(value, encode) };
@@ -33792,6 +33815,100 @@ function createRelativeTimeFormatConstructor(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/intl-displaynames.ts
+var supportedLocalesOf6 = Intl.DisplayNames.supportedLocalesOf;
+var optionTypes4 = [
+  ["localeMatcher", ["lookup", "best fit"]],
+  ["style", ["long", "short", "narrow"]],
+  ["type", ["language", "region", "script", "currency", "calendar", "dateTimeField"]],
+  ["fallback", ["code", "none"]],
+  ["languageDisplay", ["dialect", "standard"]]
+];
+function createDisplayNamesConstructor(budget) {
+  const prototype = createIntrinsicObject();
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "DisplayNames",
+    length: 2,
+    call: () => {
+      throw new TypeError("Constructor DisplayNames 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);
+        if (options === void 0) throw new TypeError("DisplayNames requires options.");
+        const source = intlOptionsObject(options, budget);
+        for (const [key, type] of optionTypes4) {
+          const raw = await readIntlProperty(source, key, budget, context);
+          if (key === "type" && raw === void 0) throw new TypeError("DisplayNames requires a type.");
+          if (raw !== void 0) converted[key] = await convertIntlOption(raw, key, type, budget, context);
+        }
+        const value = createSandboxDisplayNames(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(supportedLocalesOf6(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.DisplayNames", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => allocateProducedSandboxValue({ ...displayNamesState(context?.thisValue).options }, budget)
+    }), writable: true, configurable: true }
+  });
+  Object.defineProperty(prototype, "of", { value: createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "of",
+    length: 1,
+    call: async ([input], context) => {
+      const receiver = context?.thisValue;
+      displayNamesState(receiver);
+      const release = retainValues(budget, () => [receiver, input]);
+      try {
+        const code = await sandboxString(input, budget, context);
+        budget.visitNode(code.length);
+        return allocateProducedSandboxValue(displayName(receiver, code), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  return constructor;
+}
+
 // packages/safe-js/src/interp/globals/intl.ts
 var supportedValuesOf = Intl.supportedValuesOf;
 function createIntlGlobal(budget) {
@@ -33809,18 +33926,20 @@ function createIntlGlobal(budget) {
   const numberFormat = createNumberFormatConstructor(budget);
   const listFormat = createListFormatConstructor(budget);
   const relativeTimeFormat = createRelativeTimeFormatConstructor(budget);
+  const displayNames = createDisplayNamesConstructor(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 });
   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)) {
     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]) {
+  for (const constructor of [locale, collator, numberFormat, listFormat, relativeTimeFormat, displayNames]) {
     const prototype = constructor.properties.prototype;
     for (const owner of [prototype, constructor.properties])
       for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(owner)))
@@ -33937,7 +34056,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-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-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"]);
@@ -34230,6 +34349,15 @@ 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-displaynames") {
+    fields(node, ["kind", "options", "state"]);
+    const options = record2(node.options);
+    fields(options, ["locale", "style", "type", "fallback"], ["languageDisplay"]);
+    if (Object.values(options).some((value) => typeof value !== "string")) throw new TypeError("Invalid DisplayNames option type.");
+    const restored = displayNamesState(createSandboxDisplayNames(options.locale, options)).options;
+    if (Object.keys(options).length !== Object.keys(restored).length || Object.keys(restored).some((key) => options[key] !== restored[key]))
+      throw new TypeError("Invalid resolved DisplayNames options.");
+    state(node.state);
   } else if (node.kind === "guest-relativetimeformat") {
     fields(node, ["kind", "options", "state"]);
     const options = record2(node.options);
@@ -37996,6 +38124,7 @@ function measureSandboxData(values, options = {}) {
     if (isSandboxLocale(value)) usage += localeTag(value).length;
     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 (isSandboxNumberFormat(value)) {
       const state = numberFormatState(value);
       visit(state.options, depth + 1);
@@ -55981,4 +56110,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-TZUXEKIQ.js.map
+//# sourceMappingURL=chunk-OXTOMAYL.js.map