@poe-platform/safe-js 0.1.451 → 0.1.453

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

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-7OZYVM5K.js";
+} from "./chunk-E2VDSNJC.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-CEBPHXBL.js.map

package/dist/safe-js/chunks/{chunk-7OZYVM5K.js → chunk-E2VDSNJC.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 optionTypes4 = [
     ["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 optionTypes4) {
     let value = await readIntlProperty(options, key, budget, context);
     if (value === void 0) continue;
     if (key === "firstDayOfWeek") {
@@ -28574,20 +28574,66 @@ 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-relativetimeformat.ts
+var NativeRelativeTimeFormat = Intl.RelativeTimeFormat;
+var resolvedOptions3 = NativeRelativeTimeFormat.prototype.resolvedOptions;
+var format2 = NativeRelativeTimeFormat.prototype.format;
+var formatToParts3 = NativeRelativeTimeFormat.prototype.formatToParts;
+var states7 = /* @__PURE__ */ new WeakMap();
+function createSandboxRelativeTimeFormat(locales2, options) {
+  const native = new NativeRelativeTimeFormat(locales2, options);
+  const value = /* @__PURE__ */ Object.create(null);
+  states7.set(value, { native, options: Reflect.apply(resolvedOptions3, native, []) });
+  return value;
+}
+function isSandboxRelativeTimeFormat(value) {
+  return typeof value === "object" && value !== null && states7.has(value);
+}
+function relativeTimeFormatState(value) {
+  if (!isSandboxRelativeTimeFormat(value)) throw new TypeError("Intl.RelativeTimeFormat requires a RelativeTimeFormat receiver.");
+  return states7.get(value);
+}
+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
+var states8 = /* @__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) });
+  states8.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 && states8.has(value);
 }
 function numberFormatState(value) {
   if (!isSandboxNumberFormat(value)) throw new TypeError("Intl.NumberFormat requires a NumberFormat receiver.");
-  return states6.get(value);
+  return states8.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 +28987,11 @@ 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 (isSandboxRelativeTimeFormat(value)) return { kind: "guest-relativetimeformat", options: { ...relativeTimeFormatState(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: format3 } = numberFormatState(value);
+    return { kind: "guest-numberformat", options: { ...options }, ...format3 === void 0 ? {} : { format: encode(format3) }, state: captureObjectState(value, encode) };
   }
   if (isSandboxCollator(value)) {
     const { options, compare } = collatorState(value);
@@ -33374,6 +33422,211 @@ 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-relativetimeformat.ts
+var supportedLocalesOf5 = Intl.RelativeTimeFormat.supportedLocalesOf;
+var optionTypes3 = [
+  ["localeMatcher", ["lookup", "best fit"]],
+  ["numberingSystem", "unicodeType"],
+  ["style", ["long", "short", "narrow"]],
+  ["numeric", ["always", "auto"]]
+];
+function createRelativeTimeFormatConstructor(budget) {
+  const prototype = createIntrinsicObject();
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "RelativeTimeFormat",
+    length: 0,
+    call: () => {
+      throw new TypeError("Constructor RelativeTimeFormat 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 optionTypes3) {
+          const raw = await readIntlProperty(source, key, budget, context);
+          if (raw !== void 0) converted[key] = await convertIntlOption(raw, key, type, budget, context);
+        }
+        const value = createSandboxRelativeTimeFormat(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(supportedLocalesOf5(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.RelativeTimeFormat", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => allocateProducedSandboxValue({ ...relativeTimeFormatState(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: 2,
+      call: async ([input, unit], context) => {
+        const receiver = context?.thisValue;
+        relativeTimeFormatState(receiver);
+        const release = retainValues(budget, () => [receiver, input, unit]);
+        try {
+          const value = await sandboxNumber(input, budget, context);
+          const convertedUnit = await sandboxString(unit, budget, context);
+          budget.visitNode(convertedUnit.length);
+          return allocateProducedSandboxValue(formatRelativeTime(receiver, value, convertedUnit, 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 +33642,20 @@ function createIntlGlobal(budget) {
   const locale = createLocaleConstructor(budget);
   const collator = createCollatorConstructor(budget);
   const numberFormat = createNumberFormatConstructor(budget);
+  const listFormat = createListFormatConstructor(budget);
+  const relativeTimeFormat = createRelativeTimeFormatConstructor(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 });
   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 +33772,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-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"]);
@@ -33794,11 +34051,29 @@ 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 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%"]')
         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-relativetimeformat") {
+    fields(node, ["kind", "options", "state"]);
+    const options = record2(node.options);
+    const names = ["locale", "numberingSystem", "style", "numeric"];
+    fields(options, [...names]);
+    if (names.some((key) => typeof options[key] !== "string")) throw new TypeError("Invalid RelativeTimeFormat option type.");
+    const restored = relativeTimeFormatState(createSandboxRelativeTimeFormat(options.locale, options)).options;
+    if (names.some((key) => options[key] !== restored[key])) throw new TypeError("Invalid resolved RelativeTimeFormat options.");
+    state(node.state);
   } else if (node.kind === "guest-collator") {
     fields(node, ["kind", "options", "state"], ["compare"]);
     const options = record2(node.options);
@@ -37554,6 +37829,8 @@ 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 (isSandboxRelativeTimeFormat(value)) visit(relativeTimeFormatState(value).options, depth + 1);
     if (isSandboxNumberFormat(value)) {
       const state = numberFormatState(value);
       visit(state.options, depth + 1);
@@ -55539,4 +55816,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-E2VDSNJC.js.map