@poe-platform/safe-js 0.1.452 → 0.1.454

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

@@ -19606,6 +19606,79 @@ function relativeIndex(numeric, length) {
   return integer2 < 0 ? Math.max(length + integer2, 0) : Math.min(integer2, length);
 }
 
+// packages/safe-js/src/interp/globals/group-by.ts
+function createGroupBy(budget, keyMode) {
+  return createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "groupBy",
+    length: 2,
+    call: async ([items, callback], context) => {
+      if (items === null || items === void 0) throw new TypeError("groupBy requires an iterable.");
+      if (!isSandboxClosure(callback)) throw new TypeError("groupBy requires a callable callback.");
+      const iterator = context === void 0 ? getSandboxIterator(items, budget) : await acquireSandboxIterator(items, budget, context);
+      if (iterator === void 0) throw new TypeError("groupBy requires an iterable.");
+      const groups = createSandboxMap([]);
+      let value;
+      let key;
+      const release = retainValues(budget, () => [groups, callback, iterator.retainedValue, value, key]);
+      const checkpoint = createDataCheckpoint(budget, context);
+      const closeOnThrow = async (error) => {
+        try {
+          await closeIterator(iterator, true);
+        } catch (closeError) {
+          if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
+        }
+        throw error;
+      };
+      try {
+        let index = 0;
+        while (true) {
+          try {
+            budget.visitNode();
+            if (index >= Number.MAX_SAFE_INTEGER) throw new TypeError("groupBy input exceeds the maximum index.");
+          } catch (error) {
+            await closeOnThrow(error);
+          }
+          const next = await iterator.next();
+          if ((await readIteratorResult(iterator, next, "done")).value) break;
+          value = (await readIteratorResult(iterator, next, "value")).value;
+          try {
+            key = await invokeBuiltinClosure(callback, [value, index], budget, context, void 0);
+            if (keyMode === "property") key = await toPropertyKey(key, budget, context);
+            let group = groups.entries.get(key);
+            const added = group === void 0;
+            if (group === void 0) {
+              budget.allocateCollectionEntries(groups.entries.size + 1);
+              group = [];
+              groups.entries.set(key, group);
+            }
+            budget.allocateArrayLength(group.length + 1);
+            group.push(value);
+            const growth = 1 + (added ? 2 : 0) + (budget.limits.dataSize === void 0 ? 0 : measureSandboxData(added ? [key, value] : [value]));
+            checkpoint(groups, growth);
+            value = key = void 0;
+            index++;
+          } catch (error) {
+            await closeOnThrow(error);
+          }
+        }
+        checkpoint(groups, 0, true);
+        if (keyMode === "identity") return allocateProducedSandboxValue(groups, budget);
+        const result = /* @__PURE__ */ Object.create(null);
+        setSandboxPrototype(result, null, budget);
+        for (const [property, elements] of groups.entries) {
+          budget.visitNode();
+          defineOwnDataProperty(result, property, elements);
+        }
+        return allocateProducedSandboxValue(result, budget);
+      } finally {
+        release();
+      }
+    }
+  });
+}
+
 // packages/safe-js/src/interp/globals/numeric-parsers.ts
 function createNumericParsers(budget) {
   return {
@@ -22030,6 +22103,7 @@ function createObjectArrayGlobals(options) {
           call: ([left, right]) => Reflect.apply(Object.is, Object, [left, right]),
           name: "is"
         }),
+        groupBy: createGroupBy(options.budget, "property"),
         fromEntries: createSandboxClosure({
           sandbox: true,
           call: ([value], context) => {
@@ -28545,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 optionTypes3 = [
+  const optionTypes4 = [
     ["calendar", "ca", "unicodeType"],
     ["collation", "co", "unicodeType"],
     ["firstDayOfWeek", "fw", "unicodeType"],
@@ -28554,7 +28628,7 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
     ["numeric", "kn", "boolean"],
     ["numberingSystem", "nu", "unicodeType"]
   ];
-  for (const [key, extensionKey, type] of optionTypes3) {
+  for (const [key, extensionKey, type] of optionTypes4) {
     let value = await readIntlProperty(options, key, budget, context);
     if (value === void 0) continue;
     if (key === "firstDayOfWeek") {
@@ -28597,20 +28671,43 @@ function formatList(value, strings, parts) {
   return Reflect.apply(parts ? formatToParts2 : format, listFormatState(value).native, [strings]);
 }
 
-// packages/safe-js/src/interp/intl-numberformat.ts
+// 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);
-  states7.set(value, { native, options: numberFormatterOptions2(native) });
+  states8.set(value, { native, options: numberFormatterOptions2(native) });
   return value;
 }
 function isSandboxNumberFormat(value) {
-  return typeof value === "object" && value !== null && states7.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 states7.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;
@@ -28965,9 +29062,10 @@ 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 (isSandboxNumberFormat(value)) {
-    const { options, format: format2 } = numberFormatState(value);
-    return { kind: "guest-numberformat", options: { ...options }, ...format2 === void 0 ? {} : { format: encode(format2) }, 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);
@@ -30811,6 +30909,11 @@ function createCollectionGlobals(options) {
     name: "Set"
   });
   mapConstructors.add(mapConstructor);
+  Object.defineProperty(materializeFunctionProperties(mapConstructor), "groupBy", {
+    value: createGroupBy(options.budget, "identity"),
+    writable: true,
+    configurable: true
+  });
   setConstructors.add(setConstructor);
   installCollectionPrototypes(options.budget, mapConstructor, setConstructor);
   return { Map: mapConstructor, Set: setConstructor };
@@ -33509,6 +33612,100 @@ function createListFormatConstructor(budget) {
   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) {
@@ -33525,10 +33722,12 @@ function createIntlGlobal(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 });
@@ -33652,7 +33851,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-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"]);
@@ -33931,8 +34130,8 @@ 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 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%"]')
+      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);
@@ -33945,6 +34144,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-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);
@@ -37701,6 +37909,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 (isSandboxRelativeTimeFormat(value)) visit(relativeTimeFormatState(value).options, depth + 1);
     if (isSandboxNumberFormat(value)) {
       const state = numberFormatState(value);
       visit(state.options, depth + 1);
@@ -55686,4 +55895,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-GJPSM3AB.js.map
+//# sourceMappingURL=chunk-GYKATDHU.js.map