poe-code 14.0.73 → 14.0.74

package/dist/index.js

@@ -12249,7 +12249,7 @@ function matchSubsequence(query, text5) {
   const textCharacters = Array.from(text5);
   let previousStates = [];
   for (let queryIndex = 0; queryIndex < queryCharacters.length; queryIndex += 1) {
-    const states2 = [];
+    const states3 = [];
     let offset = 0;
     for (let textIndex = 0; textIndex < textCharacters.length; textIndex += 1) {
       const character2 = textCharacters[textIndex];
@@ -12260,7 +12260,7 @@ function matchSubsequence(query, text5) {
       }
       const positions = character2.length === 2 ? [position, position + 1] : [position];
       if (queryIndex === 0) {
-        states2[textIndex] = {
+        states3[textIndex] = {
           score: characterScore(textCharacters, textIndex, void 0) + Math.max(0, EARLY_MATCH_BONUS - position),
           positions
         };
@@ -12275,12 +12275,12 @@ function matchSubsequence(query, text5) {
           score: previous.score + characterScore(textCharacters, textIndex, previousIndex),
           positions: [...previous.positions, ...positions]
         };
-        if (isBetterMatch(next, states2[textIndex])) {
-          states2[textIndex] = next;
+        if (isBetterMatch(next, states3[textIndex])) {
+          states3[textIndex] = next;
         }
       }
     }
-    previousStates = states2;
+    previousStates = states3;
     if (!previousStates.some((state) => state !== void 0)) {
       return void 0;
     }
@@ -21524,14 +21524,14 @@ function validateMachine(machine) {
   if (!hasOwnRecordField(machine, "states") || !isStateList(machine.states)) {
     throw new TypeError("State machine states must be a string array.");
   }
-  const states2 = new Set(machine.states);
+  const states3 = new Set(machine.states);
   if (machine.states.some((state) => !hasVisibleName(state))) {
     throw new Error("State names must not be empty.");
   }
   if (!hasOwnRecordField(machine, "initial") || typeof machine.initial !== "string") {
     throw new TypeError("State machine initial must be a string.");
   }
-  if (!states2.has(machine.initial)) {
+  if (!states3.has(machine.initial)) {
     throw new Error(`Initial state "${machine.initial}" is not declared.`);
   }
   if (!hasOwnRecordField(machine, "events") || !isRecord9(machine.events)) {
@@ -21550,12 +21550,12 @@ function validateMachine(machine) {
     if (!hasOwnRecordField(event, "to") || typeof event.to !== "string") {
       throw new TypeError(`Event "${eventName}" target state must be a string.`);
     }
-    if (!states2.has(event.to)) {
+    if (!states3.has(event.to)) {
       throw new Error(`Event "${eventName}" references unknown target state "${event.to}".`);
     }
     if (event.from !== "*") {
       for (const fromState of event.from) {
-        if (!states2.has(fromState)) {
+        if (!states3.has(fromState)) {
           throw new Error(`Event "${eventName}" references unknown source state "${fromState}".`);
         }
       }
@@ -23953,13 +23953,13 @@ async function ghIssuesBackend(deps) {
 }
 function createProjectSession(project, field, labelPrefix) {
   const statusOptions = new Map(field.options.map((option) => [option.name, option.id]));
-  const states2 = field.options.map((option) => option.name);
+  const states3 = field.options.map((option) => option.name);
   const events = Object.fromEntries(
-    states2.map((state) => [state, Object.freeze({ from: "*", to: state })])
+    states3.map((state) => [state, Object.freeze({ from: "*", to: state })])
   );
   const stateMachine = Object.freeze({
-    states: Object.freeze([...states2]),
-    initial: states2[0],
+    states: Object.freeze([...states3]),
+    initial: states3[0],
     events: Object.freeze(events)
   });
   return Object.freeze({
@@ -80210,8 +80210,8 @@ function hasEmptyStringValue(value) {
   }
   return Object.values(value).some((entry) => hasEmptyStringValue(entry));
 }
-function hasOwnState(states2, state) {
-  return Object.prototype.hasOwnProperty.call(states2, state);
+function hasOwnState(states3, state) {
+  return Object.prototype.hasOwnProperty.call(states3, state);
 }
 function getOwnEntry29(record2, key3) {
   return Object.prototype.hasOwnProperty.call(record2, key3) ? record2[key3] : void 0;
@@ -80245,7 +80245,7 @@ import path98 from "node:path";
 function resolveConfig2(raw, cwd) {
   const rawConfig = isRecord31(raw) ? raw : {};
   const scoped = resolveScope(maestroConfigScope, rawConfig, process.env);
-  const { states: states2, stateOrder } = parseStates(getOwnEntry30(rawConfig, "states"));
+  const { states: states3, stateOrder } = parseStates(getOwnEntry30(rawConfig, "states"));
   const polling = scoped.polling;
   const workspace = scoped.workspace;
   const agent3 = scoped.agent;
@@ -80254,9 +80254,9 @@ function resolveConfig2(raw, cwd) {
   }
   return {
     tasks: resolveTasks(getOwnEntry30(rawConfig, "tasks"), cwd),
-    states: states2,
-    activeStateNames: stateOrder.filter((name) => states2[name]?.prompt !== void 0),
-    terminalStateNames: stateOrder.filter((name) => states2[name]?.terminal === true),
+    states: states3,
+    activeStateNames: stateOrder.filter((name) => states3[name]?.prompt !== void 0),
+    terminalStateNames: stateOrder.filter((name) => states3[name]?.terminal === true),
     stateOrder,
     polling: {
       intervalMs: readPositiveInteger(
@@ -80289,13 +80289,13 @@ function resolveConfig2(raw, cwd) {
 }
 function parseStates(value) {
   validateStateDefinitions(value);
-  const states2 = /* @__PURE__ */ Object.create(null);
+  const states3 = /* @__PURE__ */ Object.create(null);
   const stateOrder = [];
   const entries = value instanceof Map ? value.entries() : Object.entries(value);
   for (const [name, rawDefinition] of entries) {
     const stateName = String(name);
     const definition = rawDefinition;
-    Object.defineProperty(states2, stateName, {
+    Object.defineProperty(states3, stateName, {
       configurable: true,
       enumerable: true,
       value: parseStateDefinition(definition),
@@ -80303,7 +80303,7 @@ function parseStates(value) {
     });
     stateOrder.push(stateName);
   }
-  return { states: states2, stateOrder };
+  return { states: states3, stateOrder };
 }
 function parseStateDefinition(definition) {
   const state = {};
@@ -81573,8 +81573,8 @@ var init_phases = __esm({
 function isRunningPhase(phase) {
   return phase === "running-step";
 }
-function hasOwnState2(states2, state) {
-  return Object.prototype.hasOwnProperty.call(states2, state);
+function hasOwnState2(states3, state) {
+  return Object.prototype.hasOwnProperty.call(states3, state);
 }
 function isAbortError5(error3) {
   return error3 instanceof Error && error3.name === "AbortError";
@@ -82697,7 +82697,7 @@ function createStateStore(stateDir, fs31 = nodeFs7) {
       }
       throw error3;
     }
-    const states2 = [];
+    const states3 = [];
     for (const entry of [...entries].sort()) {
       if (entry.startsWith(REMOVED_STATE_PREFIX)) {
         continue;
@@ -82716,10 +82716,10 @@ function createStateStore(stateDir, fs31 = nodeFs7) {
       }
       const state = await read(entry);
       if (state !== null) {
-        states2.push(state);
+        states3.push(state);
       }
     }
-    return states2;
+    return states3;
   }
   async function remove2(id) {
     const processDir = resolveProcessDir(stateDir, id);
@@ -102105,13 +102105,13 @@ function markApprovalsBuiltIn(group) {
 function isApprovalsBuiltIn(node) {
   return node.kind === "group" && node[approvalsGroupSymbol] === true;
 }
-async function loadApprovals(tasks, states2 = []) {
-  if (states2.length === 0) {
+async function loadApprovals(tasks, states3 = []) {
+  if (states3.length === 0) {
     return tasks.all();
   }
   const seenIds = /* @__PURE__ */ new Set();
   const approvals = [];
-  for (const state of states2) {
+  for (const state of states3) {
     const matching = await tasks.all({
       state
     });
@@ -126223,6 +126223,29 @@ var init_collection_iterator = __esm({
   }
 });
 
+// packages/safe-js/src/interp/regexp-iterator.ts
+function isSandboxRegExpIterator(value) {
+  return typeof value === "object" && value !== null && states2.has(value);
+}
+function restoreSandboxRegExpIterator(state, target = /* @__PURE__ */ Object.create(null)) {
+  if (!state.exhausted && (state.matcher === void 0 || state.input === void 0))
+    throw new TypeError("A live RegExp iterator requires its matcher and input.");
+  states2.set(target, state.exhausted ? { matcher: void 0, input: void 0, exhausted: true } : { ...state });
+  return target;
+}
+function regexpIteratorState(value) {
+  const state = states2.get(value);
+  if (state === void 0) throw new TypeError("Expected a RegExp string iterator.");
+  return state;
+}
+var states2;
+var init_regexp_iterator = __esm({
+  "packages/safe-js/src/interp/regexp-iterator.ts"() {
+    "use strict";
+    states2 = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // packages/safe-js/src/interp/date.ts
 import { types } from "node:util";
 function isSandboxDate(value) {
@@ -127475,6 +127498,7 @@ function graphEntries(value) {
   }
   const entries = [];
   if (isSandboxCollectionIterator(value)) entries.push([".<collection>", collectionIteratorState(value).collection]);
+  if (isSandboxRegExpIterator(value)) entries.push([".<matcher>", regexpIteratorState(value).matcher]);
   for (const key3 of Object.keys(value)) {
     const descriptor = Object.getOwnPropertyDescriptor(value, key3);
     if (descriptor !== void 0 && "value" in descriptor)
@@ -127490,6 +127514,7 @@ var init_graph_depth = __esm({
     init_budget2();
     init_arguments();
     init_collection_iterator();
+    init_regexp_iterator();
     init_collection_brands();
     init_boxed();
     init_regexp_properties();
@@ -127571,6 +127596,21 @@ function installBoxedPrototype(budget, prototype, constructor, kind = typeof box
 function getBoxedPrototype(value, budget) {
   return boxedPrototypes.get(budget)?.get(typeof value);
 }
+function installRegexPrototype(budget, prototype, constructor) {
+  regexPrototypes.set(budget, prototype);
+  initialRegexDescriptors.set(budget, Object.getOwnPropertyDescriptors(prototype));
+  registerIntrinsicPrototype(budget, prototype, constructor);
+}
+function hasRegexPropertyOverride(value, keys, budget) {
+  const initial = initialRegexDescriptors.get(budget);
+  const prototype = regexPrototypes.get(budget);
+  const defaultPrototype = isSandboxRegex(value) && prototype !== void 0 && getSandboxPrototype(value, budget) === prototype;
+  return keys.some((key3) => {
+    const current = defaultPrototype ? Object.getOwnPropertyDescriptor(getRegexProperties(value), key3) ?? Object.getOwnPropertyDescriptor(prototype, key3) : getSandboxPropertyDescriptor(value, key3, budget);
+    const expected = initial?.[key3];
+    return expected === void 0 ? current !== void 0 : current === void 0 || current.value !== expected.value || current.get !== expected.get || current.set !== expected.set;
+  });
+}
 function isDefaultBoxedMethod(value, key3, budget) {
   const prototype = getBoxedPrototype(value, budget);
   return prototype !== void 0 && initialBoxedMethods.get(prototype)?.has(key3) === true && Object.getOwnPropertyDescriptor(prototype, key3)?.value === initialBoxedMethods.get(prototype)?.get(key3);
@@ -127582,30 +127622,32 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
   let roots = intrinsicPrototypeRoots.get(budget);
   if (roots === void 0) intrinsicPrototypeRoots.set(budget, roots = /* @__PURE__ */ new Set());
   roots.add(prototype);
-  const records = [prototype, constructor].map((target) => ({
+  const methods = Reflect.ownKeys(prototype).map((key3) => Object.getOwnPropertyDescriptor(prototype, key3)?.value).filter(isGuestClosure);
+  const records = [.../* @__PURE__ */ new Set([prototype, constructor, ...methods])].map((target) => ({
     target,
     value: isGuestClosure(target) ? materializeFunctionProperties(target) : target,
     prototype: getSandboxPrototype(target),
     explicit: hasExplicitSandboxPrototype(target)
   })).map((record2) => ({
     ...record2,
-    descriptors: new Map(Object.entries(Object.getOwnPropertyDescriptors(record2.value)))
+    descriptors: new Map(Reflect.ownKeys(record2.value).map((key3) => [key3, Object.getOwnPropertyDescriptor(record2.value, key3)]))
   }));
   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;
   intrinsicConstructors.set(
     constructor,
     () => records.every(({ target, value, descriptors, prototype: parent, explicit }) => {
       const current = Object.getOwnPropertyDescriptors(value);
-      return getSandboxPrototype(target) === parent && hasExplicitSandboxPrototype(target) === explicit && Object.keys(current).length === descriptors.size && Object.keys(current).every((key3) => unchanged(descriptors.get(key3), current[key3]));
+      return getSandboxPrototype(target) === parent && hasExplicitSandboxPrototype(target) === explicit && Reflect.ownKeys(current).length === descriptors.size && Reflect.ownKeys(value).every((key3) => unchanged(descriptors.get(key3), Object.getOwnPropertyDescriptor(value, key3)));
     })
   );
   budget.setRetainedValues(
     prototype,
     () => records.flatMap(({ target, value, descriptors, prototype: parent }) => [
       ...getSandboxPrototype(target) === parent ? [] : [getSandboxPrototype(target)],
-      ...Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(
-        ([key3, descriptor]) => unchanged(descriptors.get(key3), descriptor) ? [] : [key3, descriptor.value, ...retainedAccessorClosures(descriptor)]
-      )
+      ...Reflect.ownKeys(value).flatMap((key3) => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key3);
+        return unchanged(descriptors.get(key3), descriptor) ? [] : [key3, descriptor.value, ...retainedAccessorClosures(descriptor)];
+      })
     ])
   );
 }
@@ -127613,10 +127655,13 @@ function releaseObjectPrototype(budget) {
   for (const prototype of intrinsicPrototypeRoots.get(budget) ?? []) budget.setRetainedValues(prototype, void 0);
   intrinsicPrototypeRoots.delete(budget);
   boxedPrototypes.delete(budget);
+  regexPrototypes.delete(budget);
+  initialRegexDescriptors.delete(budget);
   intrinsicPrototypes.delete(budget);
 }
 function getSandboxPrototype(value, budget) {
   if (prototypes.has(value)) return prototypes.get(value) ?? null;
+  if (budget !== void 0 && isSandboxRegex(value)) return regexPrototypes.get(budget) ?? null;
   if (budget !== void 0 && isSandboxBox(value)) {
     const prototype = getBoxedPrototype(boxedValue(value), budget);
     if (prototype !== void 0 && prototype !== value) return prototype;
@@ -127672,13 +127717,13 @@ function setSandboxPrototype(value, prototype, budget) {
   if (budget !== void 0 && intrinsicPrototypes.get(budget) === value && prototype !== null) {
     throw new TypeError("Object.prototype has an immutable null prototype.");
   }
-  if (!Array.isArray(value) && !isPrototypeRecord(value) || prototype !== null && !Array.isArray(prototype) && !isPrototypeRecord(prototype)) {
+  if (!Array.isArray(value) && !isSandboxRegex(value) && !isPrototypeRecord(value) || prototype !== null && !Array.isArray(prototype) && !isPrototypeRecord(prototype)) {
     throw new TypeError(
       "Prototype links require ordinary sandbox objects, arrays, or guest functions."
     );
   }
   if (prototypes.has(value) && getSandboxPrototype(value, budget) === prototype) return;
-  if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : value)) {
+  if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value)) {
     throw new TypeError("Cannot change the prototype of a non-extensible object.");
   }
   let depth = 0;
@@ -127713,7 +127758,7 @@ function hasGuestObjectState(value) {
     (descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable
   );
 }
-var guestClosures, functionProperties, prototypes, intrinsicPrototypes, boxedPrototypes, intrinsicPrototypeRoots, intrinsicConstructors, initialBoxedMethods, descriptorObjects;
+var guestClosures, functionProperties, prototypes, intrinsicPrototypes, boxedPrototypes, regexPrototypes, initialRegexDescriptors, intrinsicPrototypeRoots, intrinsicConstructors, initialBoxedMethods, descriptorObjects;
 var init_object_model = __esm({
   "packages/safe-js/src/interp/object-model.ts"() {
     "use strict";
@@ -127728,6 +127773,8 @@ var init_object_model = __esm({
     prototypes = /* @__PURE__ */ new WeakMap();
     intrinsicPrototypes = /* @__PURE__ */ new WeakMap();
     boxedPrototypes = /* @__PURE__ */ new WeakMap();
+    regexPrototypes = /* @__PURE__ */ new WeakMap();
+    initialRegexDescriptors = /* @__PURE__ */ new WeakMap();
     intrinsicPrototypeRoots = /* @__PURE__ */ new WeakMap();
     intrinsicConstructors = /* @__PURE__ */ new WeakMap();
     initialBoxedMethods = /* @__PURE__ */ new WeakMap();
@@ -128014,6 +128061,16 @@ function encodeReplayData(value, options = {}) {
         };
       }
       nodes[id] = { ...storage2, properties, extensible: Object.isExtensible(entry) };
+    } else if (isSandboxRegExpIterator(entry)) {
+      const snapshot2 = regexpIteratorState(entry);
+      const properties = /* @__PURE__ */ Object.create(null);
+      for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(entry))) {
+        if (!("value" in descriptor)) throw new TypeError(`Cannot record replay data accessor '${key3}'.`);
+        properties[key3] = { value: child(descriptor.value, JSON.stringify(["property", key3])), configurable: descriptor.configurable === true, enumerable: descriptor.enumerable === true, writable: descriptor.writable === true };
+      }
+      let symbolIndex = 0;
+      const symbolEntries = serializeSymbolProperties(entry, (value2) => encode(value2, depth + 1, [...path193, { symbol: Math.floor(symbolIndex++ / 2) }]));
+      nodes[id] = { kind: "regexp-iterator", matcher: child(snapshot2.matcher, "<matcher>"), input: child(snapshot2.input, "<input>"), exhausted: snapshot2.exhausted, properties, extensible: Object.isExtensible(entry), symbolEntries };
     } else if (isSandboxCollectionIterator(entry)) {
       const snapshot2 = snapshotCollectionIterator(entry);
       const properties = /* @__PURE__ */ Object.create(null);
@@ -128204,6 +128261,20 @@ function decodeReplayData(input, options = {}, parent) {
         if (!node.extensible) Object.preventExtensions(result3);
         return result3;
       }
+      if (kind === "regexp-iterator") {
+        const exhausted = own(node, "exhausted");
+        if (typeof exhausted !== "boolean" || typeof node.extensible !== "boolean") throw new TypeError("Invalid replay RegExp iterator.");
+        const result3 = restoreSandboxRegExpIterator({ matcher: void 0, input: void 0, exhausted: true });
+        restored.set(id, result3);
+        const matcher = child(own(node, "matcher"));
+        const input2 = child(own(node, "input"));
+        if (matcher !== void 0 && !isSandboxRegex(matcher)) throw new TypeError("Invalid replay RegExp iterator matcher.");
+        if (input2 !== void 0 && typeof input2 !== "string") throw new TypeError("Invalid replay RegExp iterator input.");
+        restoreSandboxRegExpIterator({ matcher, input: input2, exhausted }, result3);
+        defineProperties(result3, record(own(node, "properties")), child, node.symbolEntries);
+        if (!node.extensible) Object.preventExtensions(result3);
+        return result3;
+      }
       if (kind === "collection-iterator") {
         const collectionKind = own(node, "collectionKind");
         const method = own(node, "method");
@@ -128338,6 +128409,7 @@ var init_replay_data = __esm({
     init_symbols2();
     init_symbols3();
     init_collection_iterator();
+    init_regexp_iterator();
     init_object_model();
     init_compile_guard();
     init_float32();
@@ -129271,6 +129343,242 @@ var init_resources = __esm({
   }
 });
 
+// packages/safe-js/src/interp/regex/engine.ts
+function matchRegex(pattern, input, lastIndex = 0) {
+  const startIndex = pattern.flags.global ? normalizeLastIndex(lastIndex) : 0;
+  return matchRegexFrom(pattern, input, startIndex);
+}
+function matchRegexFrom(pattern, input, startIndex) {
+  if (startIndex > input.length) {
+    return null;
+  }
+  for (let attempt = startIndex; attempt <= input.length; attempt += 1) {
+    const context = { input, flags: pattern.flags, steps: 0 };
+    charge(context);
+    const initialState = {
+      position: attempt,
+      captures: new Array(pattern.captureCount)
+    };
+    const result = matchNode(pattern.body, initialState, context).next();
+    if (!result.done) {
+      return toRegexMatch(input, attempt, result.value);
+    }
+  }
+  return null;
+}
+function* matchNode(node, state, context) {
+  charge(context);
+  switch (node.type) {
+    case "empty":
+      yield state;
+      return;
+    case "literal":
+      if (charactersEqual(context.input[state.position], node.value, context.flags.ignoreCase)) {
+        yield { ...state, position: state.position + 1 };
+      }
+      return;
+    case "dot":
+      if (state.position < context.input.length && (context.flags.dotAll || !isLineTerminator(context.input[state.position]))) {
+        yield { ...state, position: state.position + 1 };
+      }
+      return;
+    case "anchor":
+      if (matchesAnchor(node.kind, state.position, context)) {
+        yield state;
+      }
+      return;
+    case "wordBoundary": {
+      const previousWord = state.position > 0 && isWordCharacter(context.input[state.position - 1]);
+      const nextWord = state.position < context.input.length && isWordCharacter(context.input[state.position]);
+      if (previousWord !== nextWord !== node.negated) {
+        yield state;
+      }
+      return;
+    }
+    case "characterClass": {
+      const character2 = context.input[state.position];
+      if (character2 !== void 0 && matchesCharacterClass(character2, node.items, node.negated, context.flags.ignoreCase)) {
+        yield { ...state, position: state.position + 1 };
+      }
+      return;
+    }
+    case "sequence":
+      yield* matchSequence(node.elements, 0, state, context);
+      return;
+    case "alternation":
+      for (const alternative of node.alternatives) {
+        yield* matchNode(alternative, cloneState(state), context);
+      }
+      return;
+    case "group":
+      for (const result of matchNode(node.body, cloneState(state), context)) {
+        if (!node.capturing || node.index === void 0) {
+          yield result;
+          continue;
+        }
+        const captures = result.captures.slice();
+        captures[node.index - 1] = { start: state.position, end: result.position };
+        yield { position: result.position, captures };
+      }
+      return;
+    case "quantifier":
+      yield* matchQuantifier(node, state, context, 0);
+  }
+}
+function* matchSequence(elements, index, state, context) {
+  charge(context);
+  if (index === elements.length) {
+    yield state;
+    return;
+  }
+  for (const result of matchNode(elements[index], state, context)) {
+    yield* matchSequence(elements, index + 1, result, context);
+  }
+}
+function* matchQuantifier(node, state, context, count) {
+  charge(context);
+  const canRepeat = node.max === void 0 || count < node.max;
+  if (!node.greedy && count >= node.min) {
+    yield state;
+  }
+  if (canRepeat) {
+    for (const result of matchNode(node.body, clearCaptures(node.body, state), context)) {
+      if (result.position === state.position) {
+        if (count >= node.min) {
+          continue;
+        }
+        if (count + 1 >= node.min) {
+          yield result;
+        } else {
+          yield* matchQuantifier(node, result, context, count + 1);
+        }
+        continue;
+      }
+      yield* matchQuantifier(node, result, context, count + 1);
+    }
+  }
+  if (node.greedy && count >= node.min) {
+    yield state;
+  }
+}
+function matchesAnchor(kind, position, context) {
+  if (kind === "start") {
+    return position === 0 || context.flags.multiline && position > 0 && isLineTerminator(context.input[position - 1]);
+  }
+  return position === context.input.length || context.flags.multiline && position < context.input.length && isLineTerminator(context.input[position]);
+}
+function matchesCharacterClass(character2, items, negated, ignoreCase) {
+  const matched = items.some((item) => matchesCharacterClassItem(character2, item, ignoreCase));
+  return negated ? !matched : matched;
+}
+function matchesCharacterClassItem(character2, item, ignoreCase) {
+  if (item.type === "character") {
+    return charactersEqual(character2, item.value, ignoreCase);
+  }
+  if (item.type === "range") {
+    const candidate = character2.charCodeAt(0);
+    const from = item.from.charCodeAt(0);
+    const to = item.to.charCodeAt(0);
+    if (candidate >= from && candidate <= to) {
+      return true;
+    }
+    if (!ignoreCase) {
+      return false;
+    }
+    const foldedCandidate = foldCharacter(character2, true).charCodeAt(0);
+    const foldedFrom = foldCharacter(item.from, true).charCodeAt(0);
+    const foldedTo = foldCharacter(item.to, true).charCodeAt(0);
+    return foldedCandidate >= foldedFrom && foldedCandidate <= foldedTo;
+  }
+  const matched = item.kind === "digit" ? isDigit5(character2) : item.kind === "word" ? isWordCharacter(character2) : isSpaceCharacter(character2);
+  return item.negated ? !matched : matched;
+}
+function toRegexMatch(input, start, state) {
+  return {
+    index: start,
+    text: input.slice(start, state.position),
+    captures: state.captures.map(
+      (capture) => capture === void 0 ? void 0 : input.slice(capture.start, capture.end)
+    )
+  };
+}
+function cloneState(state) {
+  return { position: state.position, captures: state.captures.slice() };
+}
+function clearCaptures(node, state) {
+  const captures = state.captures.slice();
+  clearNodeCaptures(node, captures);
+  return { position: state.position, captures };
+}
+function clearNodeCaptures(node, captures) {
+  if (node.type === "group") {
+    if (node.capturing && node.index !== void 0) {
+      captures[node.index - 1] = void 0;
+    }
+    clearNodeCaptures(node.body, captures);
+    return;
+  }
+  if (node.type === "sequence") {
+    for (const element of node.elements) {
+      clearNodeCaptures(element, captures);
+    }
+    return;
+  }
+  if (node.type === "alternation") {
+    for (const alternative of node.alternatives) {
+      clearNodeCaptures(alternative, captures);
+    }
+    return;
+  }
+  if (node.type === "quantifier") {
+    clearNodeCaptures(node.body, captures);
+  }
+}
+function charge(context) {
+  context.steps += 1;
+  allocateRegexSteps(context.steps);
+}
+function normalizeLastIndex(lastIndex) {
+  if (Number.isNaN(lastIndex) || lastIndex <= 0) {
+    return 0;
+  }
+  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);
+}
+function foldCharacter(character2, ignoreCase) {
+  if (!ignoreCase) {
+    return character2;
+  }
+  const folded = character2.toUpperCase();
+  if (folded.length !== 1) {
+    return character2;
+  }
+  if (character2.charCodeAt(0) >= 128 && folded.charCodeAt(0) < 128) {
+    return character2;
+  }
+  return folded;
+}
+function isDigit5(character2) {
+  return character2 >= "0" && character2 <= "9";
+}
+function isWordCharacter(character2) {
+  return isDigit5(character2) || character2 >= "A" && character2 <= "Z" || character2 >= "a" && character2 <= "z" || character2 === "_";
+}
+function isSpaceCharacter(character2) {
+  return character2 === " " || character2 === "\f" || character2 === "\n" || character2 === "\r" || character2 === "	" || character2 === "\v" || character2 === "\xA0" || character2 === "\u1680" || character2 >= "\u2000" && character2 <= "\u200A" || character2 === "\u2028" || character2 === "\u2029" || character2 === "\u202F" || character2 === "\u205F" || character2 === "\u3000" || character2 === "\uFEFF";
+}
+function isLineTerminator(character2) {
+  return character2 === "\n" || character2 === "\r" || character2 === "\u2028" || character2 === "\u2029";
+}
+var init_engine2 = __esm({
+  "packages/safe-js/src/interp/regex/engine.ts"() {
+    "use strict";
+    init_budget2();
+  }
+});
+
 // packages/safe-js/src/interp/jobs.ts
 import { AsyncLocalStorage as AsyncLocalStorage7 } from "node:async_hooks";
 function runPromiseJob(task) {
@@ -129369,616 +129677,6 @@ var init_jobs4 = __esm({
   }
 });
 
-// packages/safe-js/src/interp/iteration.ts
-async function acquireSandboxIterator(value, budget, context, asyncProtocol = false, signal) {
-  const key3 = asyncProtocol ? Symbol.asyncIterator : Symbol.iterator;
-  if (context.getProperty === void 0 || isGuestHostObject(value))
-    return asyncProtocol ? getSandboxAsyncIterator(value, budget, context, signal) : getSandboxIterator(value, budget, context);
-  if (getSandboxPropertyDescriptor(value, key3, budget) === void 0) {
-    if (!asyncProtocol) return getSandboxIterator(value, budget, context);
-    if (isSandboxGenerator(value) && value.async)
-      return getSandboxAsyncIterator(value, budget, context, signal);
-    const iterator2 = await acquireSandboxIterator(value, budget, context);
-    return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal);
-  }
-  const factory = await context.getProperty(value, key3);
-  if (factory === null || factory === void 0) {
-    if (!asyncProtocol) return void 0;
-    const iterator2 = await acquireSandboxIterator(value, budget, context);
-    return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal);
-  }
-  if (!isSandboxClosure(factory)) {
-    if (typeof factory !== "function") throw new TypeError("Iterator method must be callable.");
-    if (asyncProtocol) return nativeAsyncIterator(value, factory, signal);
-    const iterator2 = Reflect.apply(factory, value, []);
-    if (typeof iterator2 !== "object" && typeof iterator2 !== "function" || iterator2 === null)
-      throw new TypeError("Iterator must be an object.");
-    return syncIterator(iterator2);
-  }
-  const iterator = await invokeBuiltinClosure(factory, [], budget, context, value);
-  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null)
-    throw new TypeError("Iterator must be an object.");
-  const next = await context.getProperty(iterator, "next");
-  const invoke2 = async (operation, args) => {
-    if (!isSandboxClosure(operation)) throw new TypeError("Iterator operation must be callable.");
-    const returned = await invokeBuiltinClosure(operation, args, budget, context, iterator);
-    const result = asyncProtocol ? await awaitSandboxValue(returned, signal, budget) : returned;
-    if (typeof result !== "object" && typeof result !== "function" || result === null)
-      throw new TypeError("Iterator result must be an object.");
-    return result;
-  };
-  return {
-    ...asyncProtocol ? { asyncProtocol: true } : {},
-    asynchronous: true,
-    retainedValue: [value, iterator, next],
-    next: (...args) => invoke2(next, args),
-    getOperation: async (method) => {
-      const operation = method === "next" ? next : await context.getProperty(iterator, method);
-      return method !== "next" && (operation === void 0 || operation === null) ? void 0 : (...args) => invoke2(operation, args);
-    },
-    readResultProperty: async (result, property) => ({
-      value: await context.getProperty(result, property)
-    })
-  };
-}
-async function readIteratorResult(iterator, result, property) {
-  return iterator.readResultProperty === void 0 ? { value: result[property] } : iterator.readResultProperty(result, property);
-}
-function getSandboxAsyncIterator(value, budget, context, signal) {
-  if (isSandboxGenerator(value) && value.async) {
-    return { ...generatorIterator(value, budget), asyncProtocol: true };
-  }
-  if (value !== null && (typeof value === "object" || typeof value === "function") && !isGuestHostObject(value)) {
-    const method = value[Symbol.asyncIterator];
-    if (method !== void 0 && method !== null) {
-      return nativeAsyncIterator(value, method, signal);
-    }
-  }
-  const iterator = getSandboxIterator(value, budget, context);
-  return iterator === void 0 ? void 0 : asyncFromSyncIterator(iterator, budget, signal);
-}
-function nativeAsyncIterator(value, method, signal) {
-  if (typeof method !== "function") throw new TypeError("Async iterator method must be callable.");
-  const iterator = Reflect.apply(method, value, []);
-  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null) {
-    throw new TypeError("Async iterator must be an object.");
-  }
-  const next = iterator.next;
-  const invoke2 = async (operation, args) => {
-    if (typeof operation !== "function")
-      throw new TypeError("Async iterator operation must be callable.");
-    const pending = Promise.resolve(Reflect.apply(operation, iterator, args)).then((result2) => ({
-      result: result2
-    }));
-    const { result } = await awaitWithSignal(pending, signal);
-    if (typeof result !== "object" && typeof result !== "function" || result === null) {
-      throw new TypeError("Iterator result must be an object.");
-    }
-    return {
-      get done() {
-        return result.done;
-      },
-      get value() {
-        return result.value;
-      }
-    };
-  };
-  return {
-    asyncProtocol: true,
-    retainedValue: value,
-    next: (...args) => invoke2(next, args),
-    get return() {
-      const operation = iterator.return;
-      return operation === void 0 || operation === null ? void 0 : (...args) => invoke2(operation, args);
-    },
-    get throw() {
-      const operation = iterator.throw;
-      return operation === void 0 || operation === null ? void 0 : (...args) => invoke2(operation, args);
-    }
-  };
-}
-function asyncFromSyncIterator(iterator, budget, signal) {
-  const invoke2 = async (method, args) => {
-    const operation = iterator.getOperation === void 0 ? iterator[method] : await iterator.getOperation(method);
-    if (operation === void 0) {
-      if (method === "throw") {
-        await closeIterator(iterator);
-        throw new TypeError("Delegated iterator does not provide a throw method.");
-      }
-      return { done: true, value: args[0] };
-    }
-    const returned = operation(...args);
-    const result = iterator.generator || iterator.asynchronous ? await returned : returned;
-    if (typeof result !== "object" && typeof result !== "function" || result === null) {
-      throw new TypeError("Iterator result must be an object.");
-    }
-    const done = Boolean((await readIteratorResult(iterator, result, "done")).value);
-    const resultValue = (await readIteratorResult(iterator, result, "value")).value;
-    try {
-      return { done, value: await awaitSandboxValue(resultValue, signal, budget) };
-    } catch (error3) {
-      if (isFatalSandboxError(error3) || error3 instanceof HostCallResumabilityError) throw error3;
-      if (!done && method !== "return") await closeIterator(iterator, true);
-      throw error3;
-    }
-  };
-  return {
-    asyncProtocol: true,
-    snapshotIndex: iterator.snapshotIndex,
-    get retainedValue() {
-      return iterator.retainedValue;
-    },
-    next: (...args) => invoke2("next", args),
-    return: (...args) => invoke2("return", args),
-    throw: (...args) => invoke2("throw", args)
-  };
-}
-async function closeIterator(iterator, preserveThrow = false) {
-  try {
-    const close = iterator.getOperation === void 0 ? iterator.return : await iterator.getOperation("return");
-    if (close === void 0) return;
-    const returned = close();
-    const result = iterator.asyncProtocol ? await suspendJob(Promise.resolve(returned)) : iterator.generator || iterator.asynchronous ? await returned : returned;
-    if (typeof result !== "object" && typeof result !== "function" || result === null) {
-      throw new TypeError("Iterator return result must be an object.");
-    }
-  } catch (error3) {
-    if (!preserveThrow || isFatalSandboxError(error3) || error3 instanceof HostCallResumabilityError)
-      throw error3;
-  }
-}
-function getSandboxIterator(value, budget, context) {
-  if (isSandboxBox(value) && typeof boxedValue(value) === "string") {
-    const primitive = boxedValue(value);
-    let text5;
-    let iterator2;
-    let initialized;
-    return {
-      asynchronous: true,
-      get retainedValue() {
-        return text5 === primitive ? void 0 : text5;
-      },
-      next: async () => {
-        initialized ??= Promise.resolve(sandboxString(value, budget ?? new Budget(), context)).then(
-          (converted) => {
-            text5 = converted;
-            iterator2 = syncIterator(converted[Symbol.iterator]());
-          }
-        );
-        await initialized;
-        return iterator2.next();
-      }
-    };
-  }
-  if (isSandboxCollectionIterator(value))
-    return { next: () => nextCollectionIterator(value, budget), snapshotIndex: () => 0 };
-  if (isGuestHostObject(value)) return getHostObjectIterator(value);
-  if (isFloat32Array(value)) {
-    return syncIterator(Float32Array.prototype.values.call(value));
-  }
-  if (isSandboxGenerator(value)) {
-    return value.async ? void 0 : generatorIterator(value);
-  }
-  if (typeof value === "string") {
-    return syncIterator(value[Symbol.iterator]());
-  }
-  if (isSandboxMap(value)) {
-    return collectionIterator(value.entries);
-  }
-  if (isSandboxSet(value)) {
-    return collectionIterator(value.values);
-  }
-  if (Array.isArray(value) && hasExplicitSandboxPrototype(value)) return void 0;
-  if (Array.isArray(value) && context?.getProperty !== void 0) {
-    let index = 0;
-    return {
-      asynchronous: true,
-      snapshotIndex: () => index,
-      next: async () => {
-        if (index >= value.length) return { done: true, value: void 0 };
-        budget?.visitNode();
-        return { done: false, value: await context.getProperty(value, index++) };
-      }
-    };
-  }
-  if (typeof value !== "object" && typeof value !== "function" || value === null) {
-    return void 0;
-  }
-  const iteratorMethod = value[Symbol.iterator];
-  if (iteratorMethod === void 0 || iteratorMethod === null) return void 0;
-  if (typeof iteratorMethod !== "function") {
-    throw new TypeError("Iterator method must be callable.");
-  }
-  const iterator = Reflect.apply(iteratorMethod, value, []);
-  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null) {
-    throw new TypeError("Iterator must be an object.");
-  }
-  return syncIterator(iterator);
-}
-function collectionIterator(collection) {
-  let iterator = collection[Symbol.iterator]();
-  let exhausted = false;
-  return {
-    ...syncIterator({
-      next: () => {
-        if (exhausted) return { done: true, value: void 0 };
-        const result = iterator.next();
-        exhausted = result.done === true;
-        return result;
-      }
-    }),
-    snapshotIndex: () => {
-      if (exhausted) return collection.size;
-      let remaining = 0;
-      while (!iterator.next().done) remaining += 1;
-      const index = collection.size - remaining;
-      iterator = collection[Symbol.iterator]();
-      for (let skipped = 0; skipped < index; skipped += 1) iterator.next();
-      return index;
-    }
-  };
-}
-function generatorIterator(generator, budget) {
-  const invoke2 = async (method, value) => {
-    const leaveRunning = enterRunningState(generator);
-    const initialState = generator.state;
-    generator.state = "running";
-    try {
-      if (generator.async && method === "return" && (initialState === "start" || initialState === "done")) {
-        if (initialState === "start") await generator.channel.return();
-        value = await awaitSandboxValue(value, void 0, budget);
-      }
-      const result = await generator.channel[method](value);
-      generator.state = result.done ? "done" : "suspended";
-      return result;
-    } catch (error3) {
-      generator.state = "done";
-      throw error3;
-    } finally {
-      leaveRunning();
-    }
-  };
-  const request = (method, value) => {
-    if (!generator.async) return invoke2(method, value);
-    const previous = asyncGeneratorRequests.get(generator) ?? Promise.resolve();
-    const result = previous.then(() => invoke2(method, value));
-    asyncGeneratorRequests.set(
-      generator,
-      result.catch(() => void 0)
-    );
-    return result;
-  };
-  return {
-    generator: true,
-    next: (value) => request("next", value),
-    return: (value) => request("return", value),
-    throw: (error3) => request("throw", error3)
-  };
-}
-function syncIterator(iterator) {
-  const next = iterator.next;
-  const invoke2 = (method, args) => {
-    const leaveRunning = enterRunningState(iterator);
-    try {
-      return Reflect.apply(method, iterator, args);
-    } finally {
-      leaveRunning();
-    }
-  };
-  return {
-    next: (...args) => invoke2(next, args),
-    get return() {
-      const method = iterator.return;
-      if (method === void 0 || method === null) return void 0;
-      if (typeof method !== "function") throw new TypeError("Iterator return must be callable.");
-      return (...args) => invoke2(method, args);
-    },
-    get throw() {
-      const method = iterator.throw;
-      if (method === void 0 || method === null) return void 0;
-      if (typeof method !== "function") throw new TypeError("Iterator throw must be callable.");
-      return (...args) => invoke2(method, args);
-    }
-  };
-}
-var asyncGeneratorRequests;
-var init_iteration = __esm({
-  "packages/safe-js/src/interp/iteration.ts"() {
-    "use strict";
-    init_values();
-    init_running_state();
-    init_float32();
-    init_boxed();
-    init_host_capabilities();
-    init_collection_iterator();
-    init_budget2();
-    init_string_coercion();
-    init_cancel2();
-    init_host_call();
-    init_jobs4();
-    init_builtin_call();
-    init_object_model();
-    asyncGeneratorRequests = /* @__PURE__ */ new WeakMap();
-  }
-});
-
-// packages/safe-js/src/interp/patterns.ts
-async function bindPattern(pattern, value, target, scope, context, reference) {
-  switch (pattern.type) {
-    case "Identifier":
-      bindIdentifier(pattern, value, target, scope);
-      return { ok: true };
-    case "MemberExpression":
-      if ("kind" in target) {
-        throw new TypeError("Destructuring declarations cannot bind to member expressions.");
-      }
-      return bindMemberExpression(pattern, value, context, reference);
-    case "AssignmentPattern":
-      return bindAssignmentPattern(pattern, value, target, scope, context, reference);
-    case "ArrayPattern":
-      return bindArrayPattern(pattern, value, target, scope, context);
-    case "ObjectPattern":
-      return bindObjectPattern(pattern, value, target, scope, context);
-    case "RestElement":
-      return bindPattern(pattern.argument, value, target, scope, context, reference);
-  }
-}
-function bindIdentifier(pattern, value, target, scope) {
-  if ("assign" in target || target.kind === "var" && target.initialize !== true) {
-    if ("assign" in target) {
-      const binding = scope.lookup(pattern.name);
-      if (!binding.found) {
-        throw new ReferenceError(`Cannot assign to undeclared binding '${pattern.name}'.`);
-      }
-      if (binding.kind === "const") {
-        throw new TypeError(`Cannot assign to const '${pattern.name}'`);
-      }
-    }
-    scope.assign(pattern.name, value);
-    return;
-  }
-  scope.declare(pattern.name, target.kind, value);
-}
-async function bindAssignmentPattern(pattern, value, target, scope, context, reference) {
-  if (value !== void 0) {
-    return bindPattern(pattern.left, value, target, scope, context, reference);
-  }
-  const defaultValue = await context.evaluate(
-    pattern.right,
-    pattern.left.type === "Identifier" ? pattern.left.name : void 0
-  );
-  if (defaultValue.kind !== "normal") {
-    return { ok: false, result: defaultValue };
-  }
-  return bindPattern(pattern.left, defaultValue.value, target, scope, context, reference);
-}
-async function bindPatternValue(pattern, readValue, target, scope, context) {
-  let member = pattern;
-  while (member.type === "AssignmentPattern" || member.type === "RestElement")
-    member = member.type === "AssignmentPattern" ? member.left : member.argument;
-  let reference;
-  if ("assign" in target && member.type === "MemberExpression") {
-    const prepared = await prepareMemberReference(member, context);
-    if (!prepared.ok) return prepared;
-    reference = prepared.reference;
-  }
-  let value;
-  const release2 = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [reference?.object, reference?.key, value]);
-  try {
-    value = (await readValue()).value;
-    return await bindPattern(pattern, value, target, scope, context, reference);
-  } finally {
-    release2();
-  }
-}
-async function bindArrayPattern(pattern, value, target, scope, context) {
-  const budget = context.budget ?? new Budget();
-  const iterator = await acquireSandboxIterator(
-    value,
-    budget,
-    context.callContext ?? {
-      stack: [],
-      thisValue: void 0,
-      getProperty: context.getProperty
-    }
-  );
-  if (iterator === void 0) throw new TypeError("Array destructuring requires an iterable.");
-  let done = false;
-  const next = async (readValue = true) => {
-    if (done) return { value: void 0 };
-    try {
-      const result = await iterator.next();
-      if (typeof result !== "object" && typeof result !== "function" || result === null)
-        throw new TypeError("Iterator result must be an object.");
-      done = Boolean((await readIteratorResult(iterator, result, "done")).value);
-      return done || !readValue ? { value: void 0 } : await readIteratorResult(iterator, result, "value");
-    } catch (error3) {
-      done = true;
-      throw error3;
-    }
-  };
-  let retained;
-  const release2 = retainValues(budget, () => [value, iterator.retainedValue, retained]);
-  try {
-    for (let index = 0; index < pattern.elements.length; index += 1) {
-      const element = pattern.elements[index];
-      if (element === null) {
-        await next(false);
-        continue;
-      }
-      const binding = await bindPatternValue(
-        element,
-        async () => {
-          if (element.type !== "RestElement") return next();
-          const rest = [];
-          retained = rest;
-          for (let entry = await next(); !done; entry = await next()) {
-            budget.allocateArrayLength(rest.length + 1);
-            rest.push(entry.value);
-          }
-          return { value: rest };
-        },
-        target,
-        scope,
-        context
-      );
-      if (!binding.ok) {
-        if (!done) {
-          done = true;
-          await closeIterator(iterator, binding.result.kind === "throw");
-        }
-        return binding;
-      }
-    }
-    if (!done) {
-      done = true;
-      await closeIterator(iterator);
-    }
-    return { ok: true };
-  } catch (error3) {
-    if (!done && !isFatalSandboxError(error3)) await closeIterator(iterator, true);
-    throw error3;
-  } finally {
-    release2();
-  }
-}
-async function bindObjectPattern(pattern, value, target, scope, context) {
-  if (value === void 0 || value === null) {
-    throw new TypeError("Object destructuring requires a non-nullish value.");
-  }
-  const excludedKeys = /* @__PURE__ */ new Set();
-  for (const property of pattern.properties) {
-    if (property.type === "RestElement") {
-      const binding2 = await bindPatternValue(
-        property,
-        async () => ({ value: await copyObjectRestValue(value, excludedKeys, context) }),
-        target,
-        scope,
-        context
-      );
-      if (!binding2.ok) {
-        return binding2;
-      }
-      continue;
-    }
-    const key3 = await evaluatePatternKey(property, context);
-    if (!key3.ok) {
-      return key3;
-    }
-    excludedKeys.add(typeof key3.value === "symbol" ? key3.value : String(key3.value));
-    const binding = await bindPatternValue(
-      property.value,
-      async () => ({ value: await context.getProperty(value, key3.value) }),
-      target,
-      scope,
-      context
-    );
-    if (!binding.ok) {
-      return binding;
-    }
-  }
-  return { ok: true };
-}
-async function bindMemberExpression(pattern, value, context, reference) {
-  if (reference === void 0) {
-    const prepared = await prepareMemberReference(pattern, context);
-    if (!prepared.ok) return prepared;
-    reference = prepared.reference;
-  }
-  if (reference.object === null || reference.object === void 0) {
-    throw new TypeError("Cannot assign properties of null or undefined.");
-  }
-  if (!isIndexableValue(reference.object)) {
-    throw new TypeError("Assignment expressions require a sandbox object property.");
-  }
-  await context.setProperty(reference.object, reference.key, value);
-  return { ok: true };
-}
-async function prepareMemberReference(pattern, context) {
-  const object = await context.evaluate(pattern.object);
-  if (object.kind !== "normal") {
-    return { ok: false, result: object };
-  }
-  const property = pattern.computed ? await context.evaluate(pattern.property) : { kind: "normal", value: getStaticPropertyName(pattern.property) };
-  if (property.kind !== "normal") {
-    return { ok: false, result: property };
-  }
-  return {
-    ok: true,
-    reference: { object: object.value, key: await context.toPropertyKey(property.value) }
-  };
-}
-async function evaluatePatternKey(property, context) {
-  return property.computed ? evaluateProperty(property.key, context) : { ok: true, value: getStaticPropertyName(property.key) };
-}
-async function evaluateProperty(property, context) {
-  const result = await context.evaluate(property);
-  if (result.kind !== "normal") {
-    return { ok: false, result };
-  }
-  return { ok: true, value: await context.toPropertyKey(result.value) };
-}
-function getStaticPropertyName(property) {
-  if (property.type === "Identifier") {
-    return property.name;
-  }
-  if (property.type === "StringLiteral" || property.type === "NumericLiteral") {
-    return property.value;
-  }
-  throw new TypeError(`Unsupported static property node '${property.type}'.`);
-}
-async function copyObjectRestValue(value, excludedKeys, context) {
-  const rest = /* @__PURE__ */ Object.create(null);
-  const release2 = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [value, rest]);
-  try {
-    for (const key3 of ownEnumerableSandboxKeys(value, true)) {
-      if (excludedKeys.has(key3) || !hasOwnSandboxProperty(value, key3, true)) continue;
-      defineProperty(rest, key3, await context.getProperty(value, key3));
-    }
-    return rest;
-  } finally {
-    release2();
-  }
-}
-function isIndexableValue(value) {
-  return typeof value === "object" && value !== null;
-}
-function defineProperty(target, key3, value) {
-  Object.defineProperty(target, key3, {
-    configurable: true,
-    enumerable: true,
-    value,
-    writable: true
-  });
-}
-var init_patterns = __esm({
-  "packages/safe-js/src/interp/patterns.ts"() {
-    "use strict";
-    init_budget2();
-    init_resources();
-    init_object2();
-    init_iteration();
-    init_values();
-  }
-});
-
-// packages/safe-js/src/interp/var-hoist.ts
-function hoistVarDeclarations(node, scope) {
-  for (const declaration of hoistedVarDeclarations([node])) {
-    for (const declarator of declaration.declarations) {
-      for (const identifier of boundIdentifiers(declarator.id)) {
-        scope.declareVar(identifier.name);
-      }
-    }
-  }
-}
-var init_var_hoist = __esm({
-  "packages/safe-js/src/interp/var-hoist.ts"() {
-    "use strict";
-    init_bindings();
-  }
-});
-
 // packages/safe-js/src/interp/data-checkpoint.ts
 function createDataCheckpoint(budget, context) {
   let estimatedDataSize = 0;
@@ -130109,360 +129807,6 @@ var init_number = __esm({
   }
 });
 
-// packages/safe-js/src/interp/regex/engine.ts
-function matchRegex(pattern, input, lastIndex = 0) {
-  const startIndex = pattern.flags.global ? normalizeLastIndex(lastIndex) : 0;
-  return matchRegexFrom(pattern, input, startIndex);
-}
-function matchRegexFrom(pattern, input, startIndex) {
-  if (startIndex > input.length) {
-    return null;
-  }
-  for (let attempt = startIndex; attempt <= input.length; attempt += 1) {
-    const context = { input, flags: pattern.flags, steps: 0 };
-    charge(context);
-    const initialState = {
-      position: attempt,
-      captures: new Array(pattern.captureCount)
-    };
-    const result = matchNode(pattern.body, initialState, context).next();
-    if (!result.done) {
-      return toRegexMatch(input, attempt, result.value);
-    }
-  }
-  return null;
-}
-function* matchNode(node, state, context) {
-  charge(context);
-  switch (node.type) {
-    case "empty":
-      yield state;
-      return;
-    case "literal":
-      if (charactersEqual(context.input[state.position], node.value, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + 1 };
-      }
-      return;
-    case "dot":
-      if (state.position < context.input.length && (context.flags.dotAll || !isLineTerminator(context.input[state.position]))) {
-        yield { ...state, position: state.position + 1 };
-      }
-      return;
-    case "anchor":
-      if (matchesAnchor(node.kind, state.position, context)) {
-        yield state;
-      }
-      return;
-    case "wordBoundary": {
-      const previousWord = state.position > 0 && isWordCharacter(context.input[state.position - 1]);
-      const nextWord = state.position < context.input.length && isWordCharacter(context.input[state.position]);
-      if (previousWord !== nextWord !== node.negated) {
-        yield state;
-      }
-      return;
-    }
-    case "characterClass": {
-      const character2 = context.input[state.position];
-      if (character2 !== void 0 && matchesCharacterClass(character2, node.items, node.negated, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + 1 };
-      }
-      return;
-    }
-    case "sequence":
-      yield* matchSequence(node.elements, 0, state, context);
-      return;
-    case "alternation":
-      for (const alternative of node.alternatives) {
-        yield* matchNode(alternative, cloneState(state), context);
-      }
-      return;
-    case "group":
-      for (const result of matchNode(node.body, cloneState(state), context)) {
-        if (!node.capturing || node.index === void 0) {
-          yield result;
-          continue;
-        }
-        const captures = result.captures.slice();
-        captures[node.index - 1] = { start: state.position, end: result.position };
-        yield { position: result.position, captures };
-      }
-      return;
-    case "quantifier":
-      yield* matchQuantifier(node, state, context, 0);
-  }
-}
-function* matchSequence(elements, index, state, context) {
-  charge(context);
-  if (index === elements.length) {
-    yield state;
-    return;
-  }
-  for (const result of matchNode(elements[index], state, context)) {
-    yield* matchSequence(elements, index + 1, result, context);
-  }
-}
-function* matchQuantifier(node, state, context, count) {
-  charge(context);
-  const canRepeat = node.max === void 0 || count < node.max;
-  if (!node.greedy && count >= node.min) {
-    yield state;
-  }
-  if (canRepeat) {
-    for (const result of matchNode(node.body, clearCaptures(node.body, state), context)) {
-      if (result.position === state.position) {
-        if (count >= node.min) {
-          continue;
-        }
-        if (count + 1 >= node.min) {
-          yield result;
-        } else {
-          yield* matchQuantifier(node, result, context, count + 1);
-        }
-        continue;
-      }
-      yield* matchQuantifier(node, result, context, count + 1);
-    }
-  }
-  if (node.greedy && count >= node.min) {
-    yield state;
-  }
-}
-function matchesAnchor(kind, position, context) {
-  if (kind === "start") {
-    return position === 0 || context.flags.multiline && position > 0 && isLineTerminator(context.input[position - 1]);
-  }
-  return position === context.input.length || context.flags.multiline && position < context.input.length && isLineTerminator(context.input[position]);
-}
-function matchesCharacterClass(character2, items, negated, ignoreCase) {
-  const matched = items.some((item) => matchesCharacterClassItem(character2, item, ignoreCase));
-  return negated ? !matched : matched;
-}
-function matchesCharacterClassItem(character2, item, ignoreCase) {
-  if (item.type === "character") {
-    return charactersEqual(character2, item.value, ignoreCase);
-  }
-  if (item.type === "range") {
-    const candidate = character2.charCodeAt(0);
-    const from = item.from.charCodeAt(0);
-    const to = item.to.charCodeAt(0);
-    if (candidate >= from && candidate <= to) {
-      return true;
-    }
-    if (!ignoreCase) {
-      return false;
-    }
-    const foldedCandidate = foldCharacter(character2, true).charCodeAt(0);
-    const foldedFrom = foldCharacter(item.from, true).charCodeAt(0);
-    const foldedTo = foldCharacter(item.to, true).charCodeAt(0);
-    return foldedCandidate >= foldedFrom && foldedCandidate <= foldedTo;
-  }
-  const matched = item.kind === "digit" ? isDigit5(character2) : item.kind === "word" ? isWordCharacter(character2) : isSpaceCharacter(character2);
-  return item.negated ? !matched : matched;
-}
-function toRegexMatch(input, start, state) {
-  return {
-    index: start,
-    text: input.slice(start, state.position),
-    captures: state.captures.map(
-      (capture) => capture === void 0 ? void 0 : input.slice(capture.start, capture.end)
-    )
-  };
-}
-function cloneState(state) {
-  return { position: state.position, captures: state.captures.slice() };
-}
-function clearCaptures(node, state) {
-  const captures = state.captures.slice();
-  clearNodeCaptures(node, captures);
-  return { position: state.position, captures };
-}
-function clearNodeCaptures(node, captures) {
-  if (node.type === "group") {
-    if (node.capturing && node.index !== void 0) {
-      captures[node.index - 1] = void 0;
-    }
-    clearNodeCaptures(node.body, captures);
-    return;
-  }
-  if (node.type === "sequence") {
-    for (const element of node.elements) {
-      clearNodeCaptures(element, captures);
-    }
-    return;
-  }
-  if (node.type === "alternation") {
-    for (const alternative of node.alternatives) {
-      clearNodeCaptures(alternative, captures);
-    }
-    return;
-  }
-  if (node.type === "quantifier") {
-    clearNodeCaptures(node.body, captures);
-  }
-}
-function charge(context) {
-  context.steps += 1;
-  allocateRegexSteps(context.steps);
-}
-function normalizeLastIndex(lastIndex) {
-  if (Number.isNaN(lastIndex) || lastIndex <= 0) {
-    return 0;
-  }
-  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);
-}
-function foldCharacter(character2, ignoreCase) {
-  if (!ignoreCase) {
-    return character2;
-  }
-  const folded = character2.toUpperCase();
-  if (folded.length !== 1) {
-    return character2;
-  }
-  if (character2.charCodeAt(0) >= 128 && folded.charCodeAt(0) < 128) {
-    return character2;
-  }
-  return folded;
-}
-function isDigit5(character2) {
-  return character2 >= "0" && character2 <= "9";
-}
-function isWordCharacter(character2) {
-  return isDigit5(character2) || character2 >= "A" && character2 <= "Z" || character2 >= "a" && character2 <= "z" || character2 === "_";
-}
-function isSpaceCharacter(character2) {
-  return character2 === " " || character2 === "\f" || character2 === "\n" || character2 === "\r" || character2 === "	" || character2 === "\v" || character2 === "\xA0" || character2 === "\u1680" || character2 >= "\u2000" && character2 <= "\u200A" || character2 === "\u2028" || character2 === "\u2029" || character2 === "\u202F" || character2 === "\u205F" || character2 === "\u3000" || character2 === "\uFEFF";
-}
-function isLineTerminator(character2) {
-  return character2 === "\n" || character2 === "\r" || character2 === "\u2028" || character2 === "\u2029";
-}
-var init_engine2 = __esm({
-  "packages/safe-js/src/interp/regex/engine.ts"() {
-    "use strict";
-    init_budget2();
-  }
-});
-
-// packages/safe-js/src/interp/methods/regex.ts
-function isRegexMethodName(property) {
-  return typeof property === "string" && regexMethodNames.has(property);
-}
-function getRegexMember(target, property, budget) {
-  if (property === "source") return escapeRegexSource(target.source, budget);
-  if (property === "flags") {
-    const flags = [..."gims"].filter((flag) => target.flags.includes(flag)).join("");
-    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, context) => callRegexMethod(context?.thisValue, property, args, budget, context)
-  });
-}
-function escapeRegexSource(source, budget) {
-  let text5 = "";
-  let escaped = false;
-  let inClass = false;
-  for (const character2 of source) {
-    budget?.visitNode();
-    if (character2 === "\n" || character2 === "\r" || character2 === "\u2028" || character2 === "\u2029") {
-      if (escaped) text5 = text5.slice(0, -1);
-      text5 += character2 === "\n" ? "\\n" : character2 === "\r" ? "\\r" : character2 === "\u2028" ? "\\u2028" : "\\u2029";
-      escaped = false;
-    } else {
-      if (!escaped && character2 === "[") inClass = true;
-      if (!escaped && character2 === "]") inClass = false;
-      text5 += character2 === "/" && !escaped && !inClass ? "\\/" : character2;
-      escaped = character2 === "\\" && !escaped;
-    }
-    budget?.allocateString(text5);
-  }
-  text5 = text5 === "" ? "(?:)" : text5;
-  return budget === void 0 ? text5 : budget.allocateString(text5);
-}
-function setRegexMember(target, property, value) {
-  const properties = getRegexProperties(target);
-  if (!Object.hasOwn(properties, property) && (property === "source" || property === "flags" || Object.hasOwn(regexFlagProperties, property))) {
-    throw new TypeError(`RegExp#${String(property)} is not writable.`);
-  }
-  if (!Reflect.set(properties, property, value)) throw new TypeError(`RegExp#${String(property)} is not writable.`);
-}
-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) : await 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, lastIndex) {
-  const pattern = getSandboxRegexPattern(target);
-  const match = matchRegex(pattern, input, lastIndex);
-  if (pattern.flags.global) {
-    target.lastIndex = match === null ? 0 : match.index + match.text.length;
-  }
-  return match;
-}
-function toMatchArray(match, input) {
-  if (match === null) {
-    return null;
-  }
-  const result = [match.text, ...match.captures];
-  Object.assign(result, { index: match.index, input, groups: void 0 });
-  return result;
-}
-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"
-    };
-  }
-});
-
 // packages/safe-js/src/interp/methods/string.ts
 import { types as types5 } from "node:util";
 function getStringMember(value, property, budget) {
@@ -130519,19 +129863,31 @@ function validateStringMethodArguments(_methodName, _args) {
 function callStringMethod(value, methodName, args, budget, callClosure = async (closure, closureArgs) => await closure.call(closureArgs), parent, context) {
   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 fallback = (coercePattern = false) => {
+    const apply = (string) => {
+      if (coercePattern && (methodName === "match" || methodName === "matchAll" || methodName === "search"))
+        return callStringPattern(string, methodName, args[0], budget, parent, context);
+      const useRegex = isSandboxRegex(args[0]) && !coercePattern;
+      if (methodName === "replace" || methodName === "replaceAll")
+        return callReplaceLikeMethod(string, methodName, args, budget, callClosure, useRegex, context);
+      if (methodName === "split") return callSplit(string, args, budget, useRegex, parent, context);
+      return callStringMethodBody(string, methodName, args, budget, parent, context);
+    };
+    return typeof value === "string" ? apply(value) : Promise.resolve(sandboxString(value, budget, context)).then(apply);
+  };
   const symbol2 = 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 (symbol2 !== void 0 && types5.isRegExp(pattern))
     throw new TypeError(`String#${methodName} does not accept unbranded host RegExp values.`);
   if (symbol2 === 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, symbol2 === Symbol.split || symbol2 === Symbol.replace ? [value, args[1]] : [value], budget, context, pattern);
-  };
-  const readProperty = (key3) => context?.getProperty !== void 0 ? context.getProperty(pattern, key3) : key3 === "flags" && isSandboxRegex(pattern) && getSandboxPropertyDescriptor(pattern, key3, budget) === void 0 ? pattern.flags : getSandboxDataProperty(pattern, key3, budget);
+  const readProperty = (key3) => context?.getProperty !== void 0 ? context.getProperty(pattern, key3) : key3 === "flags" && isSandboxRegex(pattern) && getSandboxPropertyDescriptor(pattern, key3, budget) === void 0 ? getRegexMember(pattern, key3, budget, context) : getSandboxDataProperty(pattern, key3, budget);
   const dispatch = () => {
+    const overriddenRegex = isSandboxRegex(pattern) && getSandboxPropertyDescriptor(pattern, symbol2, budget) !== void 0;
+    const applyHook = (hook2) => {
+      if (hook2 === null || hook2 === void 0) return fallback(overriddenRegex);
+      if (!isSandboxClosure(hook2)) throw new TypeError(`String#${methodName} symbol hook must be callable.`);
+      return invokeBuiltinClosure(hook2, symbol2 === Symbol.split || symbol2 === Symbol.replace ? [value, args[1]] : [value], budget, context, pattern);
+    };
     const hook = readProperty(symbol2);
     return hook instanceof Promise ? hook.then(applyHook) : applyHook(hook);
   };
@@ -130554,7 +129910,7 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
   }
   return dispatch();
 }
-function callStringMethodBody(value, methodName, args, budget, callClosure = async (closure, closureArgs) => await closure.call(closureArgs), parent, context) {
+function callStringMethodBody(value, methodName, args, budget, parent, context) {
   if (methodName === "concat" && args.some((argument) => argument !== null && typeof argument === "object")) {
     return callConcat(value, args, budget, context);
   }
@@ -130593,11 +129949,12 @@ function callStringMethodBody(value, methodName, args, budget, callClosure = asy
     }
     return budget.allocateString(result + value.slice(spanStart));
   }
-  if (methodName === "replace" || methodName === "replaceAll") {
-    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")) {
+  if (methodName === "search" && isSandboxRegex(regex) && hasRegexPropertyOverride(regex, ["exec"], budget))
+    return regexSearch(regex, value, budget, context);
+  if (methodName === "match" && isSandboxRegex(regex) && hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget))
+    return regexMatch(value, regex, budget, context);
+  if (isSandboxRegex(regex) && (methodName === "matchAll" || methodName === "match" && !regex.flags.includes("g") && regex.lastIndex !== null && typeof regex.lastIndex === "object")) {
     return callStringRegexCursor(value, methodName, regex, budget, parent, context);
   }
   if ((methodName === "match" || methodName === "matchAll" || methodName === "search") && !isSandboxRegex(args[0])) {
@@ -130606,9 +129963,6 @@ function callStringMethodBody(value, methodName, args, budget, callClosure = asy
   const operation = budget.acquireCompileOwner(false, parent?.owner);
   const compilation = new CompileScope(operation.owner);
   try {
-    if (methodName === "split") {
-      return callSplit(value, args, budget, compilation);
-    }
     if (methodName === "match" || methodName === "matchAll" || methodName === "search") {
       return callMatchLikeMethod(value, methodName, args, compilation);
     }
@@ -130726,19 +130080,19 @@ async function callConcat(value, args, budget, context) {
     release2();
   }
 }
-function callReplaceLikeMethod(value, methodName, args, budget, callClosure, context) {
+function callReplaceLikeMethod(value, methodName, args, budget, callClosure, useRegex, context) {
   const search = args[0];
   const replacement = args[1];
-  const useRegex = isSandboxRegex(search) && getSandboxPropertyDescriptor(search, Symbol.replace, budget) === void 0;
-  if (!useRegex && typeof search !== "string" || typeof replacement !== "string" && !isSandboxClosure(replacement)) {
+  const regexSearch2 = useRegex && isSandboxRegex(search);
+  if (!regexSearch2 && typeof search !== "string" || typeof replacement !== "string" && !isSandboxClosure(replacement)) {
     return (async () => {
       let normalizedSearch;
       let normalizedReplacement;
       const release2 = retainValues(budget, () => [normalizedSearch, normalizedReplacement]);
       try {
-        normalizedSearch = useRegex ? search : await sandboxString(search, budget, context);
+        normalizedSearch = regexSearch2 ? 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);
+        return await callReplaceLikeMethod(value, methodName, [normalizedSearch, normalizedReplacement], budget, callClosure, useRegex, context);
       } finally {
         release2();
       }
@@ -130765,23 +130119,28 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure, con
     replacement,
     methodName === "replaceAll",
     budget,
-    callClosure
+    callClosure,
+    context
   );
 }
 async function replaceRegex(value, regex, replacement, budget, callClosure, context) {
+  if (hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget))
+    return regexReplace(value, regex, replacement, budget, callClosure, context);
   if (regex.flags.includes("g")) regex.lastIndex = 0;
   const cursor2 = regex.lastIndex;
+  let result = "";
   const retained = {};
-  budget.setRetainedValues(retained, () => [value, regex, cursor2, replacement]);
+  budget.setRetainedValues(retained, () => [value, regex, cursor2, replacement, result]);
   try {
     const lastIndex = await sandboxNumber(cursor2, 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;
     }
@@ -130791,57 +130150,182 @@ async function replaceRegex(value, regex, replacement, budget, callClosure, cont
     budget.setRetainedValues(retained, void 0);
   }
 }
-function expandReplacement(replacement, match, captures, input, matchIndex) {
+function readReplacementProperty(target, key3, budget, context) {
+  if (context?.getProperty !== void 0) return context.getProperty(target, key3);
+  const descriptor = getSandboxPropertyDescriptor(target, key3, budget);
+  if (descriptor !== void 0) return readPropertyDescriptor(descriptor, target, context);
+  return isSandboxRegex(target) ? getRegexMember(target, key3, budget, context) : void 0;
+}
+async function regexReplace(input, regex, replacementInput, budget, callClosure, context) {
+  if (regex === null || typeof regex !== "object") throw new TypeError("RegExp replace requires an object receiver.");
+  let value;
+  let replacement;
+  const matches = [];
+  let current;
+  let field;
+  let groups;
+  let matched;
+  let captures = [];
   let result = "";
-  for (let index = 0; index < replacement.length; index += 1) {
-    const character2 = replacement.charAt(index);
-    if (character2 !== "$") {
-      result += character2;
-      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 >= "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 flags;
+  const release2 = retainValues(budget, () => [input, value, regex, replacementInput, replacement, matches, current, field, groups, matched, captures, result, flags]);
+  try {
+    value = await sandboxString(input, budget, context);
+    input = void 0;
+    replacement = isSandboxClosure(replacementInput) ? replacementInput : await sandboxString(replacementInput, budget, context);
+    replacementInput = void 0;
+    if (isSandboxRegex(regex) && !hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget)) {
+      release2();
+      return await replaceRegex(value, regex, replacement, budget, callClosure, context);
+    }
+    field = await readReplacementProperty(regex, "flags", budget, context);
+    flags = await sandboxString(field, budget, context);
+    field = void 0;
+    const global2 = flags.includes("g");
+    const fullUnicode = flags.includes("u") || flags.includes("v");
+    flags = void 0;
+    if (global2) await setSandboxProperty(regex, "lastIndex", 0, budget, true, context);
+    while (true) {
+      budget.visitNode();
+      current = await regexExec(regex, value, budget, context);
+      if (current === null) break;
+      budget.allocateArrayLength(matches.length + 1);
+      matches.push(current);
+      if (!global2) break;
+      field = await readReplacementProperty(current, "0", budget, context);
+      matched = await sandboxString(field, budget, context);
+      field = void 0;
+      if (matched.length === 0) {
+        field = await readReplacementProperty(regex, "lastIndex", budget, context);
+        const index = normalizeLastIndex(await sandboxNumber(field, budget, context));
+        const point = fullUnicode ? value.codePointAt(index) : void 0;
+        await setSandboxProperty(regex, "lastIndex", index + (point !== void 0 && point > 65535 ? 2 : 1), budget, true, context);
+        field = void 0;
+      }
+      matched = void 0;
+      current = void 0;
+    }
+    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 text5;
+      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]));
+        }
+        text5 = 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);
+        text5 = await sandboxString(field, budget, context);
+        field = void 0;
+      }
+      if (position >= copiedThrough) {
+        result = budget.allocateString(result + value.slice(copiedThrough, position) + text5);
+        copiedThrough = position + matched.length;
+      }
+      matched = void 0;
+      captures = [];
+      groups = void 0;
+    }
+    return budget.allocateString(result + value.slice(copiedThrough));
+  } finally {
+    release2();
+  }
+}
+async function expandReplacement(replacement, match, captures, input, matchIndex, budget, context, groups) {
+  let result = "";
+  const release2 = retainValues(budget, () => [replacement, match, captures, input, groups, result]);
+  try {
+    for (let index = 0; index < replacement.length; index += 1) {
+      budget.visitNode();
+      budget.allocateString(result);
+      const character2 = replacement.charAt(index);
+      if (character2 !== "$") {
+        result += character2;
+        continue;
       }
-      if (captureIndex === 0 || captureIndex > captures.length) {
+      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 {
+    release2();
   }
-  return result;
 }
-async function replaceWithClosure(value, searchValue, replacer, replaceAll2, budget, callClosure) {
+async function replaceWithClosure(value, searchValue, replacer, replaceAll2, budget, callClosure, context) {
   const offsets = findReplacementOffsets(value, searchValue, replaceAll2);
   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 release2 = 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 {
+    release2();
   }
-  result += value.slice(copiedThrough);
-  return budget.allocateString(result);
 }
 function findReplacementOffsets(value, searchValue, replaceAll2) {
   const firstOffset = value.indexOf(searchValue);
@@ -130862,42 +130346,73 @@ function findReplacementOffsets(value, searchValue, replaceAll2) {
   }
   return offsets;
 }
-function callSplit(value, args, budget, compilation) {
-  if (args.some(isSandboxClosure))
-    throw new TypeError("String#split does not support function arguments.");
-  if (isSandboxRegex(args[0])) {
-    const regex = args[0];
-    const splitter = createSandboxRegex(
-      regex.source,
-      regex.flags.includes("g") ? regex.flags : `${regex.flags}g`,
-      0,
-      compilation
-    );
-    const limit2 = asNumberOrUndefined(args[1]) ?? 2 ** 32 - 1;
-    const result2 = [];
-    let copiedThrough = 0;
-    let endedWithZeroWidthMatch = false;
-    for (const match of collectRegexMatches(splitter, value, true)) {
-      endedWithZeroWidthMatch = match.text.length === 0 && match.index === value.length;
-      if (match.text.length === 0 && (match.index === copiedThrough || match.index === value.length))
-        continue;
-      if (result2.length >= limit2) break;
-      result2.push(budget.allocateString(value.slice(copiedThrough, match.index)));
-      for (const capture of match.captures) {
-        if (result2.length >= limit2) break;
-        result2.push(capture === void 0 ? void 0 : budget.allocateString(capture));
+function callSplit(value, args, budget, useRegex, parent, context) {
+  const pattern = args[0];
+  let separator;
+  const release2 = retainValues(budget, () => [value, ...args, separator]);
+  const withLimit = (number) => {
+    const limit = number >>> 0;
+    const converted = useRegex || pattern === void 0 ? pattern : sandboxString(pattern, budget, context);
+    const split = (converted2) => {
+      separator = converted2;
+      return splitNormalized(value, converted2, limit, budget, parent);
+    };
+    return converted instanceof Promise ? converted.then(split) : split(converted);
+  };
+  try {
+    const limit = args[1] === void 0 ? 2 ** 32 - 1 : sandboxNumber(args[1], budget, context);
+    const result = limit instanceof Promise ? limit.then(withLimit) : withLimit(limit);
+    if (result instanceof Promise) return result.finally(release2);
+    release2();
+    return result;
+  } catch (error3) {
+    release2();
+    throw error3;
+  }
+}
+function splitNormalized(value, separator, limit, budget, parent) {
+  if (limit === 0) return [];
+  if (isSandboxRegex(separator)) {
+    const regex = separator;
+    const operation = budget.acquireCompileOwner(false, parent?.owner);
+    const compilation = new CompileScope(operation.owner);
+    try {
+      const splitter = createSandboxRegex(
+        regex.source,
+        regex.flags.includes("g") ? regex.flags : `${regex.flags}g`,
+        0,
+        compilation
+      );
+      const result2 = [];
+      let copiedThrough = 0;
+      let endedWithZeroWidthMatch = false;
+      while (result2.length < limit) {
+        const match = executeRegex(splitter, value, Number(splitter.lastIndex));
+        if (match === null) break;
+        if (match.text.length === 0) splitter.lastIndex = match.index + 1;
+        endedWithZeroWidthMatch = match.text.length === 0 && match.index === value.length;
+        if (match.text.length === 0 && (match.index === copiedThrough || match.index === value.length))
+          continue;
+        budget.allocateArrayLength(result2.length + 1);
+        result2.push(budget.allocateString(value.slice(copiedThrough, match.index)));
+        for (const capture of match.captures) {
+          if (result2.length >= limit) break;
+          budget.allocateArrayLength(result2.length + 1);
+          result2.push(capture === void 0 ? void 0 : budget.allocateString(capture));
+        }
+        copiedThrough = match.index + match.text.length;
       }
-      copiedThrough = match.index + match.text.length;
+      if (result2.length < limit && (value.length > 0 || !endedWithZeroWidthMatch)) {
+        budget.allocateArrayLength(result2.length + 1);
+        result2.push(budget.allocateString(value.slice(copiedThrough)));
+      }
+      return result2;
+    } finally {
+      compilation.dispose();
+      operation.release();
     }
-    if (result2.length < limit2 && (value.length > 0 || !endedWithZeroWidthMatch))
-      result2.push(budget.allocateString(value.slice(copiedThrough)));
-    budget.allocateArrayLength(result2.length);
-    return result2;
   }
-  if (args[0] !== void 0 && typeof args[0] !== "string")
-    throw new TypeError(SPLIT_STRING_MESSAGE);
-  const limit = asNumberOrUndefined(args[1]);
-  const result = splitString(value, args[0], limit).map((part) => budget.allocateString(part));
+  const result = splitString(value, separator, limit).map((part) => budget.allocateString(part));
   budget.allocateArrayLength(result.length);
   return result;
 }
@@ -130916,19 +130431,109 @@ async function callStringPattern(value, methodName, pattern, budget, parent, con
     operation.release();
   }
 }
-async function callStringRegexCursor(value, methodName, regex, budget, parent, context) {
+async function regexMatch(input, regex, budget, context) {
+  if (regex === null || typeof regex !== "object") throw new TypeError("RegExp match requires an object receiver.");
+  let value;
+  const matches = [];
+  let result;
+  let matched;
+  let cursor2;
+  let flagsValue;
+  let flags;
+  const release2 = retainValues(budget, () => [input, value, regex, matches, result, matched, cursor2, flagsValue, flags]);
+  const read = (target, key3) => {
+    if (context?.getProperty !== void 0) return context.getProperty(target, key3);
+    const descriptor = getSandboxPropertyDescriptor(target, key3, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, target, context);
+  };
+  try {
+    value = await sandboxString(input, budget, context);
+    input = void 0;
+    if (isSandboxRegex(regex) && !hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget)) {
+      release2();
+      return await callStringMethodBody(value, "match", [regex], budget, context?.compilation, context);
+    }
+    flagsValue = await read(regex, "flags");
+    flags = await sandboxString(flagsValue, budget, context);
+    flagsValue = void 0;
+    if (!flags.includes("g")) return await regexExec(regex, value, budget, context);
+    const fullUnicode = flags.includes("u") || flags.includes("v");
+    flags = void 0;
+    await setSandboxProperty(regex, "lastIndex", 0, budget, true, context);
+    while (true) {
+      budget.visitNode();
+      result = await regexExec(regex, value, budget, context);
+      if (result === null) return matches.length === 0 ? null : matches;
+      const descriptor = context?.getProperty === void 0 ? getSandboxPropertyDescriptor(result, "0", budget) : void 0;
+      matched = await (context?.getProperty !== void 0 ? context.getProperty(result, "0") : descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, result, context));
+      const text5 = await sandboxString(matched, budget, context);
+      matched = void 0;
+      budget.allocateArrayLength(matches.length + 1);
+      matches.push(text5);
+      if (text5.length === 0) {
+        cursor2 = await read(regex, "lastIndex");
+        const index = normalizeLastIndex(await sandboxNumber(cursor2, budget, context));
+        const point = fullUnicode ? value.codePointAt(index) : void 0;
+        await setSandboxProperty(regex, "lastIndex", index + (point !== void 0 && point > 65535 ? 2 : 1), budget, true, context);
+        cursor2 = void 0;
+      }
+      result = void 0;
+    }
+  } finally {
+    release2();
+  }
+}
+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;
+  let cursor2;
+  let flagsValue;
+  let flags;
+  let matcher;
   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, () => [value, regex, cursor2, flagsValue, flags, matcher]);
+  const release2 = () => {
     budget.setRetainedValues(retained, void 0);
     compilation.dispose();
     operation.release();
+  };
+  const readCursor = () => {
+    cursor2 = regex.lastIndex;
+    const finish = (lastIndex2) => {
+      if (matcher !== void 0) {
+        matcher.lastIndex = normalizeLastIndex(lastIndex2);
+        return restoreSandboxRegExpIterator({ matcher, input: value, exhausted: false });
+      }
+      return callMatchLikeMethod(value, methodName, [regex], compilation, lastIndex2);
+    };
+    const lastIndex = sandboxNumber(cursor2, budget, context);
+    return lastIndex instanceof Promise ? lastIndex.then(finish) : finish(lastIndex);
+  };
+  const clone = (text5) => {
+    flags = text5;
+    flagsValue = void 0;
+    matcher = createSandboxRegex(regex.source, flags, 0, compilation);
+    flags = void 0;
+    return readCursor();
+  };
+  const convertFlags = (value2) => {
+    flagsValue = value2;
+    const text5 = sandboxString(value2, budget, context);
+    return text5 instanceof Promise ? text5.then(clone) : clone(text5);
+  };
+  try {
+    let result;
+    if (methodName === "matchAll") {
+      const descriptor = context?.getProperty === void 0 ? getSandboxPropertyDescriptor(regex, "flags", budget) : void 0;
+      const value2 = context?.getProperty !== void 0 ? context.getProperty(regex, "flags") : descriptor !== void 0 ? readPropertyDescriptor(descriptor, regex, context) : getRegexMember(regex, "flags", budget, context);
+      result = value2 instanceof Promise ? value2.then(convertFlags) : convertFlags(value2);
+    } else result = readCursor();
+    if (result instanceof Promise) return result.finally(release2);
+    release2();
+    return result;
+  } catch (error3) {
+    release2();
+    throw error3;
   }
 }
 function callMatchLikeMethod(value, methodName, args, compilation, lastIndex) {
@@ -130946,9 +130551,10 @@ function callMatchLikeMethod(value, methodName, args, compilation, lastIndex) {
     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;
+  if (methodName === "matchAll")
+    return restoreSandboxRegExpIterator({ matcher, input: value, exhausted: false });
   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));
+  return matches.length === 0 ? null : matches.map((match) => match.text);
 }
 function collectRegexMatches(regex, value, all, budget, lastIndex = 0) {
   const matches = [];
@@ -130975,7 +130581,7 @@ function asNumberOrUndefined(value) {
 function asStringOrUndefined(value) {
   return value === void 0 ? void 0 : String(value);
 }
-var SPLIT_STRING_MESSAGE, stringMethodNames;
+var stringMethodNames;
 var init_string = __esm({
   "packages/safe-js/src/interp/methods/string.ts"() {
     "use strict";
@@ -130985,9 +130591,12 @@ var init_string = __esm({
     init_string_coercion();
     init_resources();
     init_object_model();
+    init_accessors();
+    init_boxed();
+    init_interpreter();
     init_values();
     init_regex();
-    SPLIT_STRING_MESSAGE = "String#split only supports string separator values.";
+    init_regexp_iterator();
     stringMethodNames = /* @__PURE__ */ new Set([
       "at",
       "charAt",
@@ -131834,6 +131443,23 @@ var init_object_array = __esm({
   }
 });
 
+// packages/safe-js/src/interp/var-hoist.ts
+function hoistVarDeclarations(node, scope) {
+  for (const declaration of hoistedVarDeclarations([node])) {
+    for (const declarator of declaration.declarations) {
+      for (const identifier of boundIdentifiers(declarator.id)) {
+        scope.declareVar(identifier.name);
+      }
+    }
+  }
+}
+var init_var_hoist = __esm({
+  "packages/safe-js/src/interp/var-hoist.ts"() {
+    "use strict";
+    init_bindings();
+  }
+});
+
 // packages/safe-js/src/interp/classes.ts
 async function evaluateClass(node, context, evaluateNode3, callContext) {
   const scope = context.scope.child();
@@ -134993,6 +134619,7 @@ function isRestorableBindingValue(value, seen = /* @__PURE__ */ new WeakSet()) {
   }
   if (seen.has(value)) return true;
   seen.add(value);
+  if (isSandboxRegExpIterator(value)) return isRestorableBindingValue(regexpIteratorState(value).matcher, seen);
   if (isSandboxCollectionIterator(value)) {
     return isRestorableBindingValue(collectionIteratorState(value).collection, seen);
   }
@@ -135247,7 +134874,7 @@ async function evaluateForOfStatement(node, context) {
     const restored = context.scope.consumeRestoredBinding(restoredIteration.values[0]);
     if (restored.found && Array.isArray(restored.value)) {
       restoredEntry = { done: false, value: restored.value[1] };
-      if (Array.isArray(restored.value[0]) || isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0]) || isSandboxCollectionIterator(restored.value[0])) {
+      if (Array.isArray(restored.value[0]) || isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0]) || isSandboxCollectionIterator(restored.value[0]) || isSandboxRegExpIterator(restored.value[0])) {
         return evaluateForOfIterator(node, restored.value[0], context, restoredEntry);
       }
     }
@@ -135619,7 +135246,7 @@ function createLoopIterationContext(context, scope) {
       if (context.activeLoopIterations.size === 0) return snapshot2;
       snapshot2.loopIterations = {};
       for (const [nodeId, iteration] of context.activeLoopIterations) {
-        if (typeof iteration !== "number" && (Array.isArray(iteration.values[0]) || isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]) || isSandboxCollectionIterator(iteration.values[0]))) {
+        if (typeof iteration !== "number" && (Array.isArray(iteration.values[0]) || isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]) || isSandboxCollectionIterator(iteration.values[0]) || isSandboxRegExpIterator(iteration.values[0]))) {
           const bindingName = `#for-of:${nodeId}`;
           snapshot2.bindings[bindingName] = iteration.values;
           snapshot2.loopIterations[nodeId] = { index: iteration.index, values: [bindingName] };
@@ -135967,6 +135594,7 @@ function getPropertyValue(target, property, context, receiver = target) {
   const descriptor = getSandboxPropertyDescriptor(target, property, context.budget);
   if (descriptor !== void 0)
     return readPropertyDescriptor(descriptor, receiver, createCoercionContext(context), true);
+  if (isSandboxRegExpIterator(target)) return getRegExpIteratorMember(property, context.budget);
   if (typeof target === "symbol") {
     const prototype = getBoxedPrototype(target, context.budget);
     return prototype === void 0 ? void 0 : getPropertyValue(prototype, property, context, receiver);
@@ -135993,7 +135621,7 @@ function getPropertyValue(target, property, context, receiver = target) {
   if (isSandboxGenerator(target)) return getGeneratorMember(target, property, context.budget);
   if (isSandboxClosure(target)) return getClosureMemberValue(target, property, context);
   if (isSandboxPromise(target)) return getPromiseMember(property, context.budget);
-  if (isSandboxRegex(target)) return getRegexMember(target, property, context.budget);
+  if (isSandboxRegex(target)) return hasExplicitSandboxPrototype(target) || getSandboxPrototype(target, context.budget) !== null ? void 0 : getRegexMember(target, property, context.budget, createCoercionContext(context));
   if (!isIndexableSandboxValue(target)) {
     throw new TypeError("Attempted to read a property from a non-object value.");
   }
@@ -136112,7 +135740,7 @@ async function evaluateMemberAccess(node, context, consume) {
   let property;
   const release2 = retainValues(context.budget, () => [object.value, property]);
   try {
-    const result = node.computed ? await evaluateNode2(node.property, context) : { kind: "normal", value: getStaticPropertyName2(node.property) };
+    const result = node.computed ? await evaluateNode2(node.property, context) : { kind: "normal", value: getStaticPropertyName(node.property) };
     if (result.kind !== "normal") return result;
     property = result.value;
     return await consume({
@@ -136142,12 +135770,12 @@ async function evaluateObjectPropertyKey(node, context) {
   if (!node.computed) {
     return {
       ok: true,
-      value: getStaticPropertyName2(node.key)
+      value: getStaticPropertyName(node.key)
     };
   }
   return evaluateMemberProperty(node.key, context);
 }
-function getStaticPropertyName2(node) {
+function getStaticPropertyName(node) {
   if (node.type === "Identifier") {
     return node.name;
   }
@@ -136549,7 +136177,7 @@ function hasSandboxProperty(value, key3, context) {
   while (typeof current === "object" && current !== null) {
     if (isGuestHostObject(current)) return typeof key3 === "symbol" ? false : hasHostObjectMember(current, String(key3));
     if (hasOwnSandboxProperty(current, key3, false)) return true;
-    if (!((isGuestClosure(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) && (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current))) {
+    if (!isSandboxRegex(current) && !((isGuestClosure(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) && (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current))) {
       return getPropertyValue(current, key3, context) !== void 0;
     }
     current = getSandboxPrototype(current, context.budget);
@@ -136749,7 +136377,7 @@ function getMemberValue(target, property, context) {
   while (typeof current === "object" && current !== null) {
     if (isSandboxClosure(current)) return getClosureMemberValue(current, property, context);
     if (Array.isArray(current)) return getArrayMemberValue(current, property, context);
-    if (!isPlainSandboxObject(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isFloat32Array(current)) {
+    if (!isPlainSandboxObject(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current) || isFloat32Array(current)) {
       return getPropertyValue(current, property, context);
     }
     if (Object.hasOwn(current, String(property))) return current[String(property)];
@@ -136787,7 +136415,7 @@ function setSandboxProperty(target, property, value, budget, checkInherited = tr
     return;
   }
   if (isSandboxRegex(target)) {
-    setRegexMember(target, property, value);
+    setRegexMember(target, property, value, budget);
     return;
   }
   if (!isIndexableSandboxValue(target)) {
@@ -137155,6 +136783,8 @@ var init_interpreter = __esm({
     init_collections();
     init_collection_iterator();
     init_collection_iterator2();
+    init_regexp_iterator();
+    init_regexp_iterator2();
     init_float32array2();
     init_float32();
     init_date();
@@ -137223,6 +136853,859 @@ var init_interpreter = __esm({
   }
 });
 
+// packages/safe-js/src/interp/methods/regex.ts
+async function regexSearch(target, input, budget, context) {
+  if (target === null || typeof target !== "object") throw new TypeError("RegExp search requires an object receiver.");
+  let string;
+  let previous;
+  let result;
+  const release2 = retainValues(budget, () => [target, input, string, previous, result]);
+  const read = (value, key3) => {
+    if (context?.getProperty !== void 0) return context.getProperty(value, key3);
+    const descriptor = getSandboxPropertyDescriptor(value, key3, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+  };
+  try {
+    string = await sandboxString(input, budget, context);
+    input = void 0;
+    previous = await read(target, "lastIndex");
+    if (!Object.is(previous, 0)) await setSandboxProperty(target, "lastIndex", 0, budget, true, context);
+    result = await regexExec(target, string, budget, context);
+    if (!Object.is(await read(target, "lastIndex"), previous))
+      await setSandboxProperty(target, "lastIndex", previous, budget, true, context);
+    return result === null ? -1 : await read(result, "index");
+  } finally {
+    release2();
+  }
+}
+function isRegexMethodName(property) {
+  return typeof property === "string" && regexMethodNames.has(property);
+}
+function getRegexMember(target, property, budget, context) {
+  if (property === "source") return escapeRegexSource(target.source, budget);
+  if (property === "flags") {
+    let flags = "";
+    const entries = Object.entries(regexFlagProperties);
+    const release2 = retainValues(budget, () => [target, flags]);
+    const read = (index) => {
+      if (index === entries.length) return budget.allocateString(flags);
+      budget.visitNode();
+      const [key3, flag] = entries[index];
+      const descriptor = context?.getProperty === void 0 ? getSandboxPropertyDescriptor(target, key3, budget) : void 0;
+      const value = context?.getProperty !== void 0 ? context.getProperty(target, key3) : descriptor !== void 0 ? readPropertyDescriptor(descriptor, target, context) : target.flags.includes(flag);
+      const append = (value2) => {
+        if (value2) flags += flag;
+        return read(index + 1);
+      };
+      return value instanceof Promise ? value.then(append) : append(value);
+    };
+    try {
+      const result = read(0);
+      if (result instanceof Promise) return result.finally(release2);
+      release2();
+      return result;
+    } catch (error3) {
+      release2();
+      throw error3;
+    }
+  }
+  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: property === "toString" ? "toString" : `RegExp#${property}`,
+    call: (args, context2) => callRegexMethod(context2?.thisValue, property, args, budget, context2)
+  });
+}
+function escapeRegexSource(source, budget) {
+  let text5 = "";
+  let escaped = false;
+  let inClass = false;
+  for (const character2 of source) {
+    budget?.visitNode();
+    if (character2 === "\n" || character2 === "\r" || character2 === "\u2028" || character2 === "\u2029") {
+      if (escaped) text5 = text5.slice(0, -1);
+      text5 += character2 === "\n" ? "\\n" : character2 === "\r" ? "\\r" : character2 === "\u2028" ? "\\u2028" : "\\u2029";
+      escaped = false;
+    } else {
+      if (!escaped && character2 === "[") inClass = true;
+      if (!escaped && character2 === "]") inClass = false;
+      text5 += character2 === "/" && !escaped && !inClass ? "\\/" : character2;
+      escaped = character2 === "\\" && !escaped;
+    }
+    budget?.allocateString(text5);
+  }
+  text5 = text5 === "" ? "(?:)" : text5;
+  return budget === void 0 ? text5 : budget.allocateString(text5);
+}
+function setRegexMember(target, property, value, budget) {
+  const properties = getRegexProperties(target);
+  if (!hasExplicitSandboxPrototype(target) && getSandboxPrototype(target, budget) === null && !Object.hasOwn(properties, property) && (property === "source" || property === "flags" || Object.hasOwn(regexFlagProperties, property))) {
+    throw new TypeError(`RegExp#${String(property)} is not writable.`);
+  }
+  if (!Reflect.set(properties, property, value)) throw new TypeError(`RegExp#${String(property)} is not writable.`);
+}
+async function callRegexMethod(target, methodName, args, budget, context) {
+  if (methodName === "toString") return regexToString(target, 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") {
+      budget.setRetainedValues(retained, void 0);
+      return await regexExec(target, input, budget, context) !== null;
+    }
+    if (typeof args[0] !== "string") convertedInput = input;
+    if (!isSandboxRegex(target)) throw new TypeError("RegExp execution requires a regex receiver.");
+    cursor2 = target.lastIndex;
+    const lastIndex = await sandboxNumber(cursor2, budget, context);
+    const match = executeRegex(target, input, lastIndex);
+    return toMatchArray(match, input);
+  } finally {
+    budget.setRetainedValues(retained, void 0);
+  }
+}
+async function regexExec(target, input, budget, context) {
+  let exec2;
+  const release2 = retainValues(budget, () => [target, input, exec2]);
+  try {
+    const descriptor = context?.getProperty === void 0 ? getSandboxPropertyDescriptor(target, "exec", budget) : void 0;
+    exec2 = await (context?.getProperty !== void 0 ? context.getProperty(target, "exec") : descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, target, context));
+    if (isSandboxClosure(exec2)) {
+      const result = await invokeBuiltinClosure(exec2, [input], budget, context, target);
+      if (result !== null && typeof result !== "object")
+        throw new TypeError("RegExp exec must return an object or null.");
+      return result;
+    }
+    return await callRegexMethod(target, "exec", [input], budget, context);
+  } finally {
+    release2();
+  }
+}
+async function regexToString(target, budget, context) {
+  if (target === null || typeof target !== "object")
+    throw new TypeError("RegExp#toString requires an object receiver.");
+  const read = (key3) => {
+    if (context?.getProperty !== void 0) return context.getProperty(target, key3);
+    const descriptor = getSandboxPropertyDescriptor(target, key3, budget);
+    if (descriptor !== void 0) return readPropertyDescriptor(descriptor, target, context);
+    return isSandboxRegex(target) ? getRegexMember(target, key3, budget, context) : void 0;
+  };
+  let sourceValue;
+  let flagsValue;
+  let source;
+  let flags;
+  const release2 = retainValues(budget, () => [target, sourceValue, flagsValue, source, flags]);
+  try {
+    sourceValue = await read("source");
+    source = await sandboxString(sourceValue, budget, context);
+    sourceValue = void 0;
+    flagsValue = await read("flags");
+    flags = await sandboxString(flagsValue, budget, context);
+    flagsValue = void 0;
+    return budget.allocateString(`/${source}/${flags}`);
+  } finally {
+    release2();
+  }
+}
+function executeRegex(target, input, lastIndex) {
+  const pattern = getSandboxRegexPattern(target);
+  const match = matchRegex(pattern, input, lastIndex);
+  if (pattern.flags.global) {
+    target.lastIndex = match === null ? 0 : match.index + match.text.length;
+  }
+  return match;
+}
+function toMatchArray(match, input) {
+  if (match === null) {
+    return null;
+  }
+  const result = [match.text, ...match.captures];
+  Object.assign(result, { index: match.index, input, groups: void 0 });
+  return result;
+}
+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_accessors();
+    init_resources();
+    init_string_coercion();
+    init_interpreter();
+    regexMethodNames = /* @__PURE__ */ new Set(["exec", "test", "toString"]);
+    regexFlagProperties = {
+      hasIndices: "d",
+      global: "g",
+      ignoreCase: "i",
+      multiline: "m",
+      dotAll: "s",
+      unicode: "u",
+      unicodeSets: "v",
+      sticky: "y"
+    };
+  }
+});
+
+// packages/safe-js/src/interp/methods/regexp-iterator.ts
+function nextRegExpIterator(iterator, budget) {
+  const state = regexpIteratorState(iterator);
+  budget?.visitNode();
+  if (state.exhausted) return { value: void 0, done: true };
+  const matcher = state.matcher;
+  const input = state.input;
+  const match = executeRegex(matcher, input, Number(matcher.lastIndex));
+  if (match === null || !matcher.flags.includes("g")) {
+    state.exhausted = true;
+    state.matcher = void 0;
+    state.input = void 0;
+  }
+  if (match === null) return { value: void 0, done: true };
+  if (!state.exhausted && match.text.length === 0) {
+    const index = Number(matcher.lastIndex);
+    const unicode = matcher.flags.includes("u") || matcher.flags.includes("v");
+    const codePoint = input.codePointAt(index);
+    matcher.lastIndex = index + (unicode && codePoint !== void 0 && codePoint > 65535 ? 2 : 1);
+  }
+  budget?.allocateArrayLength(match.captures.length + 1);
+  return { value: toMatchArray(match, input), done: false };
+}
+function getRegExpIteratorMember(property, budget) {
+  if (property === Symbol.toStringTag) return "RegExp String Iterator";
+  if (property === Symbol.iterator) return createSandboxClosure({
+    sandbox: true,
+    name: "[Symbol.iterator]",
+    call: (_args, context) => context?.thisValue
+  });
+  if (property !== "next") return void 0;
+  return createSandboxClosure({
+    sandbox: true,
+    name: "next",
+    call: (_args, context) => {
+      const receiver = context?.thisValue;
+      if (!isSandboxRegExpIterator(receiver))
+        throw new TypeError("RegExp string iterator next requires a matching receiver.");
+      return nextRegExpIterator(receiver, budget);
+    }
+  });
+}
+var init_regexp_iterator2 = __esm({
+  "packages/safe-js/src/interp/methods/regexp-iterator.ts"() {
+    "use strict";
+    init_regexp_iterator();
+    init_values();
+    init_regex();
+  }
+});
+
+// packages/safe-js/src/interp/iteration.ts
+async function acquireSandboxIterator(value, budget, context, asyncProtocol = false, signal) {
+  const key3 = asyncProtocol ? Symbol.asyncIterator : Symbol.iterator;
+  if (context.getProperty === void 0 || isGuestHostObject(value))
+    return asyncProtocol ? getSandboxAsyncIterator(value, budget, context, signal) : getSandboxIterator(value, budget, context);
+  if (getSandboxPropertyDescriptor(value, key3, budget) === void 0 && !(isSandboxRegExpIterator(value) && !asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== void 0)) {
+    if (!asyncProtocol) return getSandboxIterator(value, budget, context);
+    if (isSandboxGenerator(value) && value.async)
+      return getSandboxAsyncIterator(value, budget, context, signal);
+    const iterator2 = await acquireSandboxIterator(value, budget, context);
+    return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal);
+  }
+  const factory = await context.getProperty(value, key3);
+  if (factory === null || factory === void 0) {
+    if (!asyncProtocol) return void 0;
+    const iterator2 = await acquireSandboxIterator(value, budget, context);
+    return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal);
+  }
+  if (!isSandboxClosure(factory)) {
+    if (typeof factory !== "function") throw new TypeError("Iterator method must be callable.");
+    if (asyncProtocol) return nativeAsyncIterator(value, factory, signal);
+    const iterator2 = Reflect.apply(factory, value, []);
+    if (typeof iterator2 !== "object" && typeof iterator2 !== "function" || iterator2 === null)
+      throw new TypeError("Iterator must be an object.");
+    return syncIterator(iterator2);
+  }
+  const iterator = await invokeBuiltinClosure(factory, [], budget, context, value);
+  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null)
+    throw new TypeError("Iterator must be an object.");
+  const next = await context.getProperty(iterator, "next");
+  const invoke2 = async (operation, args) => {
+    if (!isSandboxClosure(operation)) throw new TypeError("Iterator operation must be callable.");
+    const returned = await invokeBuiltinClosure(operation, args, budget, context, iterator);
+    const result = asyncProtocol ? await awaitSandboxValue(returned, signal, budget) : returned;
+    if (typeof result !== "object" && typeof result !== "function" || result === null)
+      throw new TypeError("Iterator result must be an object.");
+    return result;
+  };
+  return {
+    ...asyncProtocol ? { asyncProtocol: true } : {},
+    asynchronous: true,
+    retainedValue: [value, iterator, next],
+    next: (...args) => invoke2(next, args),
+    getOperation: async (method) => {
+      const operation = method === "next" ? next : await context.getProperty(iterator, method);
+      return method !== "next" && (operation === void 0 || operation === null) ? void 0 : (...args) => invoke2(operation, args);
+    },
+    readResultProperty: async (result, property) => ({
+      value: await context.getProperty(result, property)
+    })
+  };
+}
+async function readIteratorResult(iterator, result, property) {
+  return iterator.readResultProperty === void 0 ? { value: result[property] } : iterator.readResultProperty(result, property);
+}
+function getSandboxAsyncIterator(value, budget, context, signal) {
+  if (isSandboxGenerator(value) && value.async) {
+    return { ...generatorIterator(value, budget), asyncProtocol: true };
+  }
+  if (value !== null && (typeof value === "object" || typeof value === "function") && !isGuestHostObject(value)) {
+    const method = value[Symbol.asyncIterator];
+    if (method !== void 0 && method !== null) {
+      return nativeAsyncIterator(value, method, signal);
+    }
+  }
+  const iterator = getSandboxIterator(value, budget, context);
+  return iterator === void 0 ? void 0 : asyncFromSyncIterator(iterator, budget, signal);
+}
+function nativeAsyncIterator(value, method, signal) {
+  if (typeof method !== "function") throw new TypeError("Async iterator method must be callable.");
+  const iterator = Reflect.apply(method, value, []);
+  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null) {
+    throw new TypeError("Async iterator must be an object.");
+  }
+  const next = iterator.next;
+  const invoke2 = async (operation, args) => {
+    if (typeof operation !== "function")
+      throw new TypeError("Async iterator operation must be callable.");
+    const pending = Promise.resolve(Reflect.apply(operation, iterator, args)).then((result2) => ({
+      result: result2
+    }));
+    const { result } = await awaitWithSignal(pending, signal);
+    if (typeof result !== "object" && typeof result !== "function" || result === null) {
+      throw new TypeError("Iterator result must be an object.");
+    }
+    return {
+      get done() {
+        return result.done;
+      },
+      get value() {
+        return result.value;
+      }
+    };
+  };
+  return {
+    asyncProtocol: true,
+    retainedValue: value,
+    next: (...args) => invoke2(next, args),
+    get return() {
+      const operation = iterator.return;
+      return operation === void 0 || operation === null ? void 0 : (...args) => invoke2(operation, args);
+    },
+    get throw() {
+      const operation = iterator.throw;
+      return operation === void 0 || operation === null ? void 0 : (...args) => invoke2(operation, args);
+    }
+  };
+}
+function asyncFromSyncIterator(iterator, budget, signal) {
+  const invoke2 = async (method, args) => {
+    const operation = iterator.getOperation === void 0 ? iterator[method] : await iterator.getOperation(method);
+    if (operation === void 0) {
+      if (method === "throw") {
+        await closeIterator(iterator);
+        throw new TypeError("Delegated iterator does not provide a throw method.");
+      }
+      return { done: true, value: args[0] };
+    }
+    const returned = operation(...args);
+    const result = iterator.generator || iterator.asynchronous ? await returned : returned;
+    if (typeof result !== "object" && typeof result !== "function" || result === null) {
+      throw new TypeError("Iterator result must be an object.");
+    }
+    const done = Boolean((await readIteratorResult(iterator, result, "done")).value);
+    const resultValue = (await readIteratorResult(iterator, result, "value")).value;
+    try {
+      return { done, value: await awaitSandboxValue(resultValue, signal, budget) };
+    } catch (error3) {
+      if (isFatalSandboxError(error3) || error3 instanceof HostCallResumabilityError) throw error3;
+      if (!done && method !== "return") await closeIterator(iterator, true);
+      throw error3;
+    }
+  };
+  return {
+    asyncProtocol: true,
+    snapshotIndex: iterator.snapshotIndex,
+    get retainedValue() {
+      return iterator.retainedValue;
+    },
+    next: (...args) => invoke2("next", args),
+    return: (...args) => invoke2("return", args),
+    throw: (...args) => invoke2("throw", args)
+  };
+}
+async function closeIterator(iterator, preserveThrow = false) {
+  try {
+    const close = iterator.getOperation === void 0 ? iterator.return : await iterator.getOperation("return");
+    if (close === void 0) return;
+    const returned = close();
+    const result = iterator.asyncProtocol ? await suspendJob(Promise.resolve(returned)) : iterator.generator || iterator.asynchronous ? await returned : returned;
+    if (typeof result !== "object" && typeof result !== "function" || result === null) {
+      throw new TypeError("Iterator return result must be an object.");
+    }
+  } catch (error3) {
+    if (!preserveThrow || isFatalSandboxError(error3) || error3 instanceof HostCallResumabilityError)
+      throw error3;
+  }
+}
+function getSandboxIterator(value, budget, context) {
+  if (isSandboxBox(value) && typeof boxedValue(value) === "string") {
+    const primitive = boxedValue(value);
+    let text5;
+    let iterator2;
+    let initialized;
+    return {
+      asynchronous: true,
+      get retainedValue() {
+        return text5 === primitive ? void 0 : text5;
+      },
+      next: async () => {
+        initialized ??= Promise.resolve(sandboxString(value, budget ?? new Budget(), context)).then(
+          (converted) => {
+            text5 = converted;
+            iterator2 = syncIterator(converted[Symbol.iterator]());
+          }
+        );
+        await initialized;
+        return iterator2.next();
+      }
+    };
+  }
+  if (isSandboxCollectionIterator(value))
+    return { next: () => nextCollectionIterator(value, budget), snapshotIndex: () => 0 };
+  if (isSandboxRegExpIterator(value))
+    return { next: () => nextRegExpIterator(value, budget), snapshotIndex: () => 0 };
+  if (isGuestHostObject(value)) return getHostObjectIterator(value);
+  if (isFloat32Array(value)) {
+    return syncIterator(Float32Array.prototype.values.call(value));
+  }
+  if (isSandboxGenerator(value)) {
+    return value.async ? void 0 : generatorIterator(value);
+  }
+  if (typeof value === "string") {
+    return syncIterator(value[Symbol.iterator]());
+  }
+  if (isSandboxMap(value)) {
+    return collectionIterator(value.entries);
+  }
+  if (isSandboxSet(value)) {
+    return collectionIterator(value.values);
+  }
+  if (Array.isArray(value) && hasExplicitSandboxPrototype(value)) return void 0;
+  if (Array.isArray(value) && context?.getProperty !== void 0) {
+    let index = 0;
+    return {
+      asynchronous: true,
+      snapshotIndex: () => index,
+      next: async () => {
+        if (index >= value.length) return { done: true, value: void 0 };
+        budget?.visitNode();
+        return { done: false, value: await context.getProperty(value, index++) };
+      }
+    };
+  }
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return void 0;
+  }
+  const iteratorMethod = value[Symbol.iterator];
+  if (iteratorMethod === void 0 || iteratorMethod === null) return void 0;
+  if (typeof iteratorMethod !== "function") {
+    throw new TypeError("Iterator method must be callable.");
+  }
+  const iterator = Reflect.apply(iteratorMethod, value, []);
+  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null) {
+    throw new TypeError("Iterator must be an object.");
+  }
+  return syncIterator(iterator);
+}
+function collectionIterator(collection) {
+  let iterator = collection[Symbol.iterator]();
+  let exhausted = false;
+  return {
+    ...syncIterator({
+      next: () => {
+        if (exhausted) return { done: true, value: void 0 };
+        const result = iterator.next();
+        exhausted = result.done === true;
+        return result;
+      }
+    }),
+    snapshotIndex: () => {
+      if (exhausted) return collection.size;
+      let remaining = 0;
+      while (!iterator.next().done) remaining += 1;
+      const index = collection.size - remaining;
+      iterator = collection[Symbol.iterator]();
+      for (let skipped = 0; skipped < index; skipped += 1) iterator.next();
+      return index;
+    }
+  };
+}
+function generatorIterator(generator, budget) {
+  const invoke2 = async (method, value) => {
+    const leaveRunning = enterRunningState(generator);
+    const initialState = generator.state;
+    generator.state = "running";
+    try {
+      if (generator.async && method === "return" && (initialState === "start" || initialState === "done")) {
+        if (initialState === "start") await generator.channel.return();
+        value = await awaitSandboxValue(value, void 0, budget);
+      }
+      const result = await generator.channel[method](value);
+      generator.state = result.done ? "done" : "suspended";
+      return result;
+    } catch (error3) {
+      generator.state = "done";
+      throw error3;
+    } finally {
+      leaveRunning();
+    }
+  };
+  const request = (method, value) => {
+    if (!generator.async) return invoke2(method, value);
+    const previous = asyncGeneratorRequests.get(generator) ?? Promise.resolve();
+    const result = previous.then(() => invoke2(method, value));
+    asyncGeneratorRequests.set(
+      generator,
+      result.catch(() => void 0)
+    );
+    return result;
+  };
+  return {
+    generator: true,
+    next: (value) => request("next", value),
+    return: (value) => request("return", value),
+    throw: (error3) => request("throw", error3)
+  };
+}
+function syncIterator(iterator) {
+  const next = iterator.next;
+  const invoke2 = (method, args) => {
+    const leaveRunning = enterRunningState(iterator);
+    try {
+      return Reflect.apply(method, iterator, args);
+    } finally {
+      leaveRunning();
+    }
+  };
+  return {
+    next: (...args) => invoke2(next, args),
+    get return() {
+      const method = iterator.return;
+      if (method === void 0 || method === null) return void 0;
+      if (typeof method !== "function") throw new TypeError("Iterator return must be callable.");
+      return (...args) => invoke2(method, args);
+    },
+    get throw() {
+      const method = iterator.throw;
+      if (method === void 0 || method === null) return void 0;
+      if (typeof method !== "function") throw new TypeError("Iterator throw must be callable.");
+      return (...args) => invoke2(method, args);
+    }
+  };
+}
+var asyncGeneratorRequests;
+var init_iteration = __esm({
+  "packages/safe-js/src/interp/iteration.ts"() {
+    "use strict";
+    init_values();
+    init_running_state();
+    init_float32();
+    init_boxed();
+    init_host_capabilities();
+    init_collection_iterator();
+    init_regexp_iterator();
+    init_regexp_iterator2();
+    init_budget2();
+    init_string_coercion();
+    init_cancel2();
+    init_host_call();
+    init_jobs4();
+    init_builtin_call();
+    init_object_model();
+    asyncGeneratorRequests = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/patterns.ts
+async function bindPattern(pattern, value, target, scope, context, reference) {
+  switch (pattern.type) {
+    case "Identifier":
+      bindIdentifier(pattern, value, target, scope);
+      return { ok: true };
+    case "MemberExpression":
+      if ("kind" in target) {
+        throw new TypeError("Destructuring declarations cannot bind to member expressions.");
+      }
+      return bindMemberExpression(pattern, value, context, reference);
+    case "AssignmentPattern":
+      return bindAssignmentPattern(pattern, value, target, scope, context, reference);
+    case "ArrayPattern":
+      return bindArrayPattern(pattern, value, target, scope, context);
+    case "ObjectPattern":
+      return bindObjectPattern(pattern, value, target, scope, context);
+    case "RestElement":
+      return bindPattern(pattern.argument, value, target, scope, context, reference);
+  }
+}
+function bindIdentifier(pattern, value, target, scope) {
+  if ("assign" in target || target.kind === "var" && target.initialize !== true) {
+    if ("assign" in target) {
+      const binding = scope.lookup(pattern.name);
+      if (!binding.found) {
+        throw new ReferenceError(`Cannot assign to undeclared binding '${pattern.name}'.`);
+      }
+      if (binding.kind === "const") {
+        throw new TypeError(`Cannot assign to const '${pattern.name}'`);
+      }
+    }
+    scope.assign(pattern.name, value);
+    return;
+  }
+  scope.declare(pattern.name, target.kind, value);
+}
+async function bindAssignmentPattern(pattern, value, target, scope, context, reference) {
+  if (value !== void 0) {
+    return bindPattern(pattern.left, value, target, scope, context, reference);
+  }
+  const defaultValue = await context.evaluate(
+    pattern.right,
+    pattern.left.type === "Identifier" ? pattern.left.name : void 0
+  );
+  if (defaultValue.kind !== "normal") {
+    return { ok: false, result: defaultValue };
+  }
+  return bindPattern(pattern.left, defaultValue.value, target, scope, context, reference);
+}
+async function bindPatternValue(pattern, readValue, target, scope, context) {
+  let member = pattern;
+  while (member.type === "AssignmentPattern" || member.type === "RestElement")
+    member = member.type === "AssignmentPattern" ? member.left : member.argument;
+  let reference;
+  if ("assign" in target && member.type === "MemberExpression") {
+    const prepared = await prepareMemberReference(member, context);
+    if (!prepared.ok) return prepared;
+    reference = prepared.reference;
+  }
+  let value;
+  const release2 = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [reference?.object, reference?.key, value]);
+  try {
+    value = (await readValue()).value;
+    return await bindPattern(pattern, value, target, scope, context, reference);
+  } finally {
+    release2();
+  }
+}
+async function bindArrayPattern(pattern, value, target, scope, context) {
+  const budget = context.budget ?? new Budget();
+  const iterator = await acquireSandboxIterator(
+    value,
+    budget,
+    context.callContext ?? {
+      stack: [],
+      thisValue: void 0,
+      getProperty: context.getProperty
+    }
+  );
+  if (iterator === void 0) throw new TypeError("Array destructuring requires an iterable.");
+  let done = false;
+  const next = async (readValue = true) => {
+    if (done) return { value: void 0 };
+    try {
+      const result = await iterator.next();
+      if (typeof result !== "object" && typeof result !== "function" || result === null)
+        throw new TypeError("Iterator result must be an object.");
+      done = Boolean((await readIteratorResult(iterator, result, "done")).value);
+      return done || !readValue ? { value: void 0 } : await readIteratorResult(iterator, result, "value");
+    } catch (error3) {
+      done = true;
+      throw error3;
+    }
+  };
+  let retained;
+  const release2 = retainValues(budget, () => [value, iterator.retainedValue, retained]);
+  try {
+    for (let index = 0; index < pattern.elements.length; index += 1) {
+      const element = pattern.elements[index];
+      if (element === null) {
+        await next(false);
+        continue;
+      }
+      const binding = await bindPatternValue(
+        element,
+        async () => {
+          if (element.type !== "RestElement") return next();
+          const rest = [];
+          retained = rest;
+          for (let entry = await next(); !done; entry = await next()) {
+            budget.allocateArrayLength(rest.length + 1);
+            rest.push(entry.value);
+          }
+          return { value: rest };
+        },
+        target,
+        scope,
+        context
+      );
+      if (!binding.ok) {
+        if (!done) {
+          done = true;
+          await closeIterator(iterator, binding.result.kind === "throw");
+        }
+        return binding;
+      }
+    }
+    if (!done) {
+      done = true;
+      await closeIterator(iterator);
+    }
+    return { ok: true };
+  } catch (error3) {
+    if (!done && !isFatalSandboxError(error3)) await closeIterator(iterator, true);
+    throw error3;
+  } finally {
+    release2();
+  }
+}
+async function bindObjectPattern(pattern, value, target, scope, context) {
+  if (value === void 0 || value === null) {
+    throw new TypeError("Object destructuring requires a non-nullish value.");
+  }
+  const excludedKeys = /* @__PURE__ */ new Set();
+  for (const property of pattern.properties) {
+    if (property.type === "RestElement") {
+      const binding2 = await bindPatternValue(
+        property,
+        async () => ({ value: await copyObjectRestValue(value, excludedKeys, context) }),
+        target,
+        scope,
+        context
+      );
+      if (!binding2.ok) {
+        return binding2;
+      }
+      continue;
+    }
+    const key3 = await evaluatePatternKey(property, context);
+    if (!key3.ok) {
+      return key3;
+    }
+    excludedKeys.add(typeof key3.value === "symbol" ? key3.value : String(key3.value));
+    const binding = await bindPatternValue(
+      property.value,
+      async () => ({ value: await context.getProperty(value, key3.value) }),
+      target,
+      scope,
+      context
+    );
+    if (!binding.ok) {
+      return binding;
+    }
+  }
+  return { ok: true };
+}
+async function bindMemberExpression(pattern, value, context, reference) {
+  if (reference === void 0) {
+    const prepared = await prepareMemberReference(pattern, context);
+    if (!prepared.ok) return prepared;
+    reference = prepared.reference;
+  }
+  if (reference.object === null || reference.object === void 0) {
+    throw new TypeError("Cannot assign properties of null or undefined.");
+  }
+  if (!isIndexableValue(reference.object)) {
+    throw new TypeError("Assignment expressions require a sandbox object property.");
+  }
+  await context.setProperty(reference.object, reference.key, value);
+  return { ok: true };
+}
+async function prepareMemberReference(pattern, context) {
+  const object = await context.evaluate(pattern.object);
+  if (object.kind !== "normal") {
+    return { ok: false, result: object };
+  }
+  const property = pattern.computed ? await context.evaluate(pattern.property) : { kind: "normal", value: getStaticPropertyName2(pattern.property) };
+  if (property.kind !== "normal") {
+    return { ok: false, result: property };
+  }
+  return {
+    ok: true,
+    reference: { object: object.value, key: await context.toPropertyKey(property.value) }
+  };
+}
+async function evaluatePatternKey(property, context) {
+  return property.computed ? evaluateProperty(property.key, context) : { ok: true, value: getStaticPropertyName2(property.key) };
+}
+async function evaluateProperty(property, context) {
+  const result = await context.evaluate(property);
+  if (result.kind !== "normal") {
+    return { ok: false, result };
+  }
+  return { ok: true, value: await context.toPropertyKey(result.value) };
+}
+function getStaticPropertyName2(property) {
+  if (property.type === "Identifier") {
+    return property.name;
+  }
+  if (property.type === "StringLiteral" || property.type === "NumericLiteral") {
+    return property.value;
+  }
+  throw new TypeError(`Unsupported static property node '${property.type}'.`);
+}
+async function copyObjectRestValue(value, excludedKeys, context) {
+  const rest = /* @__PURE__ */ Object.create(null);
+  const release2 = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [value, rest]);
+  try {
+    for (const key3 of ownEnumerableSandboxKeys(value, true)) {
+      if (excludedKeys.has(key3) || !hasOwnSandboxProperty(value, key3, true)) continue;
+      defineProperty(rest, key3, await context.getProperty(value, key3));
+    }
+    return rest;
+  } finally {
+    release2();
+  }
+}
+function isIndexableValue(value) {
+  return typeof value === "object" && value !== null;
+}
+function defineProperty(target, key3, value) {
+  Object.defineProperty(target, key3, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
+}
+var init_patterns = __esm({
+  "packages/safe-js/src/interp/patterns.ts"() {
+    "use strict";
+    init_budget2();
+    init_resources();
+    init_object2();
+    init_iteration();
+    init_values();
+  }
+});
+
 // packages/safe-js/src/interp/async.ts
 function emitResumeBreakpoint(context, breakpoint) {
   context.onYield?.({
@@ -138781,11 +139264,11 @@ async function objectToPrimitive(value, budget, context, joining, hint, ordinary
   }
 }
 function conversionHook(value, name, budget, context) {
-  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) || isSandboxDate(value) || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) || isSandboxGenerator(value) || isGuestHostObject(value));
+  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) || isSandboxDate(value) || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) && getSandboxPrototype(value, budget) === null || isSandboxGenerator(value) || isGuestHostObject(value));
   let current = value;
   let depth = 0;
   while (current !== null) {
-    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : current;
+    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : current;
     const descriptor = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, name);
     if (descriptor !== void 0) {
       return readPropertyDescriptor(descriptor, value, context);
@@ -138810,14 +139293,11 @@ async function defaultToString(value, budget, context, joining) {
   if (isSandboxClosure(value)) return budget.allocateString(functionString(value));
   if (isSandboxMap(value)) return "[object Map]";
   if (isSandboxSet(value)) return "[object Set]";
+  if (isSandboxRegExpIterator(value)) return "[object RegExp String Iterator]";
   if (isSandboxCollectionIterator(value))
     return collectionIteratorState(value).collectionKind === "map" ? "[object Map Iterator]" : "[object Set Iterator]";
   if (isSandboxGenerator(value)) return "[object Generator]";
-  if (isSandboxRegex(value)) {
-    return budget.allocateString(
-      `/${String(getRegexMember(value, "source", budget))}/${String(getRegexMember(value, "flags", budget))}`
-    );
-  }
+  if (isSandboxRegex(value)) return regexToString(value, budget, context);
   if (isSandboxDate(value)) return budget.allocateString(dateString(value));
   if (Array.isArray(value) || isFloat32Array(value)) {
     if (Object.hasOwn(value, "join")) {
@@ -138861,6 +139341,7 @@ var init_string_coercion = __esm({
     init_graph_depth();
     init_host_capabilities();
     init_collection_iterator();
+    init_regexp_iterator();
     init_object_model();
     init_regex();
     init_resources();
@@ -139044,6 +139525,7 @@ function typeTag(value, builtinOnly = false) {
   if (builtinOnly) return "Object";
   if (isSandboxMap(value)) return "Map";
   if (isSandboxSet(value)) return "Set";
+  if (isSandboxRegExpIterator(value)) return "RegExp String Iterator";
   if (isSandboxCollectionIterator(value)) return collectionIteratorState(value).collectionKind === "map" ? "Map Iterator" : "Set Iterator";
   if (isSandboxPromise(value)) return "Promise";
   if (isSandboxGenerator(value)) return "Generator";
@@ -139062,6 +139544,7 @@ var init_object2 = __esm({
     init_float32();
     init_host_capabilities();
     init_collection_iterator();
+    init_regexp_iterator();
     init_object_model();
     init_property_key();
     init_values();
@@ -140443,6 +140926,7 @@ function registerCancelablePromises(value, signal) {
       for (const entry of current.values) pending.push(entry);
     } else {
       if (isSandboxCollectionIterator(current)) pending.push(collectionIteratorState(current).collection);
+      if (isSandboxRegExpIterator(current)) pending.push(regexpIteratorState(current).matcher);
       for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(current))) {
         if ("value" in descriptor) pending.push(descriptor.value);
       }
@@ -140545,6 +141029,7 @@ var init_cancel2 = __esm({
   "packages/safe-js/src/interp/cancel.ts"() {
     "use strict";
     init_collection_iterator();
+    init_regexp_iterator();
     init_object_model();
     init_values();
     init_promise_tracker();
@@ -140889,6 +141374,16 @@ function measureSandboxData(values, options = {}) {
       }
       return;
     }
+    if (isSandboxRegExpIterator(value)) {
+      const state = regexpIteratorState(value);
+      visit(state.matcher, depth + 1);
+      visit(state.input, depth + 1);
+      for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+        usage += key3.length + 1;
+        if ("value" in descriptor) visit(descriptor.value, depth + 1);
+      }
+      return;
+    }
     if (isSandboxCollectionIterator(value)) {
       visit(collectionIteratorState(value).collection, depth + 1);
       for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
@@ -141046,6 +141541,22 @@ function copyToSandbox(value, state, path193 = "<root>", cloneSandboxCollections
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxPromise(value)) {
     return value;
   }
+  if (isSandboxRegExpIterator(value)) {
+    if (hasGuestObjectState(value)) throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
+    if (!cloneSandboxCollections) return value;
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const snapshot2 = regexpIteratorState(value);
+    const copy = restoreSandboxRegExpIterator({ matcher: void 0, input: void 0, exhausted: true });
+    state.seen.set(value, copy);
+    const matcher = copyToSandbox(snapshot2.matcher, state, `${path193}.<matcher>`, true, depth + 1);
+    if (matcher !== void 0 && !isSandboxRegex(matcher)) throw new TypeError("Invalid RegExp iterator matcher.");
+    restoreSandboxRegExpIterator({ ...snapshot2, matcher }, copy);
+    for (const entry of getEnumerableObjectEntries(value, path193)) {
+      defineOwnDataProperty(copy, entry.key, copyToSandbox(entry.value, state, joinPath2(path193, entry.key), true, depth + 1));
+    }
+    return copy;
+  }
   if (isSandboxCollectionIterator(value)) {
     if (hasGuestObjectState(value)) throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
     if (!cloneSandboxCollections) return value;
@@ -141372,6 +141883,9 @@ function copyFromSandbox(value, state, path193 = "<root>", options, depth = 0) {
   if (isSandboxCollectionIterator(value)) {
     throw new TypeError("Sandbox collection iterators cannot cross into host values.");
   }
+  if (isSandboxRegExpIterator(value)) {
+    throw new TypeError("Sandbox RegExp iterators cannot cross into host values.");
+  }
   if (isSandboxRegex(value)) {
     throw new TypeError("Invalid sandbox RegExp brand.");
   }
@@ -141625,6 +142139,7 @@ var init_values = __esm({
     init_accessors();
     init_collection_brands();
     init_collection_iterator();
+    init_regexp_iterator();
     init_date();
     init_boxed();
     init_host_capabilities();
@@ -141830,7 +142345,7 @@ function serializeDumpValue(value, path193, state) {
   if (hasGuestObjectState(value)) {
     throw new TypeError("Guest function properties and prototype links cannot be serialized.");
   }
-  if (isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value)) return serializeHeapReference(value, path193, state);
+  if (isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value)) return serializeHeapReference(value, path193, state);
   if (Array.isArray(value)) {
     const reference2 = serializeHeapReference(value, path193, state);
     if (reference2 !== void 0) {
@@ -141854,7 +142369,28 @@ function serializeHeapReference(value, path193, state) {
   }
   if (!state.serializedHeapIds.has(id)) {
     state.serializedHeapIds.add(id);
-    if (isSandboxRegex(value) && hasCustomRegexProperties(value)) {
+    if (isSandboxRegExpIterator(value)) {
+      const snapshot2 = regexpIteratorState(value);
+      const matcher = snapshot2.matcher;
+      const entries = /* @__PURE__ */ Object.create(null);
+      state.heap[String(id)] = {
+        kind: "regexp-iterator",
+        exhausted: snapshot2.exhausted,
+        matcher: matcher === void 0 ? { kind: "undefined" } : { kind: "regex", source: matcher.source, flags: matcher.flags, lastIndex: Number(matcher.lastIndex) },
+        input: snapshot2.input ?? { kind: "undefined" },
+        entries,
+        symbolEntries: serializeSymbolProperties(value, (entry) => {
+          const serialized = serializeDumpValue(entry, `${path193}.[symbol]`, state);
+          if (serialized === SKIP_VALUE) throw new TypeError("Unsupported RegExp iterator symbol property in public dump.");
+          return serialized;
+        })
+      };
+      for (const [key3, entry] of getEnumerableDataEntries(value)) {
+        const serialized = serializeDumpValue(entry, `${path193}.${key3}`, state);
+        if (serialized === SKIP_VALUE) throw new TypeError("Unsupported RegExp iterator property in public dump.");
+        entries[key3] = serialized;
+      }
+    } else if (isSandboxRegex(value) && hasCustomRegexProperties(value)) {
       const encode = (entry) => {
         const serialized = serializeDumpValue(entry, `${path193}.<regex-property>`, state);
         if (serialized === SKIP_VALUE) throw new TypeError("Unsupported RegExp property in public dump.");
@@ -141946,7 +142482,7 @@ function indexHeapContainers(snapshot2) {
   const heapIds = /* @__PURE__ */ new Map();
   let nextId = 1;
   for (const [value, stat35] of stats2.entries()) {
-    if (stat35.count > 1 || stat35.cyclic || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat35.count > 1 || stat35.cyclic || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -142029,6 +142565,7 @@ var init_dump_format = __esm({
   "packages/safe-js/src/snapshot/dump-format.ts"() {
     "use strict";
     init_values();
+    init_regexp_iterator();
     init_regexp_properties2();
     init_graph_depth();
     init_object_model();
@@ -142097,6 +142634,10 @@ function validateDumpHeap(root, state) {
     const entry = requireRecord3(value, path193);
     validateErrorType(entry, path193);
     validateSymbolEntries(entry, path193, state, heap);
+    if (entry.kind === "regexp-iterator") {
+      validateHeapValue(entry, path193, state, heap);
+      continue;
+    }
     if (entry.kind === "regex-object") {
       validateTaggedValue(entry, path193, state);
       continue;
@@ -142201,6 +142742,9 @@ function validatePosition(value, path193) {
   requireSafeInteger(position.column, `${path193}.column`, 0);
   return requireSafeInteger(position.offset, `${path193}.offset`, 0);
 }
+function validateValue(value, path193, depth, state) {
+  validateGenericValue(value, path193, depth, state);
+}
 function validateTaggedValue(record2, path193, state) {
   switch (record2.kind) {
     case "undefined":
@@ -142244,6 +142788,7 @@ function validateTaggedValue(record2, path193, state) {
     case "map":
     case "set":
     case "collection-iterator":
+    case "regexp-iterator":
       return;
   }
 }
@@ -142284,9 +142829,47 @@ function validateGeneratorShape(record2, path193, state) {
     }
   });
 }
+function validateHeapValue(value, path193, state, heap) {
+  const record2 = requireRecord3(value, path193);
+  validateErrorType(record2, path193);
+  if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "date", "boxed", "collection-iterator", "regexp-iterator", "regex-object"].includes(String(record2.kind)))
+    fail2("unknownTag", `${path193}.kind`, "unknown heap tag");
+  validateValue(record2, path193, 1, state);
+  if (record2.kind === "symbol") validateSymbolRecord(record2, path193, state);
+  if (record2.kind === "arguments") validateArgumentsProperties(record2, path193);
+  if (record2.kind === "array") validateArrayHeap(record2, path193, state);
+  if (record2.kind === "object") requireRecord3(record2.entries, `${path193}.entries`);
+  if (record2.kind === "boxed") validateBoxedRecord(record2, path193, heap);
+  if (record2.kind === "date") validateDateRecord(record2, path193);
+  if (record2.kind === "float32array") {
+    validateFloat32Storage(record2);
+    requireRecord3(record2.entries, `${path193}.entries`);
+  }
+  if (record2.kind === "map") {
+    const entries = requireArray(record2.entries, `${path193}.entries`, state);
+    entries.forEach((entry, index) => {
+      if (!Array.isArray(entry) || entry.length !== 2)
+        fail2("invalidValue", `${path193}.entries[${index}]`, "map entry must contain two values");
+    });
+  }
+  if (record2.kind === "set") requireArray(record2.values, `${path193}.values`, state);
+  if (record2.kind === "regexp-iterator") {
+    if (typeof record2.exhausted !== "boolean") fail2("invalidValue", `${path193}.exhausted`, "invalid iterator exhaustion");
+    if (!Object.hasOwn(record2, "matcher") || !Object.hasOwn(record2, "input")) fail2("invalidValue", path193, "missing RegExp iterator state");
+    requireRecord3(record2.entries, `${path193}.entries`);
+  }
+  if (record2.kind === "collection-iterator") {
+    if (record2.collectionKind !== "map" && record2.collectionKind !== "set") fail2("invalidValue", `${path193}.collectionKind`, "invalid iterator brand");
+    if (record2.method !== "keys" && record2.method !== "values" && record2.method !== "entries") fail2("invalidValue", `${path193}.method`, "invalid iteration method");
+    if (typeof record2.exhausted !== "boolean") fail2("invalidValue", `${path193}.exhausted`, "invalid iterator exhaustion");
+    requireSafeInteger(record2.index, `${path193}.index`, 0);
+    if (!Object.hasOwn(record2, "collection")) fail2("invalidValue", `${path193}.collection`, "missing iterator source");
+    requireRecord3(record2.entries, `${path193}.entries`);
+  }
+}
 function validateSymbolEntries(record2, path193, state, heap) {
   if (record2.symbolEntries === void 0) return;
-  if (record2.kind !== "object" && record2.kind !== "array" && record2.kind !== "date" && record2.kind !== "boxed" && record2.kind !== "regex-object")
+  if (record2.kind !== "object" && record2.kind !== "array" && record2.kind !== "date" && record2.kind !== "boxed" && record2.kind !== "regex-object" && record2.kind !== "regexp-iterator")
     fail2("invalidValue", `${path193}.symbolEntries`, "symbol properties are unsupported for this heap kind");
   const entries = requireArray(record2.symbolEntries, `${path193}.symbolEntries`, state);
   const keys = /* @__PURE__ */ new Set();
@@ -154506,22 +155089,49 @@ 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;
+    let retainedPrototype;
     const retained = {};
-    options.budget.setRetainedValues(retained, () => [...args, source]);
+    options.budget.setRetainedValues(retained, () => [...args, source, retainedSource, retainedFlags, retainedPrototype]);
     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 = (key3) => {
+        const descriptor = getSandboxPropertyDescriptor(pattern, key3, options.budget);
+        if (context?.getProperty !== void 0) return context.getProperty(pattern, key3);
+        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");
+      }
+      if (construct && context?.newTarget !== void 0 && context.newTarget !== constructor) {
+        retainedPrototype = context.getProperty !== void 0 ? await context.getProperty(context.newTarget, "prototype") : await readPropertyDescriptor(getSandboxPropertyDescriptor(context.newTarget, "prototype", options.budget) ?? { value: void 0 }, context.newTarget, context);
+      }
       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,
         0,
         compilation
       );
+      if (typeof retainedPrototype === "object" && retainedPrototype !== null)
+        setSandboxPrototype(regex, retainedPrototype, options.budget);
       if (compilation !== context?.compilation) {
         reconcileCompiledValues(options.budget, [regex], compilation);
       }
@@ -154532,9 +155142,82 @@ function createRegexGlobals(options) {
       operation.release();
     }
   };
-  return {
-    RegExp: createSandboxClosure({ sandbox: true, name: "RegExp", call: invoke2(false), construct: invoke2(true) })
-  };
+  const constructor = createSandboxClosure({ guest: true, sandbox: true, name: "RegExp", length: 2, call: invoke2(false), construct: invoke2(true) });
+  const prototype = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
+  Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
+  Object.defineProperty(prototype, Symbol.search, {
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "[Symbol.search]",
+      length: 1,
+      call: (args, context) => regexSearch(context?.thisValue, args[0], options.budget, context)
+    }),
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(prototype, Symbol.match, {
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "[Symbol.match]",
+      length: 1,
+      call: (args, context) => regexMatch(args[0], context?.thisValue, options.budget, context)
+    }),
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(prototype, Symbol.replace, {
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "[Symbol.replace]",
+      length: 2,
+      call: (args, context) => regexReplace(
+        args[0],
+        context?.thisValue,
+        args[1],
+        options.budget,
+        (closure, values) => invokeBuiltinClosure(closure, values, options.budget, context, void 0),
+        context
+      )
+    }),
+    writable: true,
+    configurable: true
+  });
+  for (const name of ["exec", "test", "toString"]) {
+    Object.defineProperty(prototype, name, {
+      value: createSandboxClosure({
+        sandbox: true,
+        name,
+        length: name === "toString" ? 0 : 1,
+        call: (args, context) => callRegexMethod(context?.thisValue, name, args, options.budget, context)
+      }),
+      writable: true,
+      configurable: true
+    });
+  }
+  for (const name of ["source", "flags", ...Object.keys(regexFlagProperties)]) {
+    const getter = createSandboxClosure({
+      sandbox: true,
+      name: `get ${name}`,
+      length: 0,
+      call: (_args, context) => {
+        const receiver = context?.thisValue;
+        if (name === "flags") {
+          if (receiver === null || typeof receiver !== "object") throw new TypeError("RegExp flags requires an object receiver.");
+          return getRegexMember(receiver, name, options.budget, context);
+        }
+        if (receiver === prototype) return name === "source" ? "(?:)" : void 0;
+        if (!isSandboxRegex(receiver)) throw new TypeError("RegExp accessor requires a regex receiver.");
+        return getRegexMember(receiver, name, options.budget, context);
+      }
+    });
+    Object.defineProperty(prototype, name, { get: accessorAdapter(getter, "get"), configurable: true });
+  }
+  installRegexPrototype(options.budget, prototype, constructor);
+  return { RegExp: constructor };
 }
 var init_regex2 = __esm({
   "packages/safe-js/src/interp/globals/regex.ts"() {
@@ -154543,6 +155226,11 @@ var init_regex2 = __esm({
     init_compile_guard();
     init_budget2();
     init_string_coercion();
+    init_object_model();
+    init_accessors();
+    init_regex();
+    init_string();
+    init_builtin_call();
   }
 });
 
@@ -154589,7 +155277,7 @@ function structuredCloneSandboxValue(value, budget, parent) {
   }
 }
 function assertStructuredCloneable(value, seen) {
-  if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value)) {
+  if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value)) {
     throw new TypeError("structuredClone() cannot clone closures, promises, or collection iterators.");
   }
   if (typeof value !== "object" || value === null || seen.has(value)) {
@@ -154617,6 +155305,7 @@ var init_misc = __esm({
   "packages/safe-js/src/interp/globals/misc.ts"() {
     "use strict";
     init_collection_iterator();
+    init_regexp_iterator();
     init_graph_depth();
     init_compile_guard();
     init_numeric_parsers();
@@ -156190,6 +156879,7 @@ var init_serialize = __esm({
     init_regexp_properties2();
     init_symbols3();
     init_collection_iterator();
+    init_regexp_iterator();
     init_object_model();
     init_shape();
     init_graph_depth();
@@ -156266,6 +156956,17 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
         value = descriptor2.value;
         continue;
       }
+      if (isSandboxRegExpIterator(value)) {
+        if (key3 === "<matcher>") value = regexpIteratorState(value).matcher;
+        else if (key3 === "<input>") value = regexpIteratorState(value).input;
+        else {
+          const property = JSON.parse(key3);
+          if (!Array.isArray(property) || property.length !== 2 || property[0] !== "property" || typeof property[1] !== "string") throw new TypeError("Invalid replay input iterator capability path.");
+          const descriptor2 = Object.getOwnPropertyDescriptor(value, property[1]);
+          value = descriptor2 !== void 0 && "value" in descriptor2 ? descriptor2.value : void 0;
+        }
+        continue;
+      }
       if (isSandboxCollectionIterator(value)) {
         if (key3 === "<collection>") value = collectionIteratorState(value).collection;
         else {
@@ -156336,11 +157037,11 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
   return { values: restored, snapshot: structuredClone(saved) };
 }
 function assertReplayInputShape(restored) {
-  if (restored === null || typeof restored !== "object" || Array.isArray(restored) || isSandboxClosure(restored) || isSandboxPromise(restored) || isSandboxCollectionIterator(restored) || isSandboxMap(restored) || isSandboxSet(restored))
+  if (restored === null || typeof restored !== "object" || Array.isArray(restored) || isSandboxClosure(restored) || isSandboxPromise(restored) || isSandboxCollectionIterator(restored) || isSandboxRegExpIterator(restored) || isSandboxMap(restored) || isSandboxSet(restored))
     throw new TypeError("Invalid replay inputs.");
   const values = restored;
   for (const key3 of ["bindings", "imports"]) {
-    if (values[key3] === null || typeof values[key3] !== "object" || Array.isArray(values[key3]) || isSandboxClosure(values[key3]) || isSandboxPromise(values[key3]) || isSandboxCollectionIterator(values[key3]) || isSandboxMap(values[key3]) || isSandboxSet(values[key3]))
+    if (values[key3] === null || typeof values[key3] !== "object" || Array.isArray(values[key3]) || isSandboxClosure(values[key3]) || isSandboxPromise(values[key3]) || isSandboxCollectionIterator(values[key3]) || isSandboxRegExpIterator(values[key3]) || isSandboxMap(values[key3]) || isSandboxSet(values[key3]))
       throw new TypeError(`Invalid replay input ${key3}.`);
   }
   if (values.entryPointArgs !== void 0 && !Array.isArray(values.entryPointArgs))
@@ -156351,6 +157052,7 @@ var init_replay_inputs = __esm({
   "packages/safe-js/src/snapshot/replay-inputs.ts"() {
     "use strict";
     init_collection_iterator();
+    init_regexp_iterator();
     init_values();
     init_replay_data();
     init_compile_guard();
@@ -162381,11 +163083,11 @@ async function resolveWorkflowTasksOptions(options) {
   };
 }
 function readGateStates(frontmatter) {
-  const states2 = asRecord6(frontmatter.states);
-  if (states2 === void 0) {
+  const states3 = asRecord6(frontmatter.states);
+  if (states3 === void 0) {
     return [];
   }
-  return Object.entries(states2).filter(([, definition]) => asRecord6(definition)?.gate === true).map(([name]) => name);
+  return Object.entries(states3).filter(([, definition]) => asRecord6(definition)?.gate === true).map(([name]) => name);
 }
 async function readWorkflowFrontmatter(workflowPath) {
   const workflowContent = await readWorkflow(workflowPath);
@@ -162416,11 +163118,11 @@ function readTaskListOptions(frontmatter, workflowPath) {
   }
   return resolved;
 }
-function createAnyToAnyStateMachine(states2) {
+function createAnyToAnyStateMachine(states3) {
   return {
-    initial: states2[0],
-    states: states2,
-    events: Object.fromEntries(states2.map((state) => [state, { from: "*", to: state }]))
+    initial: states3[0],
+    states: states3,
+    events: Object.fromEntries(states3.map((state) => [state, { from: "*", to: state }]))
   };
 }
 function parseProject(value) {
@@ -162441,9 +163143,9 @@ function parseProject(value) {
 }
 function resolveRequiredStates(statesOption, frontmatter) {
   if (statesOption !== void 0) {
-    const states2 = parseStatesCsv(statesOption);
-    if (states2.length > 0) {
-      return states2;
+    const states3 = parseStatesCsv(statesOption);
+    if (states3.length > 0) {
+      return states3;
     }
     throw new TasksOptionsError(
       "missing_required_states",
@@ -162493,8 +163195,8 @@ function readLegacyTopLevelStates(frontmatter) {
   ]);
 }
 function readDeclaredStates(value) {
-  const states2 = asRecord6(value);
-  return states2 === void 0 ? [] : Object.keys(states2);
+  const states3 = asRecord6(value);
+  return states3 === void 0 ? [] : Object.keys(states3);
 }
 function readTasksRepo(frontmatter) {
   const tasks = asRecord6(getOwnEntry37(frontmatter, "tasks"));