@poe-platform/safe-js 0.1.454 → 0.1.456

package/dist/safe-js/chunks/{chunk-IOBAVJXI.js → chunk-ENQTGOQ6.js}

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

package/dist/safe-js/chunks/{chunk-GYKATDHU.js → chunk-NC5GGOCN.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) };
@@ -30729,6 +30752,91 @@ function defineDataProperty2(target, key, value) {
   });
 }
 
+// packages/safe-js/src/interp/globals/set-operations.ts
+var setOperationNames = ["union", "intersection", "difference", "symmetricDifference", "isSubsetOf", "isSupersetOf", "isDisjointFrom"];
+function createSetOperation(name, budget) {
+  return createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name,
+    length: 1,
+    call: async ([other], context) => {
+      const receiver = context?.thisValue;
+      if (!isSandboxSet(receiver)) throw new TypeError(`Set.prototype.${name} requires a Set receiver.`);
+      if (typeof other !== "object" || other === null) throw new TypeError("Expected a set-like object.");
+      const read = async (object, key) => context?.getProperty !== void 0 ? context.getProperty(object, key) : readPropertyDescriptor(getSandboxPropertyDescriptor(object, key, budget) ?? { value: void 0 }, object, context);
+      const iterationContext = { ...context, thisValue: receiver, stack: context?.stack ?? [], getProperty: read };
+      const result = createSandboxSet([]);
+      let iterator;
+      let current;
+      let has;
+      let keys;
+      const release = retainValues(budget, () => [receiver, other, result, current, has, keys, iterator?.retainedValue]);
+      const checkpoint = createDataCheckpoint(budget, context);
+      const add = (value) => {
+        budget.visitNode();
+        if (result.values.has(value)) return;
+        budget.allocateCollectionEntries(result.values.size + 1);
+        result.values.add(value);
+        checkpoint(result, 1 + (budget.limits.dataSize === void 0 ? 0 : measureSandboxData([value])));
+      };
+      try {
+        const numericSize = await sandboxNumber(await read(other, "size"), budget, context);
+        if (Number.isNaN(numericSize)) throw new TypeError("Invalid set-like size.");
+        const size = Math.trunc(numericSize);
+        if (size < 0) throw new RangeError("Negative set-like size.");
+        has = await read(other, "has");
+        if (!isSandboxClosure(has)) throw new TypeError("Set-like has must be callable.");
+        keys = await read(other, "keys");
+        if (!isSandboxClosure(keys)) throw new TypeError("Set-like keys must be callable.");
+        if (name === "isSubsetOf" && receiver.values.size > size || name === "isSupersetOf" && receiver.values.size < size) return false;
+        const visitReceiver = name === "isSubsetOf" || (name === "intersection" || name === "difference" || name === "isDisjointFrom") && receiver.values.size <= size;
+        if (name === "union" || name === "symmetricDifference")
+          iterator = await getSandboxIteratorFromMethod(other, keys, budget, iterationContext);
+        if (name === "union" || name === "symmetricDifference" || name === "difference")
+          for (const value of receiver.values) add(value);
+        if (visitReceiver) {
+          const target = name === "difference" ? result : receiver;
+          const cursor = enterKeyedCollectionCallback(target, target.values, budget);
+          try {
+            for (let next = cursor.next(); !next.done; next = cursor.next()) {
+              current = next.value;
+              const found = Boolean(await invokeBuiltinClosure(has, [current], budget, context, other));
+              if (name === "isSubsetOf" && !found || name === "isDisjointFrom" && found) return false;
+              if (name === "intersection" && found) add(current);
+              if (name === "difference" && found) result.values.delete(current);
+              current = void 0;
+            }
+          } finally {
+            cursor.leave();
+          }
+        } else {
+          iterator ??= await getSandboxIteratorFromMethod(other, keys, budget, iterationContext);
+          while (true) {
+            budget.visitNode();
+            const next = await iterator.next();
+            if ((await readIteratorResult(iterator, next, "done")).value) break;
+            current = (await readIteratorResult(iterator, next, "value")).value;
+            const found = receiver.values.has(current);
+            if (name === "isSupersetOf" && !found || name === "isDisjointFrom" && found) {
+              await closeIterator(iterator);
+              return false;
+            }
+            if (name === "union" || name === "intersection" && found || name === "symmetricDifference" && !found) add(current);
+            else if (name === "difference" || name === "symmetricDifference" && found) result.values.delete(current);
+            current = void 0;
+          }
+        }
+        if (name === "isSubsetOf" || name === "isSupersetOf" || name === "isDisjointFrom") return true;
+        checkpoint(result, 0, true);
+        return allocateProducedSandboxValue(result, budget);
+      } finally {
+        release();
+      }
+    }
+  });
+}
+
 // packages/safe-js/src/interp/globals/collection-prototypes.ts
 function installCollectionPrototypes(budget, mapConstructor, setConstructor) {
   const mapMethods = Object.fromEntries([...mapMethodNames].map((name) => [name, createSandboxClosure({
@@ -30760,6 +30868,7 @@ function installCollectionPrototypes(budget, mapConstructor, setConstructor) {
     }
   })]));
   setMethods.keys = setMethods.values;
+  for (const name of setOperationNames) setMethods[name] = createSetOperation(name, budget);
   const mapSize = createSandboxClosure({
     guest: true,
     sandbox: true,
@@ -33706,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) {
@@ -33723,11 +33926,13 @@ 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 });
@@ -33851,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"]);
@@ -34144,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);
@@ -37910,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);
@@ -55895,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-GYKATDHU.js.map
+//# sourceMappingURL=chunk-NC5GGOCN.js.map