@poe-platform/safe-js 0.1.171 → 0.1.173

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

@@ -6717,6 +6717,23 @@ function nativeIterator(collection, method) {
   return collection.kind === "map" ? collection.entries[method]() : collection.values[method]();
 }
 
+// packages/safe-js/src/interp/regexp-iterator.ts
+var states2 = /* @__PURE__ */ new WeakMap();
+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;
+}
+
 // packages/safe-js/src/interp/boxed.ts
 import { types as types3 } from "node:util";
 var boxes = /* @__PURE__ */ new WeakSet();
@@ -7463,6 +7480,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 key of Object.keys(value)) {
     const descriptor = Object.getOwnPropertyDescriptor(value, key);
     if (descriptor !== void 0 && "value" in descriptor)
@@ -7889,7 +7907,7 @@ function serializeDumpValue(value, path, 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, path, state);
+  if (isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value)) return serializeHeapReference(value, path, state);
   if (Array.isArray(value)) {
     const reference2 = serializeHeapReference(value, path, state);
     if (reference2 !== void 0) {
@@ -7913,7 +7931,28 @@ function serializeHeapReference(value, path, state) {
   }
   if (!state.serializedHeapIds.has(id)) {
     state.serializedHeapIds.add(id);
-    if (isSandboxRegex(value) && hasCustomRegexProperties(value)) {
+    if (isSandboxRegExpIterator(value)) {
+      const snapshot = regexpIteratorState(value);
+      const matcher = snapshot.matcher;
+      const entries = /* @__PURE__ */ Object.create(null);
+      state.heap[String(id)] = {
+        kind: "regexp-iterator",
+        exhausted: snapshot.exhausted,
+        matcher: matcher === void 0 ? { kind: "undefined" } : { kind: "regex", source: matcher.source, flags: matcher.flags, lastIndex: Number(matcher.lastIndex) },
+        input: snapshot.input ?? { kind: "undefined" },
+        entries,
+        symbolEntries: serializeSymbolProperties(value, (entry) => {
+          const serialized = serializeDumpValue(entry, `${path}.[symbol]`, state);
+          if (serialized === SKIP_VALUE) throw new TypeError("Unsupported RegExp iterator symbol property in public dump.");
+          return serialized;
+        })
+      };
+      for (const [key, entry] of getEnumerableDataEntries(value)) {
+        const serialized = serializeDumpValue(entry, `${path}.${key}`, state);
+        if (serialized === SKIP_VALUE) throw new TypeError("Unsupported RegExp iterator property in public dump.");
+        entries[key] = serialized;
+      }
+    } else if (isSandboxRegex(value) && hasCustomRegexProperties(value)) {
       const encode = (entry) => {
         const serialized = serializeDumpValue(entry, `${path}.<regex-property>`, state);
         if (serialized === SKIP_VALUE) throw new TypeError("Unsupported RegExp property in public dump.");
@@ -8005,7 +8044,7 @@ function indexHeapContainers(snapshot) {
   const heapIds = /* @__PURE__ */ new Map();
   let nextId = 1;
   for (const [value, stat2] of stats.entries()) {
-    if (stat2.count > 1 || stat2.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 (stat2.count > 1 || stat2.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;
     }
@@ -8161,6 +8200,10 @@ function validateDumpHeap(root, state) {
     const entry = requireRecord(value, path);
     validateErrorType(entry, path);
     validateSymbolEntries(entry, path, state, heap);
+    if (entry.kind === "regexp-iterator") {
+      validateHeapValue(entry, path, state, heap);
+      continue;
+    }
     if (entry.kind === "regex-object") {
       validateTaggedValue(entry, path, state);
       continue;
@@ -8265,6 +8308,9 @@ function validatePosition(value, path) {
   requireSafeInteger(position.column, `${path}.column`, 0);
   return requireSafeInteger(position.offset, `${path}.offset`, 0);
 }
+function validateValue(value, path, depth, state) {
+  validateGenericValue(value, path, depth, state);
+}
 function validateTaggedValue(record2, path, state) {
   switch (record2.kind) {
     case "undefined":
@@ -8308,6 +8354,7 @@ function validateTaggedValue(record2, path, state) {
     case "map":
     case "set":
     case "collection-iterator":
+    case "regexp-iterator":
       return;
   }
 }
@@ -8348,9 +8395,47 @@ function validateGeneratorShape(record2, path, state) {
     }
   });
 }
+function validateHeapValue(value, path, state, heap) {
+  const record2 = requireRecord(value, path);
+  validateErrorType(record2, path);
+  if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "date", "boxed", "collection-iterator", "regexp-iterator", "regex-object"].includes(String(record2.kind)))
+    fail("unknownTag", `${path}.kind`, "unknown heap tag");
+  validateValue(record2, path, 1, state);
+  if (record2.kind === "symbol") validateSymbolRecord(record2, path, state);
+  if (record2.kind === "arguments") validateArgumentsProperties(record2, path);
+  if (record2.kind === "array") validateArrayHeap(record2, path, state);
+  if (record2.kind === "object") requireRecord(record2.entries, `${path}.entries`);
+  if (record2.kind === "boxed") validateBoxedRecord(record2, path, heap);
+  if (record2.kind === "date") validateDateRecord(record2, path);
+  if (record2.kind === "float32array") {
+    validateFloat32Storage(record2);
+    requireRecord(record2.entries, `${path}.entries`);
+  }
+  if (record2.kind === "map") {
+    const entries = requireArray(record2.entries, `${path}.entries`, state);
+    entries.forEach((entry, index) => {
+      if (!Array.isArray(entry) || entry.length !== 2)
+        fail("invalidValue", `${path}.entries[${index}]`, "map entry must contain two values");
+    });
+  }
+  if (record2.kind === "set") requireArray(record2.values, `${path}.values`, state);
+  if (record2.kind === "regexp-iterator") {
+    if (typeof record2.exhausted !== "boolean") fail("invalidValue", `${path}.exhausted`, "invalid iterator exhaustion");
+    if (!Object.hasOwn(record2, "matcher") || !Object.hasOwn(record2, "input")) fail("invalidValue", path, "missing RegExp iterator state");
+    requireRecord(record2.entries, `${path}.entries`);
+  }
+  if (record2.kind === "collection-iterator") {
+    if (record2.collectionKind !== "map" && record2.collectionKind !== "set") fail("invalidValue", `${path}.collectionKind`, "invalid iterator brand");
+    if (record2.method !== "keys" && record2.method !== "values" && record2.method !== "entries") fail("invalidValue", `${path}.method`, "invalid iteration method");
+    if (typeof record2.exhausted !== "boolean") fail("invalidValue", `${path}.exhausted`, "invalid iterator exhaustion");
+    requireSafeInteger(record2.index, `${path}.index`, 0);
+    if (!Object.hasOwn(record2, "collection")) fail("invalidValue", `${path}.collection`, "missing iterator source");
+    requireRecord(record2.entries, `${path}.entries`);
+  }
+}
 function validateSymbolEntries(record2, path, 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")
     fail("invalidValue", `${path}.symbolEntries`, "symbol properties are unsupported for this heap kind");
   const entries = requireArray(record2.symbolEntries, `${path}.symbolEntries`, state);
   const keys = /* @__PURE__ */ new Set();
@@ -9181,346 +9266,728 @@ async function withRunResources(signal, execute) {
   return result;
 }
 
-// packages/safe-js/src/interp/jobs.ts
-import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
-var activeJob = new AsyncLocalStorage4();
-var SandboxJobQueue = class {
-  running = false;
-  pending = [];
-  ready = [];
-  idle = [];
-  generation = 0;
-  acquire(job) {
-    return new Promise((resolve) => {
-      this.pending.push(() => {
-        this.running = true;
-        this.generation += 1;
-        job.ownsExecution = true;
-        resolve();
-      });
-      this.advance();
-    });
-  }
-  release(job) {
-    job.prefixParent = void 0;
-    if (!job.ownsExecution) return;
-    job.ownsExecution = false;
-    this.running = false;
-    this.advance();
-  }
-  async run(task) {
-    const job = { queue: this, ownsExecution: false };
-    await this.acquire(job);
-    return activeJob.run(job, async () => {
-      try {
-        return await task();
-      } finally {
-        this.release(job);
-      }
-    });
+// 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;
   }
-  async drain() {
-    let idleTurns = 0;
-    while (idleTurns < 20) {
-      const generation = this.generation;
-      if (this.running) await new Promise((resolve) => this.idle.push(resolve));
-      await Promise.resolve();
-      idleTurns = generation === this.generation ? idleTurns + 1 : 0;
+  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);
     }
   }
-  advance() {
-    if (this.running) return;
-    if (this.ready.length === 0 && this.pending.length > 0) {
-      const empty = this.ready;
-      this.ready = this.pending.reverse();
-      this.pending = empty;
+  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;
     }
-    const next = this.ready.pop();
-    if (next !== void 0) {
-      next();
-    } else {
-      for (const resolve of this.idle.splice(0)) resolve();
+    case "characterClass": {
+      const character = context.input[state.position];
+      if (character !== void 0 && matchesCharacterClass(character, 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 runPromiseJob(task) {
-  const job = activeJob.getStore();
-  return job === void 0 ? Promise.resolve().then(task) : job.queue.run(task);
-}
-function runAsyncPrefix(task) {
-  const parent = activeJob.getStore();
-  if (parent === void 0) return task();
-  let owner = parent;
-  while (owner !== void 0 && !owner.ownsExecution) owner = owner.prefixParent;
-  if (owner === void 0) return parent.queue.run(task);
-  const job = { queue: parent.queue, ownsExecution: false, prefixParent: parent };
-  return activeJob.run(job, async () => {
-    try {
-      return await task();
-    } finally {
-      job.queue.release(job);
-    }
-  });
 }
-async function suspendJob(pending) {
-  const job = activeJob.getStore();
-  if (job === void 0) return pending;
-  job.queue.release(job);
-  try {
-    return await pending;
-  } finally {
-    await job.queue.acquire(job);
+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);
   }
 }
-
-// packages/safe-js/src/interp/iteration.ts
-async function acquireSandboxIterator(value, budget, context, asyncProtocol = false, signal) {
-  const key = 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, key, 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);
+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;
   }
-  const factory = await context.getProperty(value, key);
-  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 (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 (!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);
+  if (node.greedy && count >= node.min) {
+    yield state;
   }
-  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 invoke = 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) => invoke(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) => invoke(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);
-    }
+function matchesAnchor(kind, position, context) {
+  if (kind === "start") {
+    return position === 0 || context.flags.multiline && position > 0 && isLineTerminator(context.input[position - 1]);
   }
-  const iterator = getSandboxIterator(value, budget, context);
-  return iterator === void 0 ? void 0 : asyncFromSyncIterator(iterator, budget, signal);
+  return position === context.input.length || context.flags.multiline && position < context.input.length && isLineTerminator(context.input[position]);
 }
-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.");
+function matchesCharacterClass(character, items, negated, ignoreCase) {
+  const matched = items.some((item) => matchesCharacterClassItem(character, item, ignoreCase));
+  return negated ? !matched : matched;
+}
+function matchesCharacterClassItem(character, item, ignoreCase) {
+  if (item.type === "character") {
+    return charactersEqual(character, item.value, ignoreCase);
   }
-  const next = iterator.next;
-  const invoke = 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.");
+  if (item.type === "range") {
+    const candidate = character.charCodeAt(0);
+    const from = item.from.charCodeAt(0);
+    const to = item.to.charCodeAt(0);
+    if (candidate >= from && candidate <= to) {
+      return true;
     }
-    return {
-      get done() {
-        return result.done;
-      },
-      get value() {
-        return result.value;
-      }
-    };
-  };
-  return {
-    asyncProtocol: true,
-    retainedValue: value,
-    next: (...args) => invoke(next, args),
-    get return() {
-      const operation = iterator.return;
-      return operation === void 0 || operation === null ? void 0 : (...args) => invoke(operation, args);
-    },
-    get throw() {
-      const operation = iterator.throw;
-      return operation === void 0 || operation === null ? void 0 : (...args) => invoke(operation, args);
+    if (!ignoreCase) {
+      return false;
     }
-  };
+    const foldedCandidate = foldCharacter(character, 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" ? isDigit(character) : item.kind === "word" ? isWordCharacter(character) : isSpaceCharacter(character);
+  return item.negated ? !matched : matched;
 }
-function asyncFromSyncIterator(iterator, budget, signal) {
-  const invoke = 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 (error) {
-      if (isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
-      if (!done && method !== "return") await closeIterator(iterator, true);
-      throw error;
-    }
-  };
+function toRegexMatch(input, start, state) {
   return {
-    asyncProtocol: true,
-    snapshotIndex: iterator.snapshotIndex,
-    get retainedValue() {
-      return iterator.retainedValue;
-    },
-    next: (...args) => invoke("next", args),
-    return: (...args) => invoke("return", args),
-    throw: (...args) => invoke("throw", args)
+    index: start,
+    text: input.slice(start, state.position),
+    captures: state.captures.map(
+      (capture) => capture === void 0 ? void 0 : input.slice(capture.start, capture.end)
+    )
   };
 }
-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 (error) {
-    if (!preserveThrow || isFatalSandboxError(error) || error instanceof HostCallResumabilityError)
-      throw error;
-  }
+function cloneState(state) {
+  return { position: state.position, captures: state.captures.slice() };
 }
-function getSandboxIterator(value, budget, context) {
-  if (isSandboxBox(value) && typeof boxedValue(value) === "string") {
-    const primitive = boxedValue(value);
-    let text;
-    let iterator2;
-    let initialized;
-    return {
-      asynchronous: true,
-      get retainedValue() {
-        return text === primitive ? void 0 : text;
-      },
-      next: async () => {
-        initialized ??= Promise.resolve(sandboxString(value, budget ?? new Budget(), context)).then(
-          (converted) => {
-            text = 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);
+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 (typeof value === "string") {
-    return syncIterator(value[Symbol.iterator]());
+  if (node.type === "sequence") {
+    for (const element of node.elements) {
+      clearNodeCaptures(element, captures);
+    }
+    return;
   }
-  if (isSandboxMap(value)) {
-    return collectionIterator(value.entries);
+  if (node.type === "alternation") {
+    for (const alternative of node.alternatives) {
+      clearNodeCaptures(alternative, captures);
+    }
+    return;
   }
-  if (isSandboxSet(value)) {
-    return collectionIterator(value.values);
+  if (node.type === "quantifier") {
+    clearNodeCaptures(node.body, captures);
   }
-  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++) };
-      }
-    };
+}
+function charge(context) {
+  context.steps += 1;
+  allocateRegexSteps(context.steps);
+}
+function normalizeLastIndex(lastIndex) {
+  if (Number.isNaN(lastIndex) || lastIndex <= 0) {
+    return 0;
   }
-  if (typeof value !== "object" && typeof value !== "function" || value === null) {
-    return void 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(character, ignoreCase) {
+  if (!ignoreCase) {
+    return character;
   }
-  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 folded = character.toUpperCase();
+  if (folded.length !== 1) {
+    return character;
   }
-  const iterator = Reflect.apply(iteratorMethod, value, []);
-  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null) {
-    throw new TypeError("Iterator must be an object.");
+  if (character.charCodeAt(0) >= 128 && folded.charCodeAt(0) < 128) {
+    return character;
   }
-  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;
-    }
-  };
+  return folded;
+}
+function isDigit(character) {
+  return character >= "0" && character <= "9";
+}
+function isWordCharacter(character) {
+  return isDigit(character) || character >= "A" && character <= "Z" || character >= "a" && character <= "z" || character === "_";
+}
+function isSpaceCharacter(character) {
+  return character === " " || character === "\f" || character === "\n" || character === "\r" || character === "	" || character === "\v" || character === "\xA0" || character === "\u1680" || character >= "\u2000" && character <= "\u200A" || character === "\u2028" || character === "\u2029" || character === "\u202F" || character === "\u205F" || character === "\u3000" || character === "\uFEFF";
+}
+function isLineTerminator(character) {
+  return character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029";
+}
+
+// packages/safe-js/src/interp/methods/regex.ts
+var regexMethodNames = /* @__PURE__ */ new Set(["exec", "test"]);
+var regexFlagProperties = {
+  hasIndices: "d",
+  global: "g",
+  ignoreCase: "i",
+  multiline: "m",
+  dotAll: "s",
+  unicode: "u",
+  unicodeSets: "v",
+  sticky: "y"
+};
+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 text = "";
+  let escaped = false;
+  let inClass = false;
+  for (const character of source) {
+    budget?.visitNode();
+    if (character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029") {
+      if (escaped) text = text.slice(0, -1);
+      text += character === "\n" ? "\\n" : character === "\r" ? "\\r" : character === "\u2028" ? "\\u2028" : "\\u2029";
+      escaped = false;
+    } else {
+      if (!escaped && character === "[") inClass = true;
+      if (!escaped && character === "]") inClass = false;
+      text += character === "/" && !escaped && !inClass ? "\\/" : character;
+      escaped = character === "\\" && !escaped;
+    }
+    budget?.allocateString(text);
+  }
+  text = text === "" ? "(?:)" : text;
+  return budget === void 0 ? text : budget.allocateString(text);
+}
+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 cursor;
+  let convertedInput;
+  budget.setRetainedValues(retained, () => [target, ...args, cursor, convertedInput]);
+  try {
+    const input = await sandboxString(args[0], budget, context);
+    if (methodName === "test") {
+      const exec = context?.getProperty === void 0 ? getSandboxDataProperty(target, "exec", budget) : await context.getProperty(target, "exec");
+      if (isSandboxClosure(exec)) {
+        const result = await invokeBuiltinClosure(exec, [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;
+    cursor = target.lastIndex;
+    const lastIndex = await sandboxNumber(cursor, 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;
+}
+
+// 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);
+    }
+  });
+}
+
+// packages/safe-js/src/interp/jobs.ts
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
+var activeJob = new AsyncLocalStorage4();
+var SandboxJobQueue = class {
+  running = false;
+  pending = [];
+  ready = [];
+  idle = [];
+  generation = 0;
+  acquire(job) {
+    return new Promise((resolve) => {
+      this.pending.push(() => {
+        this.running = true;
+        this.generation += 1;
+        job.ownsExecution = true;
+        resolve();
+      });
+      this.advance();
+    });
+  }
+  release(job) {
+    job.prefixParent = void 0;
+    if (!job.ownsExecution) return;
+    job.ownsExecution = false;
+    this.running = false;
+    this.advance();
+  }
+  async run(task) {
+    const job = { queue: this, ownsExecution: false };
+    await this.acquire(job);
+    return activeJob.run(job, async () => {
+      try {
+        return await task();
+      } finally {
+        this.release(job);
+      }
+    });
+  }
+  async drain() {
+    let idleTurns = 0;
+    while (idleTurns < 20) {
+      const generation = this.generation;
+      if (this.running) await new Promise((resolve) => this.idle.push(resolve));
+      await Promise.resolve();
+      idleTurns = generation === this.generation ? idleTurns + 1 : 0;
+    }
+  }
+  advance() {
+    if (this.running) return;
+    if (this.ready.length === 0 && this.pending.length > 0) {
+      const empty = this.ready;
+      this.ready = this.pending.reverse();
+      this.pending = empty;
+    }
+    const next = this.ready.pop();
+    if (next !== void 0) {
+      next();
+    } else {
+      for (const resolve of this.idle.splice(0)) resolve();
+    }
+  }
+};
+function runPromiseJob(task) {
+  const job = activeJob.getStore();
+  return job === void 0 ? Promise.resolve().then(task) : job.queue.run(task);
+}
+function runAsyncPrefix(task) {
+  const parent = activeJob.getStore();
+  if (parent === void 0) return task();
+  let owner = parent;
+  while (owner !== void 0 && !owner.ownsExecution) owner = owner.prefixParent;
+  if (owner === void 0) return parent.queue.run(task);
+  const job = { queue: parent.queue, ownsExecution: false, prefixParent: parent };
+  return activeJob.run(job, async () => {
+    try {
+      return await task();
+    } finally {
+      job.queue.release(job);
+    }
+  });
+}
+async function suspendJob(pending) {
+  const job = activeJob.getStore();
+  if (job === void 0) return pending;
+  job.queue.release(job);
+  try {
+    return await pending;
+  } finally {
+    await job.queue.acquire(job);
+  }
+}
+
+// packages/safe-js/src/interp/iteration.ts
+async function acquireSandboxIterator(value, budget, context, asyncProtocol = false, signal) {
+  const key = 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, key, 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, key);
+  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 invoke = 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) => invoke(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) => invoke(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 invoke = 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) => invoke(next, args),
+    get return() {
+      const operation = iterator.return;
+      return operation === void 0 || operation === null ? void 0 : (...args) => invoke(operation, args);
+    },
+    get throw() {
+      const operation = iterator.throw;
+      return operation === void 0 || operation === null ? void 0 : (...args) => invoke(operation, args);
+    }
+  };
+}
+function asyncFromSyncIterator(iterator, budget, signal) {
+  const invoke = 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 (error) {
+      if (isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
+      if (!done && method !== "return") await closeIterator(iterator, true);
+      throw error;
+    }
+  };
+  return {
+    asyncProtocol: true,
+    snapshotIndex: iterator.snapshotIndex,
+    get retainedValue() {
+      return iterator.retainedValue;
+    },
+    next: (...args) => invoke("next", args),
+    return: (...args) => invoke("return", args),
+    throw: (...args) => invoke("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 (error) {
+    if (!preserveThrow || isFatalSandboxError(error) || error instanceof HostCallResumabilityError)
+      throw error;
+  }
+}
+function getSandboxIterator(value, budget, context) {
+  if (isSandboxBox(value) && typeof boxedValue(value) === "string") {
+    const primitive = boxedValue(value);
+    let text;
+    let iterator2;
+    let initialized;
+    return {
+      asynchronous: true,
+      get retainedValue() {
+        return text === primitive ? void 0 : text;
+      },
+      next: async () => {
+        initialized ??= Promise.resolve(sandboxString(value, budget ?? new Budget(), context)).then(
+          (converted) => {
+            text = 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;
+    }
+  };
 }
 var asyncGeneratorRequests = /* @__PURE__ */ new WeakMap();
 function generatorIterator(generator, budget) {
@@ -9587,716 +10054,376 @@ function syncIterator(iterator) {
   };
 }
 
-// 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 release = 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 {
-    release();
-  }
-}
-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 (error) {
-      done = true;
-      throw error;
-    }
-  };
-  let retained;
-  const release = 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 (error) {
-    if (!done && !isFatalSandboxError(error)) await closeIterator(iterator, true);
-    throw error;
-  } finally {
-    release();
-  }
-}
-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 key = await evaluatePatternKey(property, context);
-    if (!key.ok) {
-      return key;
-    }
-    excludedKeys.add(typeof key.value === "symbol" ? key.value : String(key.value));
-    const binding = await bindPatternValue(
-      property.value,
-      async () => ({ value: await context.getProperty(value, key.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 release = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [value, rest]);
-  try {
-    for (const key of ownEnumerableSandboxKeys(value, true)) {
-      if (excludedKeys.has(key) || !hasOwnSandboxProperty(value, key, true)) continue;
-      defineProperty(rest, key, await context.getProperty(value, key));
-    }
-    return rest;
-  } finally {
-    release();
-  }
-}
-function isIndexableValue(value) {
-  return typeof value === "object" && value !== null;
-}
-function defineProperty(target, key, value) {
-  Object.defineProperty(target, key, {
-    configurable: true,
-    enumerable: true,
-    value,
-    writable: true
-  });
-}
-
-// 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);
+// 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);
   }
 }
-
-// packages/safe-js/src/interp/data-checkpoint.ts
-function createDataCheckpoint(budget, context) {
-  let estimatedDataSize = 0;
-  return (value, growth = 0, force = false) => {
-    const limit = budget.limits.dataSize;
-    if (limit === void 0) return;
-    estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
-    if (!force && estimatedDataSize <= limit) return;
-    if (context?.reconcileData !== void 0) context.reconcileData(value);
-    else reconcileCompiledValues(budget, [value], context?.compilation);
-    estimatedDataSize = budget.currentDataSize;
-  };
-}
-
-// packages/safe-js/src/interp/globals/numeric-parsers.ts
-function createNumericParsers(budget) {
-  return {
-    parseInt: createSandboxClosure({
-      sandbox: true,
-      name: "parseInt",
-      call: ([value, radix], context) => {
-        const parse2 = (text2) => {
-          const release = retainValues(budget, () => [text2]);
-          let convertedRadix;
-          try {
-            convertedRadix = sandboxNumber(radix, budget, context);
-          } catch (error) {
-            release();
-            throw error;
-          }
-          if (typeof convertedRadix === "number") {
-            try {
-              return globalThis.parseInt(text2, convertedRadix);
-            } finally {
-              release();
-            }
-          }
-          return convertedRadix.then((number) => globalThis.parseInt(text2, number)).finally(release);
-        };
-        const text = sandboxString(value, budget, context);
-        return typeof text === "string" ? parse2(text) : text.then(parse2);
+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}'.`);
       }
-    }),
-    parseFloat: createSandboxClosure({
-      sandbox: true,
-      name: "parseFloat",
-      call: ([value], context) => {
-        const text = sandboxString(value, budget, context);
-        return typeof text === "string" ? globalThis.parseFloat(text) : text.then(globalThis.parseFloat);
+      if (binding.kind === "const") {
+        throw new TypeError(`Cannot assign to const '${pattern.name}'`);
       }
-    })
-  };
-}
-
-// packages/safe-js/src/interp/methods/number.ts
-var numberMethodNames = /* @__PURE__ */ new Set([
-  "toExponential",
-  "toFixed",
-  "toPrecision",
-  "toString"
-]);
-function getNumberMember(property, budget) {
-  if (!isNumberMethodName(property)) {
-    return void 0;
+    }
+    scope.assign(pattern.name, value);
+    return;
   }
-  return createSandboxClosure({
-    sandbox: true,
-    name: `Number#${property}`,
-    call: (args, context) => callNumberMethod(context?.thisValue, property, args, budget, context)
-  });
-}
-function isNumberMethodName(property) {
-  return typeof property === "string" && numberMethodNames.has(property);
+  scope.declare(pattern.name, target.kind, value);
 }
-function callNumberMethod(value, methodName, args, budget, context) {
-  if (isSandboxBox(value)) value = boxedValue(value);
-  if (typeof value !== "number") {
-    throw new TypeError(`Number#${methodName} requires a number receiver.`);
+async function bindAssignmentPattern(pattern, value, target, scope, context, reference) {
+  if (value !== void 0) {
+    return bindPattern(pattern.left, value, target, scope, context, reference);
   }
-  const argument = args[0];
-  if (argument !== null && typeof argument === "object") {
-    return formatObjectArgument(value, methodName, argument, budget, context);
+  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 formatNumber(value, methodName, argument === void 0 ? void 0 : Number(argument), budget);
+  return bindPattern(pattern.left, defaultValue.value, target, scope, context, reference);
 }
-async function formatObjectArgument(value, methodName, argument, budget, context) {
-  const retainedArgument = {};
-  budget.setRetainedValues(retainedArgument, () => [argument]);
-  try {
-    const number = await sandboxNumber(argument, budget, context);
-    return formatNumber(value, methodName, number, budget);
-  } finally {
-    budget.setRetainedValues(retainedArgument, void 0);
+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;
   }
-}
-function formatNumber(value, methodName, argument, budget) {
-  let result;
+  let value;
+  const release = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [reference?.object, reference?.key, value]);
   try {
-    result = value[methodName](argument);
-  } catch (error) {
-    if (!(error instanceof RangeError)) throw error;
-    const detail = methodName === "toString" ? "radix must be between 2 and 36." : methodName === "toPrecision" ? "precision must be between 1 and 100." : "digits must be between 0 and 100.";
-    throw new RangeError(`Number#${methodName} ${detail}`);
-  }
-  return budget.allocateString(result);
-}
-
-// packages/safe-js/src/interp/methods/string.ts
-import { types as types6 } from "node:util";
-
-// packages/safe-js/src/interp/regex/engine.ts
-function matchRegex(pattern, input, lastIndex = 0) {
-  const startIndex = pattern.flags.global ? normalizeLastIndex(lastIndex) : 0;
-  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);
-    }
+    value = (await readValue()).value;
+    return await bindPattern(pattern, value, target, scope, context, reference);
+  } finally {
+    release();
   }
-  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;
+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
     }
-    case "characterClass": {
-      const character = context.input[state.position];
-      if (character !== void 0 && matchesCharacterClass(character, node.items, node.negated, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + 1 };
-      }
-      return;
+  );
+  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 (error) {
+      done = true;
+      throw error;
     }
-    case "sequence":
-      yield* matchSequence(node.elements, 0, state, context);
-      return;
-    case "alternation":
-      for (const alternative of node.alternatives) {
-        yield* matchNode(alternative, cloneState(state), context);
+  };
+  let retained;
+  const release = 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;
       }
-      return;
-    case "group":
-      for (const result of matchNode(node.body, cloneState(state), context)) {
-        if (!node.capturing || node.index === void 0) {
-          yield result;
-          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");
         }
-        const captures = result.captures.slice();
-        captures[node.index - 1] = { start: state.position, end: result.position };
-        yield { position: result.position, captures };
+        return binding;
       }
-      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);
+    }
+    if (!done) {
+      done = true;
+      await closeIterator(iterator);
+    }
+    return { ok: true };
+  } catch (error) {
+    if (!done && !isFatalSandboxError(error)) await closeIterator(iterator, true);
+    throw error;
+  } finally {
+    release();
   }
 }
-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;
+async function bindObjectPattern(pattern, value, target, scope, context) {
+  if (value === void 0 || value === null) {
+    throw new TypeError("Object destructuring requires a non-nullish value.");
   }
-  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;
+  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;
       }
-      yield* matchQuantifier(node, result, context, count + 1);
+      continue;
     }
-  }
-  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(character, items, negated, ignoreCase) {
-  const matched = items.some((item) => matchesCharacterClassItem(character, item, ignoreCase));
-  return negated ? !matched : matched;
-}
-function matchesCharacterClassItem(character, item, ignoreCase) {
-  if (item.type === "character") {
-    return charactersEqual(character, item.value, ignoreCase);
-  }
-  if (item.type === "range") {
-    const candidate = character.charCodeAt(0);
-    const from = item.from.charCodeAt(0);
-    const to = item.to.charCodeAt(0);
-    if (candidate >= from && candidate <= to) {
-      return true;
+    const key = await evaluatePatternKey(property, context);
+    if (!key.ok) {
+      return key;
     }
-    if (!ignoreCase) {
-      return false;
+    excludedKeys.add(typeof key.value === "symbol" ? key.value : String(key.value));
+    const binding = await bindPatternValue(
+      property.value,
+      async () => ({ value: await context.getProperty(value, key.value) }),
+      target,
+      scope,
+      context
+    );
+    if (!binding.ok) {
+      return binding;
     }
-    const foldedCandidate = foldCharacter(character, 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" ? isDigit(character) : item.kind === "word" ? isWordCharacter(character) : isSpaceCharacter(character);
-  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 };
+  return { ok: true };
 }
-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;
+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 (node.type === "sequence") {
-    for (const element of node.elements) {
-      clearNodeCaptures(element, captures);
-    }
-    return;
+  if (reference.object === null || reference.object === void 0) {
+    throw new TypeError("Cannot assign properties of null or undefined.");
   }
-  if (node.type === "alternation") {
-    for (const alternative of node.alternatives) {
-      clearNodeCaptures(alternative, captures);
-    }
-    return;
+  if (!isIndexableValue(reference.object)) {
+    throw new TypeError("Assignment expressions require a sandbox object property.");
   }
-  if (node.type === "quantifier") {
-    clearNodeCaptures(node.body, captures);
+  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) }
+  };
 }
-function charge(context) {
-  context.steps += 1;
-  allocateRegexSteps(context.steps);
+async function evaluatePatternKey(property, context) {
+  return property.computed ? evaluateProperty(property.key, context) : { ok: true, value: getStaticPropertyName(property.key) };
 }
-function normalizeLastIndex(lastIndex) {
-  if (Number.isNaN(lastIndex) || lastIndex <= 0) {
-    return 0;
+async function evaluateProperty(property, context) {
+  const result = await context.evaluate(property);
+  if (result.kind !== "normal") {
+    return { ok: false, result };
   }
-  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);
+  return { ok: true, value: await context.toPropertyKey(result.value) };
 }
-function foldCharacter(character, ignoreCase) {
-  if (!ignoreCase) {
-    return character;
+function getStaticPropertyName(property) {
+  if (property.type === "Identifier") {
+    return property.name;
   }
-  const folded = character.toUpperCase();
-  if (folded.length !== 1) {
-    return character;
+  if (property.type === "StringLiteral" || property.type === "NumericLiteral") {
+    return property.value;
   }
-  if (character.charCodeAt(0) >= 128 && folded.charCodeAt(0) < 128) {
-    return character;
+  throw new TypeError(`Unsupported static property node '${property.type}'.`);
+}
+async function copyObjectRestValue(value, excludedKeys, context) {
+  const rest = /* @__PURE__ */ Object.create(null);
+  const release = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [value, rest]);
+  try {
+    for (const key of ownEnumerableSandboxKeys(value, true)) {
+      if (excludedKeys.has(key) || !hasOwnSandboxProperty(value, key, true)) continue;
+      defineProperty(rest, key, await context.getProperty(value, key));
+    }
+    return rest;
+  } finally {
+    release();
   }
-  return folded;
 }
-function isDigit(character) {
-  return character >= "0" && character <= "9";
+function isIndexableValue(value) {
+  return typeof value === "object" && value !== null;
 }
-function isWordCharacter(character) {
-  return isDigit(character) || character >= "A" && character <= "Z" || character >= "a" && character <= "z" || character === "_";
+function defineProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
 }
-function isSpaceCharacter(character) {
-  return character === " " || character === "\f" || character === "\n" || character === "\r" || character === "	" || character === "\v" || character === "\xA0" || character === "\u1680" || character >= "\u2000" && character <= "\u200A" || character === "\u2028" || character === "\u2029" || character === "\u202F" || character === "\u205F" || character === "\u3000" || character === "\uFEFF";
+
+// 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);
+      }
+    }
+  }
 }
-function isLineTerminator(character) {
-  return character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029";
+
+// packages/safe-js/src/interp/data-checkpoint.ts
+function createDataCheckpoint(budget, context) {
+  let estimatedDataSize = 0;
+  return (value, growth = 0, force = false) => {
+    const limit = budget.limits.dataSize;
+    if (limit === void 0) return;
+    estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
+    if (!force && estimatedDataSize <= limit) return;
+    if (context?.reconcileData !== void 0) context.reconcileData(value);
+    else reconcileCompiledValues(budget, [value], context?.compilation);
+    estimatedDataSize = budget.currentDataSize;
+  };
 }
 
-// packages/safe-js/src/interp/methods/regex.ts
-var regexMethodNames = /* @__PURE__ */ new Set(["exec", "test"]);
-var regexFlagProperties = {
-  hasIndices: "d",
-  global: "g",
-  ignoreCase: "i",
-  multiline: "m",
-  dotAll: "s",
-  unicode: "u",
-  unicodeSets: "v",
-  sticky: "y"
-};
-function isRegexMethodName(property) {
-  return typeof property === "string" && regexMethodNames.has(property);
+// packages/safe-js/src/interp/globals/numeric-parsers.ts
+function createNumericParsers(budget) {
+  return {
+    parseInt: createSandboxClosure({
+      sandbox: true,
+      name: "parseInt",
+      call: ([value, radix], context) => {
+        const parse2 = (text2) => {
+          const release = retainValues(budget, () => [text2]);
+          let convertedRadix;
+          try {
+            convertedRadix = sandboxNumber(radix, budget, context);
+          } catch (error) {
+            release();
+            throw error;
+          }
+          if (typeof convertedRadix === "number") {
+            try {
+              return globalThis.parseInt(text2, convertedRadix);
+            } finally {
+              release();
+            }
+          }
+          return convertedRadix.then((number) => globalThis.parseInt(text2, number)).finally(release);
+        };
+        const text = sandboxString(value, budget, context);
+        return typeof text === "string" ? parse2(text) : text.then(parse2);
+      }
+    }),
+    parseFloat: createSandboxClosure({
+      sandbox: true,
+      name: "parseFloat",
+      call: ([value], context) => {
+        const text = sandboxString(value, budget, context);
+        return typeof text === "string" ? globalThis.parseFloat(text) : text.then(globalThis.parseFloat);
+      }
+    })
+  };
 }
-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)) {
+
+// packages/safe-js/src/interp/methods/number.ts
+var numberMethodNames = /* @__PURE__ */ new Set([
+  "toExponential",
+  "toFixed",
+  "toPrecision",
+  "toString"
+]);
+function getNumberMember(property, budget) {
+  if (!isNumberMethodName(property)) {
     return void 0;
   }
   return createSandboxClosure({
     sandbox: true,
-    name: `RegExp#${property}`,
-    call: (args, context) => callRegexMethod(context?.thisValue, property, args, budget, context)
+    name: `Number#${property}`,
+    call: (args, context) => callNumberMethod(context?.thisValue, property, args, budget, context)
   });
 }
-function escapeRegexSource(source, budget) {
-  let text = "";
-  let escaped = false;
-  let inClass = false;
-  for (const character of source) {
-    budget?.visitNode();
-    if (character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029") {
-      if (escaped) text = text.slice(0, -1);
-      text += character === "\n" ? "\\n" : character === "\r" ? "\\r" : character === "\u2028" ? "\\u2028" : "\\u2029";
-      escaped = false;
-    } else {
-      if (!escaped && character === "[") inClass = true;
-      if (!escaped && character === "]") inClass = false;
-      text += character === "/" && !escaped && !inClass ? "\\/" : character;
-      escaped = character === "\\" && !escaped;
-    }
-    budget?.allocateString(text);
-  }
-  text = text === "" ? "(?:)" : text;
-  return budget === void 0 ? text : budget.allocateString(text);
+function isNumberMethodName(property) {
+  return typeof property === "string" && numberMethodNames.has(property);
 }
-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.`);
+function callNumberMethod(value, methodName, args, budget, context) {
+  if (isSandboxBox(value)) value = boxedValue(value);
+  if (typeof value !== "number") {
+    throw new TypeError(`Number#${methodName} requires a number receiver.`);
   }
-  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 argument = args[0];
+  if (argument !== null && typeof argument === "object") {
+    return formatObjectArgument(value, methodName, argument, budget, context);
   }
-  const retained = {};
-  let cursor;
-  let convertedInput;
-  budget.setRetainedValues(retained, () => [target, ...args, cursor, convertedInput]);
+  return formatNumber(value, methodName, argument === void 0 ? void 0 : Number(argument), budget);
+}
+async function formatObjectArgument(value, methodName, argument, budget, context) {
+  const retainedArgument = {};
+  budget.setRetainedValues(retainedArgument, () => [argument]);
   try {
-    const input = await sandboxString(args[0], budget, context);
-    if (methodName === "test") {
-      const exec = context?.getProperty === void 0 ? getSandboxDataProperty(target, "exec", budget) : await context.getProperty(target, "exec");
-      if (isSandboxClosure(exec)) {
-        const result = await invokeBuiltinClosure(exec, [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;
-    cursor = target.lastIndex;
-    const lastIndex = await sandboxNumber(cursor, budget, context);
-    const match = executeRegex(target, input, lastIndex);
-    return methodName === "test" ? match !== null : toMatchArray(match, input);
+    const number = await sandboxNumber(argument, budget, context);
+    return formatNumber(value, methodName, number, budget);
   } 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;
+    budget.setRetainedValues(retainedArgument, void 0);
   }
-  return match;
 }
-function toMatchArray(match, input) {
-  if (match === null) {
-    return null;
+function formatNumber(value, methodName, argument, budget) {
+  let result;
+  try {
+    result = value[methodName](argument);
+  } catch (error) {
+    if (!(error instanceof RangeError)) throw error;
+    const detail = methodName === "toString" ? "radix must be between 2 and 36." : methodName === "toPrecision" ? "precision must be between 1 and 100." : "digits must be between 0 and 100.";
+    throw new RangeError(`Number#${methodName} ${detail}`);
   }
-  const result = [match.text, ...match.captures];
-  Object.assign(result, { index: match.index, input, groups: void 0 });
-  return result;
+  return budget.allocateString(result);
 }
 
 // packages/safe-js/src/interp/methods/string.ts
-var SPLIT_STRING_MESSAGE = "String#split only supports string separator values.";
+import { types as types6 } from "node:util";
 var stringMethodNames = /* @__PURE__ */ new Set([
   "at",
   "charAt",
@@ -10461,6 +10588,7 @@ function callStringMethodBody(value, methodName, args, budget, callClosure = asy
   if (methodName === "replace" || methodName === "replaceAll") {
     return callReplaceLikeMethod(value, methodName, args, budget, callClosure, context);
   }
+  if (methodName === "split") return callSplit(value, args, budget, parent, context);
   const regex = args[0];
   if (isSandboxRegex(regex) && regex.lastIndex !== null && typeof regex.lastIndex === "object" && (methodName === "match" && !regex.flags.includes("g") || methodName === "matchAll")) {
     return callStringRegexCursor(value, methodName, regex, budget, parent, context);
@@ -10471,9 +10599,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);
     }
@@ -10727,42 +10852,69 @@ function findReplacementOffsets(value, searchValue, replaceAll) {
   }
   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, parent, context) {
+  const pattern = args[0];
+  const useRegex = isSandboxRegex(pattern) && getSandboxPropertyDescriptor(pattern, Symbol.split, budget) === void 0;
+  let separator;
+  const release = 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(release);
+    release();
+    return result;
+  } catch (error) {
+    release();
+    throw error;
+  }
+}
+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;
+      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 >= limit) break;
+        result2.push(budget.allocateString(value.slice(copiedThrough, match.index)));
+        for (const capture of match.captures) {
+          if (result2.length >= limit) break;
+          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))
+        result2.push(budget.allocateString(value.slice(copiedThrough)));
+      budget.allocateArrayLength(result2.length);
+      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;
 }
@@ -10811,9 +10963,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 = [];
@@ -14711,6 +14864,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);
   }
@@ -14965,7 +15119,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);
       }
     }
@@ -15337,7 +15491,7 @@ function createLoopIterationContext(context, scope) {
       if (context.activeLoopIterations.size === 0) return snapshot;
       snapshot.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}`;
           snapshot.bindings[bindingName] = iteration.values;
           snapshot.loopIterations[nodeId] = { index: iteration.index, values: [bindingName] };
@@ -15685,6 +15839,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);
@@ -16267,7 +16422,7 @@ function hasSandboxProperty(value, key, context) {
   while (typeof current === "object" && current !== null) {
     if (isGuestHostObject(current)) return typeof key === "symbol" ? false : hasHostObjectMember(current, String(key));
     if (hasOwnSandboxProperty(current, key, 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 (!((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, key, context) !== void 0;
     }
     current = getSandboxPrototype(current, context.budget);
@@ -16467,7 +16622,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)];
@@ -17249,6 +17404,16 @@ function encodeReplayData(value, options = {}) {
         };
       }
       nodes[id] = { ...storage, properties, extensible: Object.isExtensible(entry) };
+    } else if (isSandboxRegExpIterator(entry)) {
+      const snapshot = regexpIteratorState(entry);
+      const properties = /* @__PURE__ */ Object.create(null);
+      for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(entry))) {
+        if (!("value" in descriptor)) throw new TypeError(`Cannot record replay data accessor '${key}'.`);
+        properties[key] = { value: child(descriptor.value, JSON.stringify(["property", key])), configurable: descriptor.configurable === true, enumerable: descriptor.enumerable === true, writable: descriptor.writable === true };
+      }
+      let symbolIndex = 0;
+      const symbolEntries = serializeSymbolProperties(entry, (value2) => encode(value2, depth + 1, [...path, { symbol: Math.floor(symbolIndex++ / 2) }]));
+      nodes[id] = { kind: "regexp-iterator", matcher: child(snapshot.matcher, "<matcher>"), input: child(snapshot.input, "<input>"), exhausted: snapshot.exhausted, properties, extensible: Object.isExtensible(entry), symbolEntries };
     } else if (isSandboxCollectionIterator(entry)) {
       const snapshot = snapshotCollectionIterator(entry);
       const properties = /* @__PURE__ */ Object.create(null);
@@ -17439,6 +17604,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");
@@ -18754,7 +18933,7 @@ 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) || isSandboxGenerator(value) || isGuestHostObject(value));
   let current = value;
   let depth = 0;
   while (current !== null) {
@@ -18783,6 +18962,7 @@ 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]";
@@ -18987,6 +19167,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";
@@ -20339,6 +20520,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);
       }
@@ -20776,6 +20958,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 [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+        usage += key.length + 1;
+        if ("value" in descriptor) visit(descriptor.value, depth + 1);
+      }
+      return;
+    }
     if (isSandboxCollectionIterator(value)) {
       visit(collectionIteratorState(value).collection, depth + 1);
       for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
@@ -20933,6 +21125,22 @@ function copyToSandbox(value, state, path = "<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 snapshot = regexpIteratorState(value);
+    const copy = restoreSandboxRegExpIterator({ matcher: void 0, input: void 0, exhausted: true });
+    state.seen.set(value, copy);
+    const matcher = copyToSandbox(snapshot.matcher, state, `${path}.<matcher>`, true, depth + 1);
+    if (matcher !== void 0 && !isSandboxRegex(matcher)) throw new TypeError("Invalid RegExp iterator matcher.");
+    restoreSandboxRegExpIterator({ ...snapshot, matcher }, copy);
+    for (const entry of getEnumerableObjectEntries(value, path)) {
+      defineOwnDataProperty(copy, entry.key, copyToSandbox(entry.value, state, joinPath2(path, 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;
@@ -21259,6 +21467,9 @@ function copyFromSandbox(value, state, path = "<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.");
   }
@@ -33923,7 +34134,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)) {
@@ -35504,6 +35715,17 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
         value = descriptor2.value;
         continue;
       }
+      if (isSandboxRegExpIterator(value)) {
+        if (key === "<matcher>") value = regexpIteratorState(value).matcher;
+        else if (key === "<input>") value = regexpIteratorState(value).input;
+        else {
+          const property = JSON.parse(key);
+          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 (key === "<collection>") value = collectionIteratorState(value).collection;
         else {
@@ -35574,11 +35796,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 key of ["bindings", "imports"]) {
-    if (values[key] === null || typeof values[key] !== "object" || Array.isArray(values[key]) || isSandboxClosure(values[key]) || isSandboxPromise(values[key]) || isSandboxCollectionIterator(values[key]) || isSandboxMap(values[key]) || isSandboxSet(values[key]))
+    if (values[key] === null || typeof values[key] !== "object" || Array.isArray(values[key]) || isSandboxClosure(values[key]) || isSandboxPromise(values[key]) || isSandboxCollectionIterator(values[key]) || isSandboxRegExpIterator(values[key]) || isSandboxMap(values[key]) || isSandboxSet(values[key]))
       throw new TypeError(`Invalid replay input ${key}.`);
   }
   if (values.entryPointArgs !== void 0 && !Array.isArray(values.entryPointArgs))
@@ -36179,4 +36401,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-XKCTB5FR.js.map
+//# sourceMappingURL=chunk-QR5MFF7T.js.map