poe-code 14.0.55 → 14.0.57

package/dist/index.js

@@ -127268,7 +127268,7 @@ function encodeReplayData(value, options = {}) {
         kind: "regex",
         source: entry.source,
         flags: entry.flags,
-        lastIndex: entry.lastIndex
+        lastIndex: child(entry.lastIndex, "lastIndex")
       };
     } else if (isSandboxArguments(entry)) {
       nodes[id] = { kind: "arguments", data: serializeArguments(entry, child) };
@@ -127435,11 +127435,12 @@ function decodeReplayData(input, options = {}, parent) {
         return result3;
       }
       if (kind === "regex") {
-        if (typeof node.source !== "string" || typeof node.flags !== "string" || typeof node.lastIndex !== "number" || !Number.isFinite(node.lastIndex)) {
+        if (typeof node.source !== "string" || typeof node.flags !== "string" || !Object.hasOwn(node, "lastIndex")) {
           throw new TypeError("Invalid replay regular expression.");
         }
-        const result3 = createSandboxRegex(node.source, node.flags, node.lastIndex, compilation);
+        const result3 = createSandboxRegex(node.source, node.flags, 0, compilation);
         restored.set(id, result3);
+        result3.lastIndex = child(own(node, "lastIndex"));
         return result3;
       }
       if (kind === "arguments") {
@@ -128445,10 +128446,10 @@ function charge(context) {
   allocateRegexSteps(context.steps);
 }
 function normalizeLastIndex(lastIndex) {
-  if (!Number.isFinite(lastIndex) || lastIndex <= 0) {
+  if (Number.isNaN(lastIndex) || lastIndex <= 0) {
     return 0;
   }
-  return Math.floor(lastIndex);
+  return Math.min(Math.floor(lastIndex), Number.MAX_SAFE_INTEGER);
 }
 function charactersEqual(left, right, ignoreCase) {
   return left !== void 0 && foldCharacter(left, ignoreCase) === foldCharacter(right, ignoreCase);
@@ -128496,13 +128497,14 @@ function getRegexMember(target, property, budget) {
     return budget === void 0 ? flags : budget.allocateString(flags);
   }
   if (property === "lastIndex") return target.lastIndex;
+  if (Object.hasOwn(regexFlagProperties, property)) return target.flags.includes(regexFlagProperties[property]);
   if (!isRegexMethodName(property)) {
     return void 0;
   }
   return createSandboxClosure({
     sandbox: true,
     name: `RegExp#${property}`,
-    call: (args) => callRegexMethod(target, property, args)
+    call: (args, context) => callRegexMethod(context?.thisValue, property, args, budget, context)
   });
 }
 function escapeRegexSource(source, budget) {
@@ -128530,15 +128532,41 @@ function setRegexMember(target, property, value) {
   if (property !== "lastIndex") {
     throw new TypeError(`RegExp#${String(property)} is not writable.`);
   }
-  target.lastIndex = Number(value);
+  target.lastIndex = value;
 }
-function callRegexMethod(target, methodName, args) {
-  const match = executeRegex(target, String(args[0]));
-  return methodName === "test" ? match !== null : toMatchArray(match, String(args[0]));
+async function callRegexMethod(target, methodName, args, budget, context) {
+  if (target === null || typeof target !== "object" || methodName === "exec" && !isSandboxRegex(target)) {
+    throw new TypeError(`RegExp#${methodName} requires ${methodName === "exec" ? "a regex" : "an object"} receiver.`);
+  }
+  const retained = {};
+  let cursor2;
+  let convertedInput;
+  budget.setRetainedValues(retained, () => [target, ...args, cursor2, convertedInput]);
+  try {
+    const input = await sandboxString(args[0], budget, context);
+    if (methodName === "test") {
+      const exec2 = context?.getProperty === void 0 ? getSandboxDataProperty(target, "exec", budget) : context.getProperty(target, "exec");
+      if (isSandboxClosure(exec2)) {
+        const result = await invokeBuiltinClosure(exec2, [input], budget, context, target);
+        if (result !== null && typeof result !== "object") {
+          throw new TypeError("RegExp#test exec must return an object or null.");
+        }
+        return result !== null;
+      }
+    }
+    if (!isSandboxRegex(target)) throw new TypeError("RegExp execution requires a regex receiver.");
+    if (typeof args[0] !== "string") convertedInput = input;
+    cursor2 = target.lastIndex;
+    const lastIndex = await sandboxNumber(cursor2, budget, context);
+    const match = executeRegex(target, input, lastIndex);
+    return methodName === "test" ? match !== null : toMatchArray(match, input);
+  } finally {
+    budget.setRetainedValues(retained, void 0);
+  }
 }
-function executeRegex(target, input) {
+function executeRegex(target, input, lastIndex) {
   const pattern = getSandboxRegexPattern(target);
-  const match = matchRegex(pattern, input, target.lastIndex);
+  const match = matchRegex(pattern, input, lastIndex);
   if (pattern.flags.global) {
     target.lastIndex = match === null ? 0 : match.index + match.text.length;
   }
@@ -128552,13 +128580,26 @@ function toMatchArray(match, input) {
   Object.assign(result, { index: match.index, input, groups: void 0 });
   return result;
 }
-var regexMethodNames;
+var regexMethodNames, regexFlagProperties;
 var init_regex = __esm({
   "packages/safe-js/src/interp/methods/regex.ts"() {
     "use strict";
     init_values();
     init_engine2();
+    init_builtin_call();
+    init_object_model();
+    init_string_coercion();
     regexMethodNames = /* @__PURE__ */ new Set(["exec", "test"]);
+    regexFlagProperties = {
+      hasIndices: "d",
+      global: "g",
+      ignoreCase: "i",
+      multiline: "m",
+      dotAll: "s",
+      unicode: "u",
+      unicodeSets: "v",
+      sticky: "y"
+    };
   }
 });
 
@@ -130549,13 +130590,14 @@ function deepCopyToSandbox(value) {
     seen: /* @__PURE__ */ new WeakMap()
   });
 }
-function cloneSandboxValue(value) {
+function cloneSandboxValue(value, options = {}) {
   const initializeIterators = [];
   const copy = copyToSandbox(
     value,
     {
       seen: /* @__PURE__ */ new WeakMap(),
-      initializeIterators
+      initializeIterators,
+      ...options
     },
     "<root>",
     true
@@ -130654,11 +130696,12 @@ function measureSandboxData(values, options = {}) {
     }
     if (isSandboxPromise(value)) return;
     if (isSandboxRegex(value)) {
-      const { source, flags } = captureRegexData(value);
+      const { source, flags, lastIndex } = captureRegexData(value);
       const compiled = regexCompiledData(getSandboxRegexPattern(value));
       const staged = compiled.ticket === void 0 ? 0 : compiled.ticket.owner.budget.compileTicketUsage(compiled.ticket);
       usage += Math.max(6 + source.length + flags.length + compiled.units, staged - 1);
       if (compiled.ticket !== void 0) options.compileTickets?.add(compiled.ticket);
+      visit(lastIndex, depth + 1);
       return;
     }
     if (isSandboxArguments(value)) {
@@ -130739,7 +130782,16 @@ function copyToSandbox(value, state, path193 = "<root>", cloneSandboxCollections
     return value;
   }
   if (isLiveCapability(value)) throw new TypeError("Live capabilities require their owning realm bridge.");
-  if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxRegex(value) || isSandboxPromise(value)) {
+  if (isSandboxRegex(value)) {
+    if (!cloneSandboxCollections) return value;
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = createSandboxRegex(value.source, value.flags, 0, state.compilation);
+    state.seen.set(value, copy);
+    if (!state.resetRegexLastIndex) copy.lastIndex = copyToSandbox(value.lastIndex, state, `${path193}.lastIndex`, true, depth + 1);
+    return copy;
+  }
+  if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxPromise(value)) {
     return value;
   }
   if (isSandboxCollectionIterator(value)) {
@@ -130948,9 +131000,9 @@ function copyFromSandbox(value, state, path193 = "<root>", options, depth = 0) {
       if (existing !== void 0) return existing;
       guard.allocate(1 + source.length + flags.length);
       const regex = new RegExp(source, flags);
-      regex.lastIndex = lastIndex;
-      guard.retainScratch();
       state.seen.set(value, regex);
+      Reflect.set(regex, "lastIndex", copyFromSandbox(lastIndex, state, `${path193}.lastIndex`, options, depth + 1));
+      guard.retainScratch();
       return regex;
     } finally {
       guard.close();
@@ -131832,7 +131884,7 @@ function validateTaggedValue(record2, path193, state) {
     case "undefined":
       return;
     case "number":
-      if (!["-Infinity", "Infinity", "NaN"].includes(String(record2.value))) {
+      if (!["-Infinity", "Infinity", "NaN", "-0"].includes(String(record2.value))) {
         fail2("invalidValue", `${path193}.value`, "unknown non-finite number value");
       }
       return;
@@ -131854,6 +131906,11 @@ function validateTaggedValue(record2, path193, state) {
       requireString2(record2.flags, `${path193}.flags`, state.limits);
       requireSafeInteger(record2.lastIndex, `${path193}.lastIndex`, 0);
       return;
+    case "regex-object":
+      requireString2(record2.source, `${path193}.source`, state.limits);
+      requireString2(record2.flags, `${path193}.flags`, state.limits);
+      if (!Object.hasOwn(record2, "lastIndex")) fail2("invalidValue", `${path193}.lastIndex`, "missing regex cursor");
+      return;
     case "array":
     case "arguments":
     case "object":
@@ -145226,7 +145283,11 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
     return budget.allocateString(result + value.slice(spanStart));
   }
   if (methodName === "replace" || methodName === "replaceAll") {
-    return callReplaceLikeMethod(value, methodName, args, budget, callClosure);
+    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"))) {
+    return callStringRegexCursor(value, methodName, regex, budget, parent, context);
   }
   if ((methodName === "match" || methodName === "matchAll" || methodName === "search") && !isSandboxRegex(args[0])) {
     return callStringPattern(value, methodName, args[0], budget, parent, context);
@@ -145341,7 +145402,7 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
     operation.release();
   }
 }
-function callReplaceLikeMethod(value, methodName, args, budget, callClosure) {
+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)) {
@@ -145359,7 +145420,8 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure) {
       replacement,
       methodName === "replaceAll",
       budget,
-      callClosure
+      callClosure,
+      context
     );
   }
   if (typeof replacement === "string") {
@@ -145376,20 +145438,28 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure) {
     callClosure
   );
 }
-async function replaceRegex(value, regex, replacement, replaceAll2, budget, callClosure) {
+async function replaceRegex(value, regex, replacement, replaceAll2, budget, callClosure, context) {
   if (regex.flags.includes("g")) regex.lastIndex = 0;
-  const matches = collectRegexMatches(regex, value, replaceAll2 || regex.flags.includes("g"));
-  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])
-    );
-    copiedThrough = match.index + match.text.length;
+  const cursor2 = regex.lastIndex;
+  const retained = {};
+  budget.setRetainedValues(retained, () => [value, regex, cursor2, replacement]);
+  try {
+    const lastIndex = await sandboxNumber(cursor2, budget, context);
+    const matches = collectRegexMatches(regex, value, replaceAll2 || 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])
+      );
+      copiedThrough = match.index + match.text.length;
+    }
+    result += value.slice(copiedThrough);
+    return budget.allocateString(result);
+  } finally {
+    budget.setRetainedValues(retained, void 0);
   }
-  result += value.slice(copiedThrough);
-  return budget.allocateString(result);
 }
 function expandReplacement(replacement, match, captures, input, matchIndex) {
   let result = "";
@@ -145505,7 +145575,7 @@ async function callStringPattern(value, methodName, pattern, budget, parent, con
   const operation = budget.acquireCompileOwner(false, parent?.owner);
   const compilation = new CompileScope(operation.owner);
   const retainedPattern = {};
-  budget.setRetainedValues(retainedPattern, () => [pattern]);
+  budget.setRetainedValues(retainedPattern, () => [value, pattern]);
   try {
     const source = pattern === void 0 ? "" : await sandboxString(pattern, budget, context);
     const regex = createSandboxRegex(source, methodName === "matchAll" ? "g" : "", 0, compilation);
@@ -145516,35 +145586,51 @@ async function callStringPattern(value, methodName, pattern, budget, parent, con
     operation.release();
   }
 }
-function callMatchLikeMethod(value, methodName, args, compilation) {
+async function callStringRegexCursor(value, methodName, regex, budget, parent, context) {
+  const operation = budget.acquireCompileOwner(false, parent?.owner);
+  const compilation = new CompileScope(operation.owner);
+  const cursor2 = regex.lastIndex;
+  const retained = {};
+  budget.setRetainedValues(retained, () => [value, regex, cursor2]);
+  try {
+    const lastIndex = await sandboxNumber(cursor2, budget, context);
+    return callMatchLikeMethod(value, methodName, [regex], compilation, lastIndex);
+  } finally {
+    budget.setRetainedValues(retained, void 0);
+    compilation.dispose();
+    operation.release();
+  }
+}
+function callMatchLikeMethod(value, methodName, args, compilation, lastIndex) {
   const regex = args[0];
   if (!isSandboxRegex(regex))
     throw new TypeError(`String#${methodName} requires a regex argument.`);
   if (methodName === "search") {
-    const lastIndex = regex.lastIndex;
-    if (!Object.is(lastIndex, 0)) regex.lastIndex = 0;
-    const match = executeRegex(regex, value);
-    if (!Object.is(regex.lastIndex, lastIndex)) regex.lastIndex = lastIndex;
+    const lastIndex2 = regex.lastIndex;
+    if (!Object.is(lastIndex2, 0)) regex.lastIndex = 0;
+    const match = executeRegex(regex, value, 0);
+    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), value);
+    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, regex.lastIndex, compilation) : regex;
-  const matches = collectRegexMatches(matcher, value, true, compilation.owner?.budget);
+  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));
   if (methodName === "match" && matches.length === 0) return null;
   return methodName === "match" ? matches.map((match) => match.text) : matches.map((match) => toMatchArray(match, value));
 }
-function collectRegexMatches(regex, value, all, budget) {
+function collectRegexMatches(regex, value, all, budget, lastIndex = 0) {
   const matches = [];
   do {
-    const match = executeRegex(regex, value);
+    const match = executeRegex(regex, value, lastIndex);
     if (match === null) break;
     budget?.allocateArrayLength(matches.length + 1);
     matches.push(match);
-    if (all && match.text.length === 0) regex.lastIndex += 1;
+    lastIndex = match.index + match.text.length;
+    if (all && match.text.length === 0) regex.lastIndex = ++lastIndex;
   } while (all);
   return matches;
 }
@@ -145567,6 +145653,7 @@ var init_string = __esm({
     "use strict";
     init_builtin_call();
     init_compile_guard();
+    init_engine2();
     init_string_coercion();
     init_values();
     init_regex();
@@ -151088,7 +151175,7 @@ function createMiscGlobals(options) {
   return {
     structuredClone: createSandboxClosure({
       sandbox: true,
-      call: ([value]) => structuredCloneSandboxValue(value, options.budget),
+      call: ([value], context) => structuredCloneSandboxValue(value, options.budget, context?.compilation),
       name: "structuredClone"
     }),
     parseInt: createSandboxClosure({
@@ -151113,11 +151200,20 @@ function createMiscGlobals(options) {
     })
   };
 }
-function structuredCloneSandboxValue(value, budget) {
-  assertSandboxGraphDepth(value);
-  const clone = cloneSandboxValue(value);
-  assertStructuredCloneable(clone, /* @__PURE__ */ new WeakSet());
-  return allocateProducedSandboxValue(clone, budget);
+function structuredCloneSandboxValue(value, budget, parent) {
+  const operation = budget.acquireCompileOwner(false, parent?.owner);
+  const compilation = parent?.owner === operation.owner ? parent : new CompileScope(operation.owner);
+  try {
+    const clone = cloneSandboxValue(value, { compilation, resetRegexLastIndex: true });
+    assertSandboxGraphDepth(clone);
+    assertStructuredCloneable(clone, /* @__PURE__ */ new WeakSet());
+    allocateProducedSandboxValue(clone, budget);
+    if (compilation !== parent) reconcileCompiledValues(budget, [clone], compilation);
+    return clone;
+  } finally {
+    if (compilation !== parent) compilation.dispose();
+    operation.release();
+  }
 }
 function assertStructuredCloneable(value, seen) {
   if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value)) {
@@ -151149,6 +151245,7 @@ var init_misc = __esm({
     "use strict";
     init_collection_iterator();
     init_graph_depth();
+    init_compile_guard();
     init_values();
   }
 });