@poe-platform/safe-js 0.1.170 → 0.1.171

package/dist/safe-js/chunks/{chunk-MZW43CYT.js → chunk-OUFC6W7G.js}

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

package/dist/safe-js/chunks/{chunk-WPI4GGVU.js → chunk-XKCTB5FR.js}

@@ -9955,6 +9955,9 @@ function formatNumber(value, methodName, argument, budget) {
   return budget.allocateString(result);
 }
 
+// packages/safe-js/src/interp/methods/string.ts
+import { types as types6 } from "node:util";
+
 // packages/safe-js/src/interp/regex/engine.ts
 function matchRegex(pattern, input, lastIndex = 0) {
   const startIndex = pattern.flags.global ? normalizeLastIndex(lastIndex) : 0;
@@ -10382,15 +10385,39 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
   if (value === null || value === void 0)
     throw new TypeError(`String#${methodName} requires a non-null receiver.`);
   const fallback = () => typeof value === "string" ? callStringMethodBody(value, methodName, args, budget, callClosure, parent, context) : Promise.resolve(sandboxString(value, budget, context)).then((string) => callStringMethodBody(string, methodName, args, budget, callClosure, parent, context));
-  const symbol = methodName === "match" ? Symbol.match : methodName === "search" ? Symbol.search : methodName === "split" ? Symbol.split : void 0;
+  const symbol = methodName === "match" ? Symbol.match : methodName === "search" ? Symbol.search : methodName === "matchAll" ? Symbol.matchAll : methodName === "replace" || methodName === "replaceAll" ? Symbol.replace : methodName === "split" ? Symbol.split : void 0;
   const pattern = args[0];
+  if (symbol !== void 0 && types6.isRegExp(pattern))
+    throw new TypeError(`String#${methodName} does not accept unbranded host RegExp values.`);
   if (symbol === void 0 || pattern === null || pattern === void 0) return fallback();
   const applyHook = (hook) => {
     if (hook === null || hook === void 0) return fallback();
     if (!isSandboxClosure(hook)) throw new TypeError(`String#${methodName} symbol hook must be callable.`);
-    return invokeBuiltinClosure(hook, methodName === "split" ? [value, args[1]] : [value], budget, context, pattern);
+    return invokeBuiltinClosure(hook, symbol === Symbol.split || symbol === Symbol.replace ? [value, args[1]] : [value], budget, context, pattern);
   };
-  return context?.getProperty !== void 0 ? Promise.resolve(context.getProperty(pattern, symbol)).then(applyHook) : applyHook(getSandboxDataProperty(pattern, symbol, budget));
+  const readProperty = (key) => context?.getProperty !== void 0 ? context.getProperty(pattern, key) : key === "flags" && isSandboxRegex(pattern) && getSandboxPropertyDescriptor(pattern, key, budget) === void 0 ? pattern.flags : getSandboxDataProperty(pattern, key, budget);
+  const dispatch = () => {
+    const hook = readProperty(symbol);
+    return hook instanceof Promise ? hook.then(applyHook) : applyHook(hook);
+  };
+  if ((methodName === "replaceAll" || methodName === "matchAll") && (typeof pattern === "object" || typeof pattern === "function")) {
+    const checkFlags = (flags) => {
+      const checkText = (text2) => {
+        if (!text2.includes("g")) throw new TypeError(`String#${methodName} requires a global regex.`);
+        return dispatch();
+      };
+      const text = sandboxString(flags, budget, context);
+      return typeof text === "string" ? checkText(text) : text.then(checkText);
+    };
+    const checkMatch = (match2) => {
+      if (!(match2 === void 0 ? isSandboxRegex(pattern) : Boolean(match2))) return dispatch();
+      const flags = readProperty("flags");
+      return flags instanceof Promise ? flags.then(checkFlags) : checkFlags(flags);
+    };
+    const match = readProperty(Symbol.match);
+    return match instanceof Promise ? match.then(checkMatch) : checkMatch(match);
+  }
+  return dispatch();
 }
 function callStringMethodBody(value, methodName, args, budget, callClosure = async (closure, closureArgs) => await closure.call(closureArgs), parent, context) {
   if (methodName === "concat" && args.some((argument) => argument !== null && typeof argument === "object")) {
@@ -10435,7 +10462,7 @@ function callStringMethodBody(value, methodName, args, budget, callClosure = asy
     return callReplaceLikeMethod(value, methodName, args, budget, callClosure, context);
   }
   const regex = args[0];
-  if (isSandboxRegex(regex) && regex.lastIndex !== null && typeof regex.lastIndex === "object" && (methodName === "match" && !regex.flags.includes("g") || methodName === "matchAll" && regex.flags.includes("g"))) {
+  if (isSandboxRegex(regex) && regex.lastIndex !== null && typeof regex.lastIndex === "object" && (methodName === "match" && !regex.flags.includes("g") || methodName === "matchAll")) {
     return callStringRegexCursor(value, methodName, regex, budget, parent, context);
   }
   if ((methodName === "match" || methodName === "matchAll" || methodName === "search") && !isSandboxRegex(args[0])) {
@@ -10567,20 +10594,26 @@ async function callConcat(value, args, budget, context) {
 function callReplaceLikeMethod(value, methodName, args, budget, callClosure, context) {
   const search = args[0];
   const replacement = args[1];
-  if (!isSandboxRegex(search) && typeof search !== "string" || typeof replacement !== "string" && !isSandboxClosure(replacement)) {
-    throw new TypeError(
-      `String#${methodName} only supports string or regex search values and string or function replacements.`
-    );
+  const useRegex = isSandboxRegex(search) && getSandboxPropertyDescriptor(search, Symbol.replace, budget) === void 0;
+  if (!useRegex && typeof search !== "string" || typeof replacement !== "string" && !isSandboxClosure(replacement)) {
+    return (async () => {
+      let normalizedSearch;
+      let normalizedReplacement;
+      const release = retainValues(budget, () => [normalizedSearch, normalizedReplacement]);
+      try {
+        normalizedSearch = useRegex ? search : await sandboxString(search, budget, context);
+        normalizedReplacement = isSandboxClosure(replacement) ? replacement : await sandboxString(replacement, budget, context);
+        return await callReplaceLikeMethod(value, methodName, [normalizedSearch, normalizedReplacement], budget, callClosure, context);
+      } finally {
+        release();
+      }
+    })();
   }
   if (isSandboxRegex(search)) {
-    if (methodName === "replaceAll" && !search.flags.includes("g")) {
-      throw new TypeError("String#replaceAll requires a global regex.");
-    }
     return replaceRegex(
       value,
       search,
       replacement,
-      methodName === "replaceAll",
       budget,
       callClosure,
       context
@@ -10600,14 +10633,14 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure, con
     callClosure
   );
 }
-async function replaceRegex(value, regex, replacement, replaceAll, budget, callClosure, context) {
+async function replaceRegex(value, regex, replacement, budget, callClosure, context) {
   if (regex.flags.includes("g")) regex.lastIndex = 0;
   const cursor = regex.lastIndex;
   const retained = {};
   budget.setRetainedValues(retained, () => [value, regex, cursor, replacement]);
   try {
     const lastIndex = await sandboxNumber(cursor, budget, context);
-    const matches = collectRegexMatches(regex, value, replaceAll || regex.flags.includes("g"), void 0, lastIndex);
+    const matches = collectRegexMatches(regex, value, regex.flags.includes("g"), void 0, lastIndex);
     let result = "";
     let copiedThrough = 0;
     for (const match of matches) {
@@ -10774,13 +10807,11 @@ function callMatchLikeMethod(value, methodName, args, compilation, lastIndex) {
     if (!Object.is(regex.lastIndex, lastIndex2)) regex.lastIndex = lastIndex2;
     return match?.index ?? -1;
   }
-  if (methodName === "matchAll" && !regex.flags.includes("g"))
-    throw new TypeError("String#matchAll requires a global regex.");
   if (methodName === "match" && !regex.flags.includes("g"))
     return toMatchArray(executeRegex(regex, value, lastIndex ?? Number(regex.lastIndex)), value);
   if (methodName === "match") regex.lastIndex = 0;
   const matcher = methodName === "matchAll" ? createSandboxRegex(regex.source, regex.flags, normalizeLastIndex(lastIndex ?? Number(regex.lastIndex)), compilation) : regex;
-  const matches = collectRegexMatches(matcher, value, true, compilation.owner?.budget, Number(matcher.lastIndex));
+  const matches = collectRegexMatches(matcher, value, matcher.flags.includes("g"), compilation.owner?.budget, Number(matcher.lastIndex));
   if (methodName === "match" && matches.length === 0) return null;
   return methodName === "match" ? matches.map((match) => match.text) : matches.map((match) => toMatchArray(match, value));
 }
@@ -33500,7 +33531,7 @@ function createReplayableRandom(options = {}) {
 
 // packages/safe-js/src/realm.ts
 import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
-import { types as types6 } from "node:util";
+import { types as types7 } from "node:util";
 
 // packages/safe-js/src/interp/globals/console-json.ts
 function createConsoleJsonGlobals(options) {
@@ -34179,7 +34210,7 @@ var RealmState = class {
         throw new TypeError("Realm limits must be positive safe integers with supported names.");
       this.limits[name] = Number(value);
     }
-    if (options.extensions !== void 0 && (!Array.isArray(options.extensions) || types6.isProxy(options.extensions)))
+    if (options.extensions !== void 0 && (!Array.isArray(options.extensions) || types7.isProxy(options.extensions)))
       throw new TypeError("Extensions must be a registration array.");
     const registrations = options.extensions ?? [];
     const extensions = [];
@@ -34414,7 +34445,7 @@ var RealmState = class {
     return this.phase.run(phase, () => {
       try {
         const result = call();
-        if (types6.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
+        if (types7.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
           return Promise.resolve(result).then(
             async (value) => {
               await Promise.allSettled(phase.pending);
@@ -34483,7 +34514,7 @@ var RealmState = class {
       },
       read: (operation, validate) => {
         const value = this.invokeHost(operation, operation);
-        if (types6.isPromise(value)) {
+        if (types7.isPromise(value)) {
           void Promise.resolve(value).catch(() => void 0);
           throw new TypeError("Live property operations must be synchronous.");
         }
@@ -34491,7 +34522,7 @@ var RealmState = class {
       },
       write: (operation, value) => {
         const result = this.invokeHost(operation, () => operation(this.exportValue(value)));
-        if (types6.isPromise(result)) {
+        if (types7.isPromise(result)) {
           void Promise.resolve(result).catch(() => void 0);
           throw new TypeError("Live property setters must be synchronous.");
         }
@@ -34700,7 +34731,7 @@ var RealmState = class {
         }
       });
       const output = getExtensionSetup(extension)(context);
-      if (types6.isPromise(output)) {
+      if (types7.isPromise(output)) {
         void Promise.resolve(output).catch(() => void 0);
         throw new TypeError("Extension setup must be synchronous.");
       }
@@ -34892,7 +34923,7 @@ var RealmState = class {
 };
 function readModules(input) {
   const entries = (value, label) => {
-    if (types6.isMap(value) && !types6.isProxy(value)) {
+    if (types7.isMap(value) && !types7.isProxy(value)) {
       const result = [...Map.prototype.entries.call(value)];
       if (result.length > 4096 || result.some(([key]) => typeof key !== "string" || key.length === 0))
         throw new TypeError(`${label} requires bounded string keys.`);
@@ -36148,4 +36179,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-WPI4GGVU.js.map
+//# sourceMappingURL=chunk-XKCTB5FR.js.map