@poe-platform/safe-js 0.1.182 → 0.1.184

package/dist/safe-js/chunks/{chunk-J5JNS3B3.js → chunk-4XA4KLMD.js}

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

package/dist/safe-js/chunks/{chunk-A6KP64IV.js → chunk-Q64VTJKF.js}

@@ -10827,23 +10827,28 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure, use
     replacement,
     methodName === "replaceAll",
     budget,
-    callClosure
+    callClosure,
+    context
   );
 }
 async function replaceRegex(value, regex, replacement, budget, callClosure, context) {
+  if (["exec", "flags", ...Object.keys(regexFlagProperties)].some((key) => getSandboxPropertyDescriptor(regex, key, budget) !== void 0))
+    return replaceObservableRegex(value, regex, replacement, budget, callClosure, context);
   if (regex.flags.includes("g")) regex.lastIndex = 0;
   const cursor = regex.lastIndex;
+  let result = "";
   const retained = {};
-  budget.setRetainedValues(retained, () => [value, regex, cursor, replacement]);
+  budget.setRetainedValues(retained, () => [value, regex, cursor, replacement, result]);
   try {
     const lastIndex = await sandboxNumber(cursor, budget, context);
     const matches = collectRegexMatches(regex, value, regex.flags.includes("g"), void 0, lastIndex);
-    let result = "";
     let copiedThrough = 0;
     for (const match of matches) {
       result += value.slice(copiedThrough, match.index);
-      result += typeof replacement === "string" ? expandReplacement(replacement, match.text, match.captures, value, match.index) : String(
-        await callClosure(replacement, [match.text, ...match.captures, match.index, value])
+      result += typeof replacement === "string" ? await expandReplacement(replacement, match.text, match.captures, value, match.index, budget, context) : await sandboxString(
+        await callClosure(replacement, [match.text, ...match.captures, match.index, value]),
+        budget,
+        context
       );
       copiedThrough = match.index + match.text.length;
     }
@@ -10853,57 +10858,171 @@ async function replaceRegex(value, regex, replacement, budget, callClosure, cont
     budget.setRetainedValues(retained, void 0);
   }
 }
-function expandReplacement(replacement, match, captures, input, matchIndex) {
+function readReplacementProperty(target, key, budget, context) {
+  if (context?.getProperty !== void 0) return context.getProperty(target, key);
+  const descriptor = getSandboxPropertyDescriptor(target, key, budget);
+  if (descriptor !== void 0) return readPropertyDescriptor(descriptor, target, context);
+  return isSandboxRegex(target) ? getRegexMember(target, key, budget, context) : void 0;
+}
+async function replaceObservableRegex(value, regex, replacement, budget, callClosure, context) {
+  const matches = [];
+  let current;
+  let field;
+  let groups;
+  let matched;
+  let captures = [];
   let result = "";
-  for (let index = 0; index < replacement.length; index += 1) {
-    const character = replacement.charAt(index);
-    if (character !== "$") {
-      result += character;
-      continue;
+  let flags;
+  const release = retainValues(budget, () => [value, regex, replacement, matches, current, field, groups, matched, captures, result, flags]);
+  try {
+    field = await readReplacementProperty(regex, "flags", budget, context);
+    flags = await sandboxString(field, budget, context);
+    field = void 0;
+    const global = flags.includes("g");
+    const fullUnicode = flags.includes("u") || flags.includes("v");
+    flags = void 0;
+    if (global) regex.lastIndex = 0;
+    while (true) {
+      budget.visitNode();
+      current = await regexExec(regex, value, budget, context);
+      if (current === null) break;
+      budget.allocateArrayLength(matches.length + 1);
+      matches.push(current);
+      if (!global) break;
+      field = await readReplacementProperty(current, "0", budget, context);
+      matched = await sandboxString(field, budget, context);
+      field = void 0;
+      if (matched.length === 0) {
+        field = regex.lastIndex;
+        const index = normalizeLastIndex(await sandboxNumber(field, budget, context));
+        const point = fullUnicode ? value.codePointAt(index) : void 0;
+        regex.lastIndex = index + (point !== void 0 && point > 65535 ? 2 : 1);
+        field = void 0;
+      }
+      matched = void 0;
+      current = void 0;
     }
-    const token = replacement.charAt(index + 1);
-    if (token === "$") {
-      result += "$";
-    } else if (token === "&") {
-      result += match;
-    } else if (token === "`") {
-      result += input.slice(0, matchIndex);
-    } else if (token === "'") {
-      result += input.slice(matchIndex + match.length);
-    } else if (token >= "0" && token <= "9") {
-      let captureIndex = Number(token);
-      const nextDigit = replacement.charAt(index + 2);
-      if (nextDigit >= "0" && nextDigit <= "9") {
-        const twoDigitIndex = Number(token + nextDigit);
-        if (twoDigitIndex > 0 && twoDigitIndex <= captures.length) {
-          captureIndex = twoDigitIndex;
-          index += 1;
-        }
+    let copiedThrough = 0;
+    for (current of matches) {
+      field = await readReplacementProperty(current, "length", budget, context);
+      const count = Math.max(normalizeLastIndex(await sandboxNumber(field, budget, context)) - 1, 0);
+      field = await readReplacementProperty(current, "0", budget, context);
+      matched = await sandboxString(field, budget, context);
+      field = await readReplacementProperty(current, "index", budget, context);
+      const number = await sandboxNumber(field, budget, context);
+      const position = Math.min(Math.max(Number.isNaN(number) ? 0 : Math.trunc(number), 0), value.length);
+      field = void 0;
+      captures = [];
+      budget.allocateArrayLength(count);
+      for (let index = 1; index <= count; index++) {
+        budget.visitNode();
+        field = await readReplacementProperty(current, String(index), budget, context);
+        captures.push(field === void 0 ? void 0 : await sandboxString(field, budget, context));
+        field = void 0;
+      }
+      groups = await readReplacementProperty(current, "groups", budget, context);
+      let text;
+      if (typeof replacement === "string") {
+        if (groups === null) throw new TypeError("Replacement groups cannot be null.");
+        if (groups !== void 0 && typeof groups !== "object") {
+          groups = createSandboxBox(groups);
+          budget.chargeDataUsage(measureSandboxData([groups]));
+        }
+        text = await expandReplacement(replacement, matched, captures, value, position, budget, context, groups);
+      } else {
+        const args = [matched, ...captures, position, value];
+        if (groups !== void 0) args.push(groups);
+        budget.allocateArrayLength(args.length);
+        field = await callClosure(replacement, args);
+        text = await sandboxString(field, budget, context);
+        field = void 0;
+      }
+      if (position >= copiedThrough) {
+        result = budget.allocateString(result + value.slice(copiedThrough, position) + text);
+        copiedThrough = position + matched.length;
       }
-      if (captureIndex === 0 || captureIndex > captures.length) {
+      matched = void 0;
+      captures = [];
+      groups = void 0;
+    }
+    return budget.allocateString(result + value.slice(copiedThrough));
+  } finally {
+    release();
+  }
+}
+async function expandReplacement(replacement, match, captures, input, matchIndex, budget, context, groups) {
+  let result = "";
+  const release = retainValues(budget, () => [replacement, match, captures, input, groups, result]);
+  try {
+    for (let index = 0; index < replacement.length; index += 1) {
+      budget.visitNode();
+      budget.allocateString(result);
+      const character = replacement.charAt(index);
+      if (character !== "$") {
+        result += character;
+        continue;
+      }
+      const token = replacement.charAt(index + 1);
+      if (token === "$") {
+        result += "$";
+      } else if (token === "&") {
+        result += match;
+      } else if (token === "`") {
+        result += input.slice(0, matchIndex);
+      } else if (token === "'") {
+        result += input.slice(matchIndex + match.length);
+      } else if (token === "<" && groups !== void 0) {
+        const end = replacement.indexOf(">", index + 2);
+        if (end === -1) {
+          result += "$";
+          continue;
+        }
+        const capture = await readReplacementProperty(groups, replacement.slice(index + 2, end), budget, context);
+        if (capture !== void 0) result += await sandboxString(capture, budget, context);
+        index = end;
+        continue;
+      } else if (token >= "0" && token <= "9") {
+        let captureIndex = Number(token);
+        const nextDigit = replacement.charAt(index + 2);
+        if (nextDigit >= "0" && nextDigit <= "9") {
+          const twoDigitIndex = Number(token + nextDigit);
+          if (twoDigitIndex > 0 && twoDigitIndex <= captures.length) {
+            captureIndex = twoDigitIndex;
+            index += 1;
+          }
+        }
+        if (captureIndex === 0 || captureIndex > captures.length) {
+          result += "$";
+          continue;
+        }
+        result += captures[captureIndex - 1] ?? "";
+      } else {
         result += "$";
         continue;
       }
-      result += captures[captureIndex - 1] ?? "";
-    } else {
-      result += "$";
-      continue;
+      index += 1;
     }
-    index += 1;
+    return budget.allocateString(result);
+  } finally {
+    release();
   }
-  return result;
 }
-async function replaceWithClosure(value, searchValue, replacer, replaceAll, budget, callClosure) {
+async function replaceWithClosure(value, searchValue, replacer, replaceAll, budget, callClosure, context) {
   const offsets = findReplacementOffsets(value, searchValue, replaceAll);
   let result = "";
   let copiedThrough = 0;
-  for (const offset of offsets) {
-    result += value.slice(copiedThrough, offset);
-    result += String(await callClosure(replacer, [searchValue, offset, value]));
-    copiedThrough = offset + searchValue.length;
+  const release = retainValues(budget, () => [value, searchValue, replacer, result]);
+  try {
+    for (const offset of offsets) {
+      result += value.slice(copiedThrough, offset);
+      result += await sandboxString(await callClosure(replacer, [searchValue, offset, value]), budget, context);
+      copiedThrough = offset + searchValue.length;
+    }
+    result += value.slice(copiedThrough);
+    return budget.allocateString(result);
+  } finally {
+    release();
   }
-  result += value.slice(copiedThrough);
-  return budget.allocateString(result);
 }
 function findReplacementOffsets(value, searchValue, replaceAll) {
   const firstOffset = value.indexOf(searchValue);
@@ -36567,4 +36686,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-A6KP64IV.js.map
+//# sourceMappingURL=chunk-Q64VTJKF.js.map