@poe-platform/safe-js 0.1.183 → 0.1.185

package/dist/safe-js/chunks/{chunk-VZNLY6BP.js → chunk-BWM5IA32.js}

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

package/dist/safe-js/chunks/{chunk-7XAXYVOY.js → chunk-ZOPU6AKV.js}

@@ -10832,6 +10832,8 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure, use
   );
 }
 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 = "";
@@ -10843,7 +10845,7 @@ async function replaceRegex(value, regex, replacement, budget, callClosure, cont
     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) : await sandboxString(
+      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
@@ -10856,45 +10858,154 @@ 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, context) {
   const offsets = findReplacementOffsets(value, searchValue, replaceAll);
@@ -34234,16 +34345,38 @@ function createRegexGlobals(options) {
     const operation = options.budget.acquireCompileOwner(false, selected);
     const compilation = context?.compilation?.owner === operation.owner ? context.compilation : new CompileScope(operation.owner);
     let source = "";
+    let retainedSource;
+    let retainedFlags;
     const retained = {};
-    options.budget.setRetainedValues(retained, () => [...args, source]);
+    options.budget.setRetainedValues(retained, () => [...args, source, retainedSource, retainedFlags]);
     try {
       const pattern = args[0];
       const flags = args[1];
-      if (!construct && isSandboxRegex(pattern) && flags === void 0) return pattern;
-      const sourceValue = isSandboxRegex(pattern) ? pattern.source : pattern;
-      const flagsValue = isSandboxRegex(pattern) && flags === void 0 ? pattern.flags : flags;
+      const read = (key) => {
+        const descriptor = getSandboxPropertyDescriptor(pattern, key, options.budget);
+        if (key === "constructor" && descriptor === void 0 && isSandboxRegex(pattern)) return constructor;
+        if (context?.getProperty !== void 0) return context.getProperty(pattern, key);
+        return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, pattern, context);
+      };
+      let regexLike = false;
+      if (pattern !== null && typeof pattern === "object") {
+        const match = await read(Symbol.match);
+        regexLike = match === void 0 ? isSandboxRegex(pattern) : Boolean(match);
+      }
+      if (!construct && regexLike && flags === void 0 && await read("constructor") === constructor) return pattern;
+      let sourceValue = pattern;
+      let flagsValue = flags;
+      if (isSandboxRegex(pattern)) {
+        sourceValue = pattern.source;
+        if (flags === void 0) flagsValue = pattern.flags;
+      } else if (regexLike) {
+        sourceValue = retainedSource = await read("source");
+        if (flags === void 0) flagsValue = retainedFlags = await read("flags");
+      }
       source = sourceValue === void 0 ? "" : await sandboxString(sourceValue, options.budget, context);
+      retainedSource = void 0;
       const flagText = flagsValue === void 0 ? "" : await sandboxString(flagsValue, options.budget, context);
+      retainedFlags = void 0;
       const regex = createSandboxRegex(
         source,
         flagText,
@@ -34260,9 +34393,8 @@ function createRegexGlobals(options) {
       operation.release();
     }
   };
-  return {
-    RegExp: createSandboxClosure({ sandbox: true, name: "RegExp", call: invoke(false), construct: invoke(true) })
-  };
+  const constructor = createSandboxClosure({ sandbox: true, name: "RegExp", call: invoke(false), construct: invoke(true) });
+  return { RegExp: constructor };
 }
 
 // packages/safe-js/src/interp/globals/misc.ts
@@ -36575,4 +36707,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-7XAXYVOY.js.map
+//# sourceMappingURL=chunk-ZOPU6AKV.js.map