@poe-platform/safe-js 0.1.451 → 0.1.452

package/dist/safe-js/chunks/{chunk-YIPIBBVN.js → chunk-6WDZNRKU.js}

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

package/dist/safe-js/chunks/{chunk-7OZYVM5K.js → chunk-GJPSM3AB.js}

@@ -28545,7 +28545,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 optionTypes2 = [
+  const optionTypes3 = [
     ["calendar", "ca", "unicodeType"],
     ["collation", "co", "unicodeType"],
     ["firstDayOfWeek", "fw", "unicodeType"],
@@ -28554,7 +28554,7 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
     ["numeric", "kn", "boolean"],
     ["numberingSystem", "nu", "unicodeType"]
   ];
-  for (const [key, extensionKey, type] of optionTypes2) {
+  for (const [key, extensionKey, type] of optionTypes3) {
     let value = await readIntlProperty(options, key, budget, context);
     if (value === void 0) continue;
     if (key === "firstDayOfWeek") {
@@ -28574,20 +28574,43 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
   return budget.allocateString(Reflect.apply(nativeToString, result, []));
 }
 
-// packages/safe-js/src/interp/intl-numberformat.ts
+// packages/safe-js/src/interp/intl-listformat.ts
+var NativeListFormat = Intl.ListFormat;
+var resolvedOptions2 = NativeListFormat.prototype.resolvedOptions;
+var format = NativeListFormat.prototype.format;
+var formatToParts2 = NativeListFormat.prototype.formatToParts;
 var states6 = /* @__PURE__ */ new WeakMap();
+function createSandboxListFormat(locales2, options) {
+  const native = new NativeListFormat(locales2, options);
+  const value = /* @__PURE__ */ Object.create(null);
+  states6.set(value, { native, options: Reflect.apply(resolvedOptions2, native, []) });
+  return value;
+}
+function isSandboxListFormat(value) {
+  return typeof value === "object" && value !== null && states6.has(value);
+}
+function listFormatState(value) {
+  if (!isSandboxListFormat(value)) throw new TypeError("Intl.ListFormat requires a ListFormat receiver.");
+  return states6.get(value);
+}
+function formatList(value, strings, parts) {
+  return Reflect.apply(parts ? formatToParts2 : format, listFormatState(value).native, [strings]);
+}
+
+// packages/safe-js/src/interp/intl-numberformat.ts
+var states7 = /* @__PURE__ */ new WeakMap();
 function createSandboxNumberFormat(locales2, options) {
   const native = createNumberFormatter(locales2, options);
   const value = /* @__PURE__ */ Object.create(null);
-  states6.set(value, { native, options: numberFormatterOptions2(native) });
+  states7.set(value, { native, options: numberFormatterOptions2(native) });
   return value;
 }
 function isSandboxNumberFormat(value) {
-  return typeof value === "object" && value !== null && states6.has(value);
+  return typeof value === "object" && value !== null && states7.has(value);
 }
 function numberFormatState(value) {
   if (!isSandboxNumberFormat(value)) throw new TypeError("Intl.NumberFormat requires a NumberFormat receiver.");
-  return states6.get(value);
+  return states7.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;
@@ -28941,9 +28964,10 @@ function captureGuestHeapNode(value, encode) {
     return void 0;
   }
   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 (isSandboxNumberFormat(value)) {
-    const { options, format } = numberFormatState(value);
-    return { kind: "guest-numberformat", options: { ...options }, ...format === void 0 ? {} : { format: encode(format) }, state: captureObjectState(value, encode) };
+    const { options, format: format2 } = numberFormatState(value);
+    return { kind: "guest-numberformat", options: { ...options }, ...format2 === void 0 ? {} : { format: encode(format2) }, state: captureObjectState(value, encode) };
   }
   if (isSandboxCollator(value)) {
     const { options, compare } = collatorState(value);
@@ -33374,6 +33398,117 @@ function createNumberFormatConstructor(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/intl-listformat.ts
+var supportedLocalesOf4 = Intl.ListFormat.supportedLocalesOf;
+var optionTypes2 = [
+  ["localeMatcher", ["lookup", "best fit"]],
+  ["type", ["conjunction", "disjunction", "unit"]],
+  ["style", ["long", "short", "narrow"]]
+];
+function createListFormatConstructor(budget) {
+  const prototype = createIntrinsicObject();
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "ListFormat",
+    length: 0,
+    call: () => {
+      throw new TypeError("Constructor ListFormat 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);
+        const source = intlOptionsObject(options, budget);
+        for (const [key, type] of optionTypes2) {
+          const raw = await readIntlProperty(source, key, budget, context);
+          if (raw !== void 0) converted[key] = await convertIntlOption(raw, key, type, budget, context);
+        }
+        const value = createSandboxListFormat(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(supportedLocalesOf4(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.ListFormat", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => allocateProducedSandboxValue({ ...listFormatState(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;
+        listFormatState(receiver);
+        const strings = [];
+        let iterator;
+        const release = retainValues(budget, () => [receiver, strings, iterator?.retainedValue]);
+        const checkpoint = createDataCheckpoint(budget, context);
+        try {
+          if (input !== void 0) {
+            iterator = context === void 0 ? getSandboxIterator(input, budget) : await acquireSandboxIterator(input, budget, context);
+            if (iterator === void 0) throw new TypeError("ListFormat requires an iterable.");
+            while (true) {
+              budget.visitNode();
+              const result = await iterator.next();
+              if ((await readIteratorResult(iterator, result, "done")).value) break;
+              const value = (await readIteratorResult(iterator, result, "value")).value;
+              if (typeof value !== "string") {
+                await closeIterator(iterator, true);
+                throw new TypeError("ListFormat requires string elements.");
+              }
+              budget.visitNode(value.length);
+              budget.allocateArrayLength(strings.length + 1);
+              strings.push(value);
+              checkpoint(strings, value.length + 1);
+            }
+          }
+          return allocateProducedSandboxValue(formatList(receiver, strings, method === "formatToParts"), budget);
+        } finally {
+          release();
+        }
+      }
+    }), writable: true, configurable: true });
+  }
+  return constructor;
+}
+
 // packages/safe-js/src/interp/globals/intl.ts
 var supportedValuesOf = Intl.supportedValuesOf;
 function createIntlGlobal(budget) {
@@ -33389,16 +33524,18 @@ function createIntlGlobal(budget) {
   const locale = createLocaleConstructor(budget);
   const collator = createCollatorConstructor(budget);
   const numberFormat = createNumberFormatConstructor(budget);
+  const listFormat = createListFormatConstructor(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 });
   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]) {
+  for (const constructor of [locale, collator, numberFormat, listFormat]) {
     const prototype = constructor.properties.prototype;
     for (const owner of [prototype, constructor.properties])
       for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(owner)))
@@ -33515,7 +33652,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-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-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"]);
@@ -33794,11 +33931,20 @@ 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 format = reference(node.format, ["bound-function"]);
-      if (reference(format.thisValue) !== node || array(format.args).length !== 0 || format.name !== "" || format.length !== 1 || reference(format.target, ["intrinsic"]).id !== '["%NumberFormatFormat%"]')
+      const format2 = reference(node.format, ["bound-function"]);
+      if (reference(format2.thisValue) !== node || array(format2.args).length !== 0 || format2.name !== "" || format2.length !== 1 || reference(format2.target, ["intrinsic"]).id !== '["%NumberFormatFormat%"]')
         throw new TypeError("Invalid cached NumberFormat function.");
     }
     state(node.state);
+  } else if (node.kind === "guest-listformat") {
+    fields(node, ["kind", "options", "state"]);
+    const options = record2(node.options);
+    const names = ["locale", "type", "style"];
+    fields(options, [...names]);
+    if (names.some((key) => typeof options[key] !== "string")) throw new TypeError("Invalid ListFormat option type.");
+    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-collator") {
     fields(node, ["kind", "options", "state"], ["compare"]);
     const options = record2(node.options);
@@ -37554,6 +37700,7 @@ function measureSandboxData(values, options = {}) {
     }
     if (isSandboxDate(value)) usage += 8;
     if (isSandboxLocale(value)) usage += localeTag(value).length;
+    if (isSandboxListFormat(value)) visit(listFormatState(value).options, depth + 1);
     if (isSandboxNumberFormat(value)) {
       const state = numberFormatState(value);
       visit(state.options, depth + 1);
@@ -55539,4 +55686,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-7OZYVM5K.js.map
+//# sourceMappingURL=chunk-GJPSM3AB.js.map