@poe-platform/safe-js 0.1.447 → 0.1.449

package/dist/safe-js/chunks/{chunk-RN5KVZJA.js → chunk-264RHYEA.js}

@@ -8525,6 +8525,8 @@ var functionPrototypes = /* @__PURE__ */ new WeakMap();
 var initialArrayMethods = /* @__PURE__ */ new WeakMap();
 var initialRegexDescriptors = /* @__PURE__ */ new WeakMap();
 var intrinsicPrototypeRoots = /* @__PURE__ */ new WeakMap();
+var intrinsicRetentionTargets = /* @__PURE__ */ new WeakMap();
+var intrinsicRetentionGroups = /* @__PURE__ */ new WeakMap();
 var intrinsicConstructors = /* @__PURE__ */ new WeakMap();
 var intrinsicFunctions = /* @__PURE__ */ new WeakSet();
 var initialBoxedMethods = /* @__PURE__ */ new WeakMap();
@@ -8701,11 +8703,16 @@ function registerIntrinsicObject(budget, value, trackMethods = true) {
   const methods2 = trackMethods ? Object.values(Object.getOwnPropertyDescriptors(value)).map((descriptor) => descriptor.value).filter(isGuestClosure) : [];
   trackIntrinsicState(budget, value, value, [value, ...methods2]);
 }
-function trackIntrinsicState(budget, root, owner, targets) {
-  let roots = intrinsicPrototypeRoots.get(budget);
-  if (roots === void 0) intrinsicPrototypeRoots.set(budget, roots = /* @__PURE__ */ new Set());
-  roots.add(root);
-  const records = [...new Set(targets)].map((target) => {
+function completeIntrinsicObjectInitialization(budget, value) {
+  for (const records of intrinsicRetentionGroups.get(budget)?.values() ?? []) {
+    const record4 = records.find((record5) => record5.target === value);
+    if (record4 === void 0) continue;
+    Object.assign(record4, captureIntrinsicRecords([value])[0]);
+    return;
+  }
+}
+function captureIntrinsicRecords(targets) {
+  return [...new Set(targets)].map((target) => {
     let tracked = trackedPrototypes.get(target);
     if (tracked === void 0) {
       tracked = { current: getSandboxPrototype(target) };
@@ -8726,6 +8733,12 @@ function trackIntrinsicState(budget, root, owner, targets) {
     extensible: Object.isExtensible(record4.value),
     descriptors: new Map(Reflect.ownKeys(record4.value).map((key) => [key, Object.getOwnPropertyDescriptor(record4.value, key)]))
   }));
+}
+function trackIntrinsicState(budget, root, owner, targets) {
+  let roots = intrinsicPrototypeRoots.get(budget);
+  if (roots === void 0) intrinsicPrototypeRoots.set(budget, roots = /* @__PURE__ */ new Set());
+  roots.add(root);
+  const records = captureIntrinsicRecords(targets);
   for (const { target } of records)
     if (isGuestClosure(target)) intrinsicFunctions.add(target);
   const unchanged = (before, after) => before !== void 0 && after !== void 0 && Object.is(before.value, after.value) && before.get === after.get && before.set === after.set && before.writable === after.writable && before.configurable === after.configurable && before.enumerable === after.enumerable;
@@ -8736,9 +8749,21 @@ function trackIntrinsicState(budget, root, owner, targets) {
       return getSandboxPrototype(target) === parent && Object.isExtensible(value) === extensible && hasExplicitSandboxPrototype(target) === explicit && Reflect.ownKeys(current).length === descriptors2.size && Reflect.ownKeys(value).every((key) => unchanged(descriptors2.get(key), Object.getOwnPropertyDescriptor(value, key)));
     })
   );
+  let retainedTargets = intrinsicRetentionTargets.get(budget);
+  if (retainedTargets === void 0) intrinsicRetentionTargets.set(budget, retainedTargets = /* @__PURE__ */ new WeakSet());
+  let groups = intrinsicRetentionGroups.get(budget);
+  if (groups === void 0) intrinsicRetentionGroups.set(budget, groups = /* @__PURE__ */ new Map());
+  let retainedRecords = groups.get(root);
+  if (retainedRecords === void 0) groups.set(root, retainedRecords = []);
+  for (const record4 of records) {
+    if (retainedTargets.has(record4.target)) continue;
+    retainedTargets.add(record4.target);
+    retainedRecords.push(record4);
+  }
+  if (retainedRecords.length === 0) return;
   budget.setRetainedValues(root, () => {
     const retained = [];
-    for (const record4 of records) {
+    for (const record4 of retainedRecords) {
       const { value, descriptors: descriptors2, prototype: parent, revision } = record4;
       const currentPrototype = record4.tracked.current;
       if (currentPrototype !== parent) retained.push(currentPrototype);
@@ -8762,6 +8787,8 @@ function releaseObjectPrototype(budget) {
   releaseIntrinsicIdentities(budget);
   for (const prototype of intrinsicPrototypeRoots.get(budget) ?? []) budget.setRetainedValues(prototype, void 0);
   intrinsicPrototypeRoots.delete(budget);
+  intrinsicRetentionTargets.delete(budget);
+  intrinsicRetentionGroups.delete(budget);
   boxedPrototypes.delete(budget);
   regexPrototypes.delete(budget);
   collectionPrototypes.delete(budget);
@@ -12349,8 +12376,12 @@ function formatNumber(value, methodName, argument, budget) {
 // packages/safe-js/src/interp/methods/string.ts
 import { types as types7 } from "node:util";
 
-// packages/safe-js/src/interp/methods/string-locale.ts
-var collatorOptions = [
+// packages/safe-js/src/interp/intl-collator.ts
+var NativeCollator = Intl.Collator;
+var nativeResolvedOptions = NativeCollator.prototype.resolvedOptions;
+var nativeCompare = Object.getOwnPropertyDescriptor(NativeCollator.prototype, "compare").get;
+var states5 = /* @__PURE__ */ new WeakMap();
+var optionTypes = [
   ["usage", ["sort", "search"]],
   ["localeMatcher", ["lookup", "best fit"]],
   ["collation", "unicodeType"],
@@ -12359,6 +12390,50 @@ var collatorOptions = [
   ["sensitivity", ["base", "accent", "case", "variant"]],
   ["ignorePunctuation", "boolean"]
 ];
+async function readCollatorOptions(input, budget, context, invalid) {
+  const source = intlOptionsObject(input, budget);
+  const options = /* @__PURE__ */ Object.create(null);
+  const release = retainValues(budget, () => [source, options]);
+  try {
+    for (const [key, type] of optionTypes) {
+      const value = await readIntlProperty(source, key, budget, context);
+      if (value !== void 0) options[key] = await convertIntlOption(
+        value,
+        key,
+        type,
+        budget,
+        context,
+        (text) => {
+          invalid?.(key, text);
+          new NativeCollator([], { [key]: text });
+        }
+      );
+    }
+    return options;
+  } finally {
+    release();
+  }
+}
+function createSandboxCollator(locales2, options) {
+  const native = new NativeCollator(locales2, options);
+  const value = /* @__PURE__ */ Object.create(null);
+  states5.set(value, { native, options: Reflect.apply(nativeResolvedOptions, native, []) });
+  return value;
+}
+function isSandboxCollator(value) {
+  return typeof value === "object" && value !== null && states5.has(value);
+}
+function collatorState(value) {
+  if (!isSandboxCollator(value)) throw new TypeError("Intl.Collator requires a Collator receiver.");
+  return states5.get(value);
+}
+function compareCollatorStrings(value, first, second) {
+  const state = collatorState(value);
+  const compare = Reflect.apply(nativeCompare, state.native, []);
+  return Reflect.apply(compare, void 0, [first, second]);
+}
+
+// packages/safe-js/src/interp/methods/string-locale.ts
 async function changeStringLocaleCase(value, method, args, budget, context) {
   let locales2 = [];
   const release = retainValues(budget, () => [value, locales2]);
@@ -12373,19 +12448,15 @@ async function changeStringLocaleCase(value, method, args, budget, context) {
 async function compareStringLocale(value, args, budget, context) {
   let comparison = "";
   let locales2 = [];
-  const options = /* @__PURE__ */ Object.create(null);
+  let options = /* @__PURE__ */ Object.create(null);
   const release = retainValues(budget, () => [value, comparison, locales2, options]);
   try {
     comparison = await sandboxString(args[0], budget, context);
     locales2 = await canonicalizeGuestLocales(args[1], budget, context);
     if (args[2] === null) return Reflect.apply(String.prototype.localeCompare, value, [comparison, locales2, null]);
-    const inputOptions = intlOptionsObject(args[2], budget);
-    for (const [key, type] of collatorOptions) {
-      const option = await readIntlProperty(inputOptions, key, budget, context);
-      if (option !== void 0) options[key] = await convertIntlOption(option, key, type, budget, context, (text) => {
-        Reflect.apply(String.prototype.localeCompare, "", ["", [], { [key]: text }]);
-      });
-    }
+    options = await readCollatorOptions(args[2], budget, context, (key, text) => {
+      Reflect.apply(String.prototype.localeCompare, "", ["", [], { [key]: text }]);
+    });
     budget.visitNode(value.length + comparison.length);
     return Reflect.apply(String.prototype.localeCompare, value, [comparison, locales2, options]);
   } finally {
@@ -21145,7 +21216,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 optionTypes = [
+  const optionTypes2 = [
     ["calendar", "ca", "unicodeType"],
     ["collation", "co", "unicodeType"],
     ["firstDayOfWeek", "fw", "unicodeType"],
@@ -21154,7 +21225,7 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
     ["numeric", "kn", "boolean"],
     ["numberingSystem", "nu", "unicodeType"]
   ];
-  for (const [key, extensionKey, type] of optionTypes) {
+  for (const [key, extensionKey, type] of optionTypes2) {
     let value = await readIntlProperty(options, key, budget, context);
     if (value === void 0) continue;
     if (key === "firstDayOfWeek") {
@@ -21513,6 +21584,10 @@ function captureGuestHeapNode(value, encode) {
     return void 0;
   }
   if (isSandboxLocale(value)) return { kind: "guest-locale", tag: localeTag(value), state: captureObjectState(value, encode) };
+  if (isSandboxCollator(value)) {
+    const { options, compare } = collatorState(value);
+    return { kind: "guest-collator", options: { ...options }, ...compare === void 0 ? {} : { compare: encode(compare) }, state: captureObjectState(value, encode) };
+  }
   if (hasGuestObjectState(value) || privateElements.has(value)) {
     if (isSandboxRegex(value)) return { kind: "guest-regex", source: value.source, flags: value.flags, state: captureObjectState(value, encode) };
     if (isSandboxBox(value)) return { kind: "guest-boxed", value: encode(boxedValue(value)), state: captureObjectState(value, encode) };
@@ -24791,6 +24866,7 @@ function createIteratorGlobal(budget) {
   installIteratorConsumers(prototype, budget);
   installLazyIteratorHelpers(prototype, budget);
   registerIntrinsicFunction(budget, constructor);
+  completeIntrinsicObjectInitialization(budget, prototype);
   registerIntrinsicObject(budget, prototype);
   return constructor;
 }
@@ -25714,6 +25790,107 @@ function createLocaleConstructor(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/intl-collator.ts
+var supportedLocalesOf = Intl.Collator.supportedLocalesOf;
+function createCollatorConstructor(budget) {
+  const prototype = createIntrinsicObject();
+  const compareTarget = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "",
+    length: 2,
+    call: async ([first, second], context) => {
+      let left = "";
+      const release = retainValues(budget, () => [context?.thisValue, left]);
+      try {
+        left = await sandboxString(first, budget, context);
+        const right = await sandboxString(second, budget, context);
+        budget.visitNode(left.length + right.length);
+        return compareCollatorStrings(context?.thisValue, left, right);
+      } finally {
+        release();
+      }
+    }
+  });
+  registerBuiltinIdentities(budget, { "%CollatorCompare%": compareTarget });
+  registerIntrinsicFunction(budget, compareTarget);
+  const initialize = 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 release = retainValues(budget, () => [selected, locales2]);
+    try {
+      locales2 = await canonicalizeGuestLocales(input, budget, context);
+      const converted = await readCollatorOptions(options, budget, context);
+      const value = createSandboxCollator(locales2, converted);
+      setSandboxPrototype(value, typeof selected === "object" && selected !== null ? selected : prototype, budget);
+      return allocateProducedSandboxValue(value, budget);
+    } finally {
+      release();
+    }
+  };
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "Collator",
+    length: 0,
+    construct: initialize,
+    call: (args, context) => initialize(args, { ...context, stack: context?.stack ?? [], thisValue: context?.thisValue, newTarget: void 0 })
+  });
+  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 option = await readIntlProperty(source, "localeMatcher", budget, context);
+        const matcher = option === void 0 ? void 0 : await convertIntlOption(option, "localeMatcher", ["lookup", "best fit"], budget, context);
+        return allocateProducedSandboxValue(supportedLocalesOf(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.Collator", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => allocateProducedSandboxValue({ ...collatorState(context?.thisValue).options }, budget)
+    }), writable: true, configurable: true },
+    compare: { get: accessorAdapter(createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "get compare",
+      length: 0,
+      call: (_args, context) => {
+        const receiver = context?.thisValue;
+        const state = collatorState(receiver);
+        if (state.compare === void 0) {
+          state.compare = createBoundFunction(
+            { target: compareTarget, thisValue: receiver, args: [] },
+            "",
+            2,
+            (target, args, stack, thisValue) => invokeBuiltinClosure(target, args, budget, { stack, thisValue }, thisValue)
+          );
+          allocateProducedSandboxValue(state.compare, budget);
+        }
+        return state.compare;
+      }
+    }), "get"), configurable: true }
+  });
+  return constructor;
+}
+
 // packages/safe-js/src/interp/globals/intl.ts
 var supportedValuesOf = Intl.supportedValuesOf;
 function createIntlGlobal(budget) {
@@ -25727,18 +25904,23 @@ function createIntlGlobal(budget) {
   };
   const intl = createIntrinsicObject();
   const locale = createLocaleConstructor(budget);
+  const collator = createCollatorConstructor(budget);
   Object.defineProperty(intl, "Locale", { value: locale, writable: true, configurable: true });
+  Object.defineProperty(intl, "Collator", { value: collator, 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 });
-  const prototype = locale.properties.prototype;
-  for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(prototype)))
-    for (const closure of [descriptor.value, ...retainedAccessorClosures(descriptor)])
-      if (isSandboxClosure(closure)) registerIntrinsicFunction(budget, closure);
-  registerIntrinsicObject(budget, prototype);
+  for (const constructor of [locale, collator]) {
+    const prototype = constructor.properties.prototype;
+    for (const owner of [prototype, constructor.properties])
+      for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(owner)))
+        for (const closure of [descriptor.value, ...retainedAccessorClosures(descriptor)])
+          if (isSandboxClosure(closure)) registerIntrinsicFunction(budget, closure);
+    registerIntrinsicObject(budget, prototype);
+  }
   for (const name of Object.keys(methods2)) registerIntrinsicFunction(budget, intl[name]);
   registerIntrinsicObject(budget, intl);
   return intl;
@@ -25848,7 +26030,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-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-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"]);
@@ -26117,6 +26299,23 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     fields(node, ["kind", "source", "flags", "state"]);
     if (typeof node.source !== "string" || typeof node.flags !== "string") throw new TypeError("Invalid guest RegExp payload.");
     state(node.state);
+  } else if (node.kind === "guest-collator") {
+    fields(node, ["kind", "options", "state"], ["compare"]);
+    const options = record2(node.options);
+    const names = ["locale", "usage", "sensitivity", "ignorePunctuation", "collation", "numeric", "caseFirst"];
+    fields(options, names);
+    for (const key of names)
+      if (typeof options[key] !== (key === "numeric" || key === "ignorePunctuation" ? "boolean" : "string"))
+        throw new TypeError("Invalid Collator option type.");
+    const restored = collatorState(createSandboxCollator(options.locale, options)).options;
+    for (const key of names)
+      if (options[key] !== restored[key]) throw new TypeError("Invalid resolved Collator options.");
+    if (node.compare !== void 0) {
+      const compare = reference(node.compare, ["bound-function"]);
+      if (reference(compare.thisValue) !== node || array(compare.args).length !== 0 || compare.name !== "" || compare.length !== 2 || reference(compare.target, ["intrinsic"]).id !== '["%CollatorCompare%"]')
+        throw new TypeError("Invalid cached Collator comparison.");
+    }
+    state(node.state);
   } else if (node.kind === "guest-locale") {
     fields(node, ["kind", "tag", "state"]);
     if (typeof node.tag !== "string" || localeTag(createSandboxLocale(node.tag)) !== node.tag)
@@ -29855,6 +30054,11 @@ function measureSandboxData(values, options = {}) {
     }
     if (isSandboxDate(value)) usage += 8;
     if (isSandboxLocale(value)) usage += localeTag(value).length;
+    if (isSandboxCollator(value)) {
+      const state = collatorState(value);
+      visit(state.options, depth + 1);
+      visit(state.compare, depth + 1);
+    }
     if (isGuestHostObject(value)) {
       usage += measureHostObjectData(value);
       return;
@@ -47818,4 +48022,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-RN5KVZJA.js.map
+//# sourceMappingURL=chunk-264RHYEA.js.map