@poe-platform/safe-js 0.1.89 → 0.1.90

package/dist/safe-js/chunks/{chunk-M4M56OCI.js → chunk-774EXZKX.js}

@@ -6997,26 +6997,8 @@ function getSandboxPrototype(value, budget) {
   if (prototypes.has(value)) return prototypes.get(value) ?? null;
   return budget !== void 0 && isPrototypeRecord(value) ? intrinsicPrototypes.get(budget) ?? null : null;
 }
-function getSandboxDataProperty(value, key, budget) {
-  let current = value;
-  let depth = 0;
-  while (typeof current === "object" && current !== null) {
-    if (isGuestHostObject(current)) return getHostObjectMember(current, String(key));
-    if (isGuestClosure(current)) return getGuestFunctionProperty(current, String(key));
-    if (isSandboxClosure(current)) {
-      const properties = current.properties;
-      return properties !== void 0 && Object.hasOwn(properties, String(key)) ? properties[String(key)] : void 0;
-    }
-    if (isSandboxMap(current) || isSandboxSet(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxGenerator(current))
-      return void 0;
-    if (Object.hasOwn(current, String(key))) return current[String(key)];
-    current = getSandboxPrototype(current, budget);
-    if (current !== null) {
-      budget?.visitNode();
-      assertSandboxDataDepth(++depth);
-    }
-  }
-  return void 0;
+function hasExplicitSandboxPrototype(value) {
+  return prototypes.has(value);
 }
 function setSandboxPrototype(value, prototype, budget) {
   if (budget !== void 0 && intrinsicPrototypes.get(budget) === value && prototype !== null) {
@@ -8178,609 +8160,930 @@ function isCounter(value) {
 // packages/safe-js/src/interp/cancel.ts
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 
-// packages/safe-js/src/interp/string-coercion.ts
-function sandboxString(value, budget, context, joining = /* @__PURE__ */ new Set()) {
-  if (value === null || typeof value !== "object") {
-    if (typeof value === "function") throw new TypeError("Expected a sandbox value.");
-    return budget.allocateString(String(value));
-  }
-  return stringifyObject(value, budget, context, joining);
+// 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);
 }
-async function stringifyObject(value, budget, context, joining) {
-  const leaveCall = budget.enterCall();
-  try {
-    budget.visitNode();
-    for (const name of ["toString", "valueOf"]) {
-      const descriptor = Object.getOwnPropertyDescriptor(value, name);
-      let result;
-      if (descriptor === void 0) {
-        if (name === "valueOf") continue;
-        result = await defaultToString(value, budget, context, joining);
-      } else {
-        const hook = ownDataValue(value, name);
-        if (!isSandboxClosure(hook)) continue;
-        if (context?.invokeClosure === void 0) {
-          throw new TypeError("String hooks require a sandbox call context.");
-        }
-        result = await context.invokeClosure(hook, [], value);
-      }
-      if (result === null || typeof result !== "object") {
-        return sandboxString(result, budget, context, joining);
-      }
+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);
     }
-    throw new TypeError("Cannot convert object to primitive value");
-  } finally {
-    leaveCall();
   }
+  return null;
 }
-async function defaultToString(value, budget, context, joining) {
-  if (isSandboxDate(value)) return budget.allocateString(dateString(value));
-  if (Array.isArray(value) || isFloat32Array(value)) {
-    if (Object.hasOwn(value, "join")) {
-      const join = ownDataValue(value, "join");
-      if (!isSandboxClosure(join))
-        return isFloat32Array(value) ? "[object Float32Array]" : "[object Array]";
-      if (context?.invokeClosure === void 0) {
-        throw new TypeError("String hooks require a sandbox call context.");
+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 context.invokeClosure(join, [], value);
+      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;
     }
-    if (joining.has(value)) return "";
-    joining.add(value);
-    try {
-      const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
-      let text = "";
-      for (let index = 0; index < length; index++) {
-        budget.visitNode();
-        const element = ownDataValue(value, String(index));
-        const part = element === null || element === void 0 ? "" : await sandboxString(element, budget, context, joining);
-        text = budget.allocateString(text + (index === 0 ? "" : ",") + part);
+    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 text;
-    } finally {
-      joining.delete(value);
+      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);
   }
-  if (sandboxErrorTypes.has(value)) {
-    const nameValue = ownDataValue(value, "name");
-    const name = nameValue === void 0 ? "Error" : await sandboxString(nameValue, budget, context, joining);
-    const messageValue = ownDataValue(value, "message");
-    const message = messageValue === void 0 ? "" : await sandboxString(messageValue, budget, context, joining);
-    return name === "" ? message : message === "" ? name : `${name}: ${message}`;
-  }
-  return isSandboxPromise(value) ? "[object Promise]" : "[object Object]";
 }
-function ownDataValue(value, name) {
-  const descriptor = Object.getOwnPropertyDescriptor(value, name);
-  if (descriptor !== void 0 && !Object.hasOwn(descriptor, "value")) {
-    throw new TypeError("String conversion requires sandbox data properties.");
+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);
   }
-  return descriptor?.value;
 }
-
-// packages/safe-js/src/interp/property-key.ts
-async function toPropertyKey(value, budget, context) {
-  if (typeof value === "string") return value;
-  const invocation = context.invokeClosure === void 0 ? {
-    ...context,
-    invokeClosure: async (closure, args, thisValue) => {
-      const leaveCall = budget.enterCall();
-      try {
-        const result = closure.call(args, { ...invocation, thisValue });
-        if (isSandboxPromise(result)) {
-          await result.synchronousPrefix;
-          return result;
+function* matchQuantifier(node, state, context, count) {
+  charge(context);
+  const canRepeat = node.max === void 0 || count < node.max;
+  if (!node.greedy && count >= node.min) {
+    yield state;
+  }
+  if (canRepeat) {
+    for (const result of matchNode(node.body, clearCaptures(node.body, state), context)) {
+      if (result.position === state.position) {
+        if (count >= node.min) {
+          continue;
         }
-        return await result;
-      } finally {
-        leaveCall();
-      }
-    }
-  } : context;
-  if (typeof value === "object" && value !== null && !Array.isArray(value) && !isSandboxClosure(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isSandboxPromise(value) && !isSandboxRegex(value) && !isSandboxDate(value) && !isFloat32Array(value) && !isSandboxGenerator(value) && !isGuestHostObject(value)) {
-    for (const name of ["toString", "valueOf"]) {
-      const method = getSandboxDataProperty(value, name, budget);
-      if (!isSandboxClosure(method)) continue;
-      const primitive = await invocation.invokeClosure(method, [], value);
-      if (primitive === null || typeof primitive !== "object") {
-        return budget.allocateString(String(primitive));
+        if (count + 1 >= node.min) {
+          yield result;
+        } else {
+          yield* matchQuantifier(node, result, context, count + 1);
+        }
+        continue;
       }
+      yield* matchQuantifier(node, result, context, count + 1);
     }
-    throw new TypeError("Cannot convert object to primitive value.");
   }
-  return sandboxString(value, budget, invocation);
-}
-
-// packages/safe-js/src/interp/exceptions.ts
-var capturedExceptionBrand = /* @__PURE__ */ Symbol("CapturedException");
-async function evaluateThrowStatement(node, context, evaluateNode2) {
-  const argument = await evaluateNode2(node.argument, context);
-  if (argument.kind !== "normal") {
-    return argument;
+  if (node.greedy && count >= node.min) {
+    yield state;
   }
-  return {
-    kind: "throw",
-    hasValue: true,
-    span: node.span,
-    stackFrames: context.callStack,
-    value: argument.value
-  };
 }
-async function evaluateTryStatement(node, context, evaluateNode2) {
-  let fatalBudgetError;
-  let tryResult;
-  try {
-    tryResult = await evaluateBlockCompletion(node.block, context, evaluateNode2);
-  } catch (error) {
-    if (!isBudgetExceeded(error) || node.finalizer === void 0) {
-      throw error;
-    }
-    fatalBudgetError = error;
-    tryResult = {
-      kind: "throw",
-      hasValue: true,
-      value: void 0
-    };
-  }
-  const tryOrCatchResult = fatalBudgetError === void 0 && tryResult.kind === "throw" && node.handler !== void 0 ? await evaluateCatchClause(node.handler, tryResult.value, context, evaluateNode2) : tryResult;
-  if (node.finalizer === void 0 || tryOrCatchResult.kind === "error") {
-    return tryOrCatchResult;
-  }
-  const evaluateFinalizer = () => fatalBudgetError?.budget === "deadline" ? evaluateWithoutDeadlineChecks(
-    context,
-    () => evaluateBlockCompletion(node.finalizer, context, evaluateNode2)
-  ) : evaluateBlockCompletion(node.finalizer, context, evaluateNode2);
-  const finalizerResult = await (fatalBudgetError === void 0 ? evaluateFinalizer() : withFatalPromiseCleanup(evaluateFinalizer));
-  if (fatalBudgetError !== void 0) {
-    throw fatalBudgetError;
-  }
-  if (finalizerResult.kind === "normal") {
-    return tryOrCatchResult;
+function matchesAnchor(kind, position, context) {
+  if (kind === "start") {
+    return position === 0 || context.flags.multiline && position > 0 && isLineTerminator(context.input[position - 1]);
   }
-  return finalizerResult;
-}
-function createCapturedException(reason, stackFrames, sandbox = false) {
-  return {
-    reason,
-    sandbox,
-    stackFrames,
-    [capturedExceptionBrand]: true
-  };
+  return position === context.input.length || context.flags.multiline && position < context.input.length && isLineTerminator(context.input[position]);
 }
-function isCapturedException(value) {
-  return typeof value === "object" && value !== null && capturedExceptionBrand in value;
+function matchesCharacterClass(character, items, negated, ignoreCase) {
+  const matched = items.some((item) => matchesCharacterClassItem(character, item, ignoreCase));
+  return negated ? !matched : matched;
 }
-function coerceThrownValue(reason, budget, stackFrames, span, sandbox = false) {
-  if (reason instanceof HostCallResumabilityError) {
-    throw reason;
-  }
-  if (isSubsetErrorValue(reason)) {
-    attachErrorSpan(reason, readErrorSpan(reason) ?? span);
-    return reason;
-  }
-  if (reason instanceof Error) {
-    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
-      chargeBudget: false,
-      cause: readErrorCause(reason),
-      span
-    });
-  }
-  if (sandbox) {
-    return reason;
+function matchesCharacterClassItem(character, item, ignoreCase) {
+  if (item.type === "character") {
+    return charactersEqual(character, item.value, ignoreCase);
   }
-  if (isErrorLikeValue(reason)) {
-    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
-      chargeBudget: false,
-      cause: readErrorCause(reason),
-      span
-    });
+  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;
+    }
+    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;
   }
-  return deepCopyToSandbox(reason);
+  const matched = item.kind === "digit" ? isDigit(character) : item.kind === "word" ? isWordCharacter(character) : isSpaceCharacter(character);
+  return item.negated ? !matched : matched;
 }
-function surfaceThrownValue(reason, budget, stackFrames = [], span) {
-  if (reason instanceof HostCallResumabilityError) {
-    throw reason;
+function toRegexMatch(input, start, state) {
+  return {
+    index: start,
+    text: input.slice(start, state.position),
+    captures: state.captures.map(
+      (capture) => capture === void 0 ? void 0 : input.slice(capture.start, capture.end)
+    )
+  };
+}
+function cloneState(state) {
+  return { position: state.position, captures: state.captures.slice() };
+}
+function clearCaptures(node, state) {
+  const captures = state.captures.slice();
+  clearNodeCaptures(node, captures);
+  return { position: state.position, captures };
+}
+function clearNodeCaptures(node, captures) {
+  if (node.type === "group") {
+    if (node.capturing && node.index !== void 0) {
+      captures[node.index - 1] = void 0;
+    }
+    clearNodeCaptures(node.body, captures);
+    return;
   }
-  if (isSubsetErrorValue(reason)) {
-    normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
-    return reason;
+  if (node.type === "sequence") {
+    for (const element of node.elements) {
+      clearNodeCaptures(element, captures);
+    }
+    return;
   }
-  if (reason instanceof Error) {
-    const error = createSubsetErrorValue(
-      reason.name || "Error",
-      reason.message,
-      stackFrames,
-      budget,
-      {
-        cause: reason,
-        chargeBudget: false,
-        span
-      }
-    );
-    normalizeSurfacedSubsetError(error, budget, stackFrames, span);
-    return error;
+  if (node.type === "alternation") {
+    for (const alternative of node.alternatives) {
+      clearNodeCaptures(alternative, captures);
+    }
+    return;
   }
-  if (isErrorLikeValue(reason)) {
-    const error = createSubsetErrorValue(
-      reason.name || "Error",
-      reason.message,
-      stackFrames,
-      budget,
-      {
-        cause: readErrorCause(reason),
-        chargeBudget: false,
-        span
-      }
-    );
-    normalizeSurfacedSubsetError(error, budget, stackFrames, span);
-    return error;
+  if (node.type === "quantifier") {
+    clearNodeCaptures(node.body, captures);
   }
-  return createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
-    chargeBudget: false,
-    span
-  });
 }
-function createSubsetErrorValue(name, message, stackFrames, budget, options = {}) {
-  const resumeChecks = options.chargeBudget === false ? budget.suspendChecks() : void 0;
-  try {
-    const errorName = budget.allocateString(name === "" ? "Error" : name);
-    const errorMessage = budget.allocateString(coerceErrorMessage(message));
-    const header = errorMessage === "" ? errorName : `${errorName}: ${errorMessage}`;
-    const stack = budget.allocateString([header, ...[...stackFrames].reverse()].join("\n"));
-    const error = {
-      name: errorName,
-      message: errorMessage,
-      stack
-    };
-    sandboxErrorTypes.set(error, toSandboxErrorName(errorName));
-    attachErrorSpan(error, options.span);
-    attachWrappedErrorCause(error, options.cause);
-    return error;
-  } finally {
-    resumeChecks?.();
-  }
+function charge(context) {
+  context.steps += 1;
+  allocateRegexSteps(context.steps);
 }
-function isSandboxErrorConstructorInstance(value, name) {
-  if (typeof value !== "object" || value === null) return false;
-  const errorType = sandboxErrorTypes.get(value);
-  return errorType !== void 0 && (name === "Error" || name === errorType);
+function normalizeLastIndex(lastIndex) {
+  if (!Number.isFinite(lastIndex) || lastIndex <= 0) {
+    return 0;
+  }
+  return Math.floor(lastIndex);
 }
-function toSandboxErrorName(name) {
-  return sandboxErrorNames.includes(name) ? name : "Error";
+function charactersEqual(left, right, ignoreCase) {
+  return left !== void 0 && foldCharacter(left, ignoreCase) === foldCharacter(right, ignoreCase);
 }
-function isSubsetErrorValue(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
+function foldCharacter(character, ignoreCase) {
+  if (!ignoreCase) {
+    return character;
   }
-  const prototype = Object.getPrototypeOf(value);
-  return (prototype === Object.prototype || prototype === null) && typeof value.name === "string" && typeof value.message === "string" && typeof value.stack === "string";
-}
-function normalizeSurfacedSubsetError(error, budget, stackFrames, span) {
-  const resumeChecks = budget.suspendChecks();
-  try {
-    const name = budget.allocateString(toSandboxErrorName(readErrorName(error)));
-    const message = budget.allocateString(readSurfacedErrorMessage(error, name));
-    const frames = readSandboxStackFrames(error.stack);
-    error.name = name;
-    error.message = message;
-    error.stack = budget.allocateString(
-      formatErrorStack(name, message, frames.length > 0 ? frames : [...stackFrames].reverse())
-    );
-    attachErrorSpan(error, readErrorSpan(error) ?? span);
-  } finally {
-    resumeChecks();
+  const folded = character.toUpperCase();
+  if (folded.length !== 1) {
+    return character;
+  }
+  if (character.charCodeAt(0) >= 128 && folded.charCodeAt(0) < 128) {
+    return character;
   }
+  return folded;
 }
-function readErrorName(error) {
-  return typeof error.name === "string" && error.name.length > 0 ? error.name : "Error";
+function isDigit(character) {
+  return character >= "0" && character <= "9";
 }
-function readSurfacedErrorMessage(error, name) {
-  const message = typeof error.message === "string" ? error.message : "";
-  if (message === "") {
-    return `${name} thrown`;
-  }
-  if (message === "[object Object]") {
-    return `${name} thrown with non-string message`;
-  }
-  return message;
+function isWordCharacter(character) {
+  return isDigit(character) || character >= "A" && character <= "Z" || character >= "a" && character <= "z" || character === "_";
 }
-function readSandboxStackFrames(stack) {
-  if (typeof stack !== "string") {
-    return [];
-  }
-  const [, ...frames] = stack.split("\n");
-  return frames;
+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 isErrorLikeValue(value) {
-  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.message === "string";
+function isLineTerminator(character) {
+  return character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029";
 }
-function coerceErrorMessage(message) {
-  if (message === void 0) {
-    return "";
+
+// packages/safe-js/src/interp/methods/regex.ts
+var regexMethodNames = /* @__PURE__ */ new Set(["exec", "test"]);
+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 (Array.isArray(message)) {
-    return message.map((value) => value === null || value === void 0 ? "" : String(value)).join(",");
+  if (property === "lastIndex") return target.lastIndex;
+  if (!isRegexMethodName(property)) {
+    return void 0;
   }
-  if (typeof message === "object" && message !== null) {
-    return "[object Object]";
+  return createSandboxClosure({
+    sandbox: true,
+    name: `RegExp#${property}`,
+    call: (args) => callRegexMethod(target, property, args)
+  });
+}
+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);
   }
-  return String(message);
+  text = text === "" ? "(?:)" : text;
+  return budget === void 0 ? text : budget.allocateString(text);
 }
-async function evaluateWithoutDeadlineChecks(context, evaluate) {
-  const resumeDeadlineChecks = context.budget.suspendDeadlineChecks();
-  try {
-    return await evaluate();
-  } finally {
-    resumeDeadlineChecks();
+function setRegexMember(target, property, value) {
+  if (property !== "lastIndex") {
+    throw new TypeError(`RegExp#${String(property)} is not writable.`);
   }
+  target.lastIndex = Number(value);
 }
-function isBudgetExceeded(error) {
-  return error instanceof SandboxError && error.code === "budgetExceeded";
+function callRegexMethod(target, methodName, args) {
+  const match = executeRegex(target, String(args[0]));
+  return methodName === "test" ? match !== null : toMatchArray(match, String(args[0]));
 }
-async function evaluateCatchClause(node, thrownValue, context, evaluateNode2) {
-  const scope = context.scope.child();
-  const catchContext = {
-    ...context,
-    scope
-  };
-  if (node.param !== void 0) {
-    const binding = await bindPattern(node.param, thrownValue, catchContext, evaluateNode2);
-    if (!binding.ok) {
-      return binding.result;
-    }
+function executeRegex(target, input) {
+  const pattern = getSandboxRegexPattern(target);
+  const match = matchRegex(pattern, input, target.lastIndex);
+  if (pattern.flags.global) {
+    target.lastIndex = match === null ? 0 : match.index + match.text.length;
   }
-  return evaluateBlockCompletion(node.body, catchContext, evaluateNode2);
+  return match;
 }
-async function evaluateBlockCompletion(node, context, evaluateNode2) {
-  const blockContext = {
-    ...context,
-    scope: context.scope.child()
-  };
-  predeclareBlockBindings(node, blockContext.scope);
-  let result = {
-    kind: "normal",
-    hasValue: false,
-    value: void 0
-  };
-  for (const statement of node.body) {
-    result = await evaluateNode2(statement, blockContext);
-    if (result.kind !== "normal") {
-      return result;
-    }
+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;
 }
-function predeclareBlockBindings(node, scope) {
-  const names = /* @__PURE__ */ new Set();
-  for (const statement of node.body) {
-    if (statement.type !== "VariableDeclaration" || statement.kind === "var") {
-      continue;
-    }
-    for (const name of getDeclarationBindingNames(statement)) {
-      if (names.has(name) || scope.hasOwnBinding(name)) {
-        throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
+
+// packages/safe-js/src/interp/string-coercion.ts
+var defaultStringHook = /* @__PURE__ */ Symbol("defaultStringHook");
+function sandboxString(value, budget, context, joining = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "function") throw new TypeError("Expected a sandbox value.");
+    return budget.allocateString(String(value));
+  }
+  const invocation = context?.invokeClosure !== void 0 ? context : {
+    ...context,
+    stack: context?.stack ?? [],
+    thisValue: context?.thisValue,
+    invokeClosure: async (closure, args, thisValue) => {
+      const leaveCall = budget.enterCall();
+      try {
+        const result = closure.call(args, { ...invocation, thisValue });
+        if (isSandboxPromise(result)) {
+          await result.synchronousPrefix;
+          return result;
+        }
+        return await result;
+      } finally {
+        leaveCall();
       }
-      names.add(name);
-      scope.predeclare(name, statement.kind);
     }
-  }
-}
-function getDeclarationBindingNames(node) {
-  return node.declarations.flatMap((declarator) => getPatternBindingNames(declarator.id));
-}
-function getPatternBindingNames(pattern) {
-  switch (pattern.type) {
-    case "Identifier":
-      return [pattern.name];
-    case "MemberExpression":
-      return [];
-    case "AssignmentPattern":
-      return getPatternBindingNames(pattern.left);
-    case "ArrayPattern":
-      return pattern.elements.flatMap(
-        (element) => element === null ? [] : getPatternBindingNames(element)
-      );
-    case "ObjectPattern":
-      return pattern.properties.flatMap(
-        (property) => property.type === "RestElement" ? getPatternBindingNames(property) : getPatternBindingNames(property.value)
-      );
-    case "RestElement":
-      return getPatternBindingNames(pattern.argument);
-  }
-}
-async function bindPattern(pattern, value, context, evaluateNode2) {
-  switch (pattern.type) {
-    case "Identifier":
-      context.scope.declare(pattern.name, "let", value);
-      return { ok: true };
-    case "MemberExpression":
-      throw new TypeError("Catch bindings do not support member expressions.");
-    case "AssignmentPattern":
-      return bindAssignmentPattern(pattern, value, context, evaluateNode2);
-    case "ArrayPattern":
-      return bindArrayPattern(pattern, value, context, evaluateNode2);
-    case "ObjectPattern":
-      return bindObjectPattern(pattern, value, context, evaluateNode2);
-    case "RestElement":
-      return bindPattern(pattern.argument, value, context, evaluateNode2);
-  }
+  };
+  return stringifyObject(value, budget, invocation, joining);
 }
-async function bindAssignmentPattern(pattern, value, context, evaluateNode2) {
-  let nextValue = value;
-  if (nextValue === void 0) {
-    const defaultValue = await evaluateNode2(pattern.right, context);
-    if (defaultValue.kind !== "normal") {
-      return {
-        ok: false,
-        result: defaultValue
-      };
+async function stringifyObject(value, budget, context, joining) {
+  const leaveCall = budget.enterCall();
+  try {
+    budget.visitNode();
+    for (const name of ["toString", "valueOf"]) {
+      const hook = conversionHook(value, name, budget);
+      let result;
+      if (hook === defaultStringHook) {
+        result = await defaultToString(value, budget, context, joining);
+      } else {
+        if (!isSandboxClosure(hook)) continue;
+        if (context?.invokeClosure === void 0) {
+          throw new TypeError("String hooks require a sandbox call context.");
+        }
+        result = await context.invokeClosure(hook, [], value);
+      }
+      if (result === null || typeof result !== "object") {
+        return sandboxString(result, budget, context, joining);
+      }
     }
-    nextValue = defaultValue.value;
+    throw new TypeError("Cannot convert object to primitive value");
+  } finally {
+    leaveCall();
   }
-  return bindPattern(pattern.left, nextValue, context, evaluateNode2);
 }
-async function bindArrayPattern(pattern, value, context, evaluateNode2) {
-  if (!Array.isArray(value)) {
-    throw new TypeError("Array catch bindings require an array value.");
-  }
-  for (let index = 0; index < pattern.elements.length; index += 1) {
-    const element = pattern.elements[index];
-    if (element === null) {
-      continue;
-    }
-    const elementValue = element.type === "RestElement" ? value.slice(index) : value[index];
-    const binding = await bindPattern(element, elementValue, context, evaluateNode2);
-    if (!binding.ok) {
-      return binding;
+function conversionHook(value, name, budget) {
+  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) || isSandboxDate(value) || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value) || isSandboxGenerator(value) || isGuestHostObject(value));
+  let current = value;
+  let depth = 0;
+  while (current !== null) {
+    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : current;
+    const descriptor = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, name);
+    if (descriptor !== void 0) {
+      if (!Object.hasOwn(descriptor, "value"))
+        throw new TypeError("String conversion requires sandbox data properties.");
+      return descriptor.value;
+    }
+    const parent = getSandboxPrototype(current, budget);
+    if (current === value && (implicitBuiltin || parent === null && !hasExplicitSandboxPrototype(value))) {
+      return name === "toString" ? defaultStringHook : void 0;
+    }
+    current = parent;
+    if (current !== null) {
+      budget.visitNode();
+      assertSandboxDataDepth(++depth);
     }
   }
-  return { ok: true };
+  return void 0;
 }
-async function bindObjectPattern(pattern, value, context, evaluateNode2) {
-  if (typeof value !== "object" && !Array.isArray(value) || value === null) {
-    throw new TypeError("Object catch bindings require a non-null object value.");
+async function defaultToString(value, budget, context, joining) {
+  if (isSandboxMap(value)) return "[object Map]";
+  if (isSandboxSet(value)) return "[object Set]";
+  if (isSandboxGenerator(value)) return "[object Generator]";
+  if (isSandboxRegex(value)) {
+    return budget.allocateString(
+      `/${getRegexMember(value, "source", budget)}/${getRegexMember(value, "flags", budget)}`
+    );
   }
-  const excludedKeys = /* @__PURE__ */ new Set();
-  for (const property of pattern.properties) {
-    if (property.type === "RestElement") {
-      const restValue = copyObjectRest(value, excludedKeys);
-      const binding2 = await bindPattern(property, restValue, context, evaluateNode2);
-      if (!binding2.ok) {
-        return binding2;
+  if (isSandboxDate(value)) return budget.allocateString(dateString(value));
+  if (Array.isArray(value) || isFloat32Array(value)) {
+    if (Object.hasOwn(value, "join")) {
+      const join = ownDataValue(value, "join");
+      if (!isSandboxClosure(join))
+        return isFloat32Array(value) ? "[object Float32Array]" : "[object Array]";
+      if (context?.invokeClosure === void 0) {
+        throw new TypeError("String hooks require a sandbox call context.");
       }
-      continue;
-    }
-    const key = await resolvePatternPropertyKey(property, context, evaluateNode2);
-    if (!key.ok) {
-      return key;
+      return context.invokeClosure(join, [], value);
     }
-    excludedKeys.add(String(key.value));
-    const binding = await bindPattern(
-      property.value,
-      getObjectPatternValue(value, key.value),
-      context,
-      evaluateNode2
-    );
-    if (!binding.ok) {
-      return binding;
+    if (joining.has(value)) return "";
+    joining.add(value);
+    try {
+      const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
+      let text = "";
+      for (let index = 0; index < length; index++) {
+        budget.visitNode();
+        const element = ownDataValue(value, String(index));
+        const part = element === null || element === void 0 ? "" : await sandboxString(element, budget, context, joining);
+        text = budget.allocateString(text + (index === 0 ? "" : ",") + part);
+      }
+      return text;
+    } finally {
+      joining.delete(value);
     }
   }
-  return { ok: true };
+  if (sandboxErrorTypes.has(value)) {
+    const nameValue = ownDataValue(value, "name");
+    const name = nameValue === void 0 ? "Error" : await sandboxString(nameValue, budget, context, joining);
+    const messageValue = ownDataValue(value, "message");
+    const message = messageValue === void 0 ? "" : await sandboxString(messageValue, budget, context, joining);
+    return name === "" ? message : message === "" ? name : `${name}: ${message}`;
+  }
+  return isSandboxPromise(value) ? "[object Promise]" : "[object Object]";
 }
-async function resolvePatternPropertyKey(property, context, evaluateNode2) {
-  if (!property.computed) {
-    return {
-      ok: true,
-      value: getStaticPropertyKey(property.key)
-    };
+function ownDataValue(value, name) {
+  const descriptor = Object.getOwnPropertyDescriptor(value, name);
+  if (descriptor !== void 0 && !Object.hasOwn(descriptor, "value")) {
+    throw new TypeError("String conversion requires sandbox data properties.");
   }
-  const computedKey = await evaluateNode2(property.key, context);
-  if (computedKey.kind !== "normal") {
-    return {
-      ok: false,
-      result: computedKey
-    };
+  return descriptor?.value;
+}
+
+// packages/safe-js/src/interp/property-key.ts
+async function toPropertyKey(value, budget, context) {
+  if (typeof value === "string") return value;
+  return sandboxString(value, budget, context);
+}
+
+// packages/safe-js/src/interp/exceptions.ts
+var capturedExceptionBrand = /* @__PURE__ */ Symbol("CapturedException");
+async function evaluateThrowStatement(node, context, evaluateNode2) {
+  const argument = await evaluateNode2(node.argument, context);
+  if (argument.kind !== "normal") {
+    return argument;
   }
   return {
-    ok: true,
-    value: await (context.toPropertyKey?.(computedKey.value) ?? toPropertyKey(
-      computedKey.value,
-      context.budget,
-      { stack: context.callStack, thisValue: void 0 }
-    ))
+    kind: "throw",
+    hasValue: true,
+    span: node.span,
+    stackFrames: context.callStack,
+    value: argument.value
   };
 }
-function getStaticPropertyKey(property) {
-  switch (property.type) {
-    case "Identifier":
-      return property.name;
-    case "StringLiteral":
-    case "NumericLiteral":
-      return property.value;
-    default:
-      throw new TypeError(`Unsupported catch binding property key '${property.type}'.`);
+async function evaluateTryStatement(node, context, evaluateNode2) {
+  let fatalBudgetError;
+  let tryResult;
+  try {
+    tryResult = await evaluateBlockCompletion(node.block, context, evaluateNode2);
+  } catch (error) {
+    if (!isBudgetExceeded(error) || node.finalizer === void 0) {
+      throw error;
+    }
+    fatalBudgetError = error;
+    tryResult = {
+      kind: "throw",
+      hasValue: true,
+      value: void 0
+    };
+  }
+  const tryOrCatchResult = fatalBudgetError === void 0 && tryResult.kind === "throw" && node.handler !== void 0 ? await evaluateCatchClause(node.handler, tryResult.value, context, evaluateNode2) : tryResult;
+  if (node.finalizer === void 0 || tryOrCatchResult.kind === "error") {
+    return tryOrCatchResult;
+  }
+  const evaluateFinalizer = () => fatalBudgetError?.budget === "deadline" ? evaluateWithoutDeadlineChecks(
+    context,
+    () => evaluateBlockCompletion(node.finalizer, context, evaluateNode2)
+  ) : evaluateBlockCompletion(node.finalizer, context, evaluateNode2);
+  const finalizerResult = await (fatalBudgetError === void 0 ? evaluateFinalizer() : withFatalPromiseCleanup(evaluateFinalizer));
+  if (fatalBudgetError !== void 0) {
+    throw fatalBudgetError;
+  }
+  if (finalizerResult.kind === "normal") {
+    return tryOrCatchResult;
   }
+  return finalizerResult;
 }
-function getObjectPatternValue(value, key) {
-  return value[key];
+function createCapturedException(reason, stackFrames, sandbox = false) {
+  return {
+    reason,
+    sandbox,
+    stackFrames,
+    [capturedExceptionBrand]: true
+  };
 }
-function copyObjectRest(value, excludedKeys) {
-  const rest = /* @__PURE__ */ Object.create(null);
-  for (const [key, entryValue] of Object.entries(value)) {
-    if (excludedKeys.has(key)) {
-      continue;
-    }
-    rest[key] = entryValue;
+function isCapturedException(value) {
+  return typeof value === "object" && value !== null && capturedExceptionBrand in value;
+}
+function coerceThrownValue(reason, budget, stackFrames, span, sandbox = false) {
+  if (reason instanceof HostCallResumabilityError) {
+    throw reason;
   }
-  return rest;
+  if (isSubsetErrorValue(reason)) {
+    attachErrorSpan(reason, readErrorSpan(reason) ?? span);
+    return reason;
+  }
+  if (reason instanceof Error) {
+    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
+      chargeBudget: false,
+      cause: readErrorCause(reason),
+      span
+    });
+  }
+  if (sandbox) {
+    return reason;
+  }
+  if (isErrorLikeValue(reason)) {
+    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
+      chargeBudget: false,
+      cause: readErrorCause(reason),
+      span
+    });
+  }
+  return deepCopyToSandbox(reason);
 }
-
-// packages/safe-js/src/interp/running-state.ts
-var runningObjects = /* @__PURE__ */ new WeakSet();
-var lockedCollections = /* @__PURE__ */ new WeakSet();
-var activeSnapshots = /* @__PURE__ */ new WeakSet();
-function enterRunningState(object) {
-  if (runningObjects.has(object)) {
-    throw new SandboxError("reentry");
+function surfaceThrownValue(reason, budget, stackFrames = [], span) {
+  if (reason instanceof HostCallResumabilityError) {
+    throw reason;
   }
-  runningObjects.add(object);
-  let active = true;
-  return () => {
-    if (!active) return;
-    active = false;
-    runningObjects.delete(object);
-  };
+  if (isSubsetErrorValue(reason)) {
+    normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
+    return reason;
+  }
+  if (reason instanceof Error) {
+    const error = createSubsetErrorValue(
+      reason.name || "Error",
+      reason.message,
+      stackFrames,
+      budget,
+      {
+        cause: reason,
+        chargeBudget: false,
+        span
+      }
+    );
+    normalizeSurfacedSubsetError(error, budget, stackFrames, span);
+    return error;
+  }
+  if (isErrorLikeValue(reason)) {
+    const error = createSubsetErrorValue(
+      reason.name || "Error",
+      reason.message,
+      stackFrames,
+      budget,
+      {
+        cause: readErrorCause(reason),
+        chargeBudget: false,
+        span
+      }
+    );
+    normalizeSurfacedSubsetError(error, budget, stackFrames, span);
+    return error;
+  }
+  return createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
+    chargeBudget: false,
+    span
+  });
 }
-function assertCollectionMutable(object) {
-  if (lockedCollections.has(object)) {
-    throw new SandboxError("reentry");
+function createSubsetErrorValue(name, message, stackFrames, budget, options = {}) {
+  const resumeChecks = options.chargeBudget === false ? budget.suspendChecks() : void 0;
+  try {
+    const errorName = budget.allocateString(name === "" ? "Error" : name);
+    const errorMessage = budget.allocateString(coerceErrorMessage(message));
+    const header = errorMessage === "" ? errorName : `${errorName}: ${errorMessage}`;
+    const stack = budget.allocateString([header, ...[...stackFrames].reverse()].join("\n"));
+    const error = {
+      name: errorName,
+      message: errorMessage,
+      stack
+    };
+    sandboxErrorTypes.set(error, toSandboxErrorName(errorName));
+    attachErrorSpan(error, options.span);
+    attachWrappedErrorCause(error, options.cause);
+    return error;
+  } finally {
+    resumeChecks?.();
   }
 }
-function enterSnapshotRun(snapshot) {
-  if (activeSnapshots.has(snapshot)) {
-    throw new SandboxError("reentry");
+function isSandboxErrorConstructorInstance(value, name) {
+  if (typeof value !== "object" || value === null) return false;
+  const errorType = sandboxErrorTypes.get(value);
+  return errorType !== void 0 && (name === "Error" || name === errorType);
+}
+function toSandboxErrorName(name) {
+  return sandboxErrorNames.includes(name) ? name : "Error";
+}
+function isSubsetErrorValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
   }
-  activeSnapshots.add(snapshot);
-  return () => activeSnapshots.delete(snapshot);
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === Object.prototype || prototype === null) && typeof value.name === "string" && typeof value.message === "string" && typeof value.stack === "string";
 }
-function assertSnapshotInactive(snapshot) {
-  if (activeSnapshots.has(snapshot)) {
-    throw new SandboxError("reentry");
+function normalizeSurfacedSubsetError(error, budget, stackFrames, span) {
+  const resumeChecks = budget.suspendChecks();
+  try {
+    const name = budget.allocateString(toSandboxErrorName(readErrorName(error)));
+    const message = budget.allocateString(readSurfacedErrorMessage(error, name));
+    const frames = readSandboxStackFrames(error.stack);
+    error.name = name;
+    error.message = message;
+    error.stack = budget.allocateString(
+      formatErrorStack(name, message, frames.length > 0 ? frames : [...stackFrames].reverse())
+    );
+    attachErrorSpan(error, readErrorSpan(error) ?? span);
+  } finally {
+    resumeChecks();
   }
 }
-
-// packages/safe-js/src/interp/iteration.ts
-function getSandboxIterator(value) {
-  if (isGuestHostObject(value)) return getHostObjectIterator(value);
-  if (isFloat32Array(value)) {
-    return syncIterator(Float32Array.prototype.values.call(value));
+function readErrorName(error) {
+  return typeof error.name === "string" && error.name.length > 0 ? error.name : "Error";
+}
+function readSurfacedErrorMessage(error, name) {
+  const message = typeof error.message === "string" ? error.message : "";
+  if (message === "") {
+    return `${name} thrown`;
   }
-  if (isSandboxGenerator(value)) {
-    return generatorIterator(value);
+  if (message === "[object Object]") {
+    return `${name} thrown with non-string message`;
   }
-  if (typeof value === "string") {
-    return syncIterator(value[Symbol.iterator]());
+  return message;
+}
+function readSandboxStackFrames(stack) {
+  if (typeof stack !== "string") {
+    return [];
   }
-  if (isSandboxMap(value)) {
-    return collectionIterator(value.entries);
+  const [, ...frames] = stack.split("\n");
+  return frames;
+}
+function isErrorLikeValue(value) {
+  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.message === "string";
+}
+function coerceErrorMessage(message) {
+  if (message === void 0) {
+    return "";
   }
-  if (isSandboxSet(value)) {
-    return collectionIterator(value.values);
+  if (Array.isArray(message)) {
+    return message.map((value) => value === null || value === void 0 ? "" : String(value)).join(",");
   }
-  if (typeof value !== "object" && typeof value !== "function" || value === null) {
-    return void 0;
+  if (typeof message === "object" && message !== null) {
+    return "[object Object]";
   }
-  const iteratorMethod = value[Symbol.iterator];
-  if (typeof iteratorMethod !== "function") {
-    return void 0;
+  return String(message);
+}
+async function evaluateWithoutDeadlineChecks(context, evaluate) {
+  const resumeDeadlineChecks = context.budget.suspendDeadlineChecks();
+  try {
+    return await evaluate();
+  } finally {
+    resumeDeadlineChecks();
   }
-  return syncIterator(Reflect.apply(iteratorMethod, value, []));
 }
-function collectionIterator(collection) {
-  let iterator = collection[Symbol.iterator]();
-  let exhausted = false;
-  return {
-    ...syncIterator({
+function isBudgetExceeded(error) {
+  return error instanceof SandboxError && error.code === "budgetExceeded";
+}
+async function evaluateCatchClause(node, thrownValue, context, evaluateNode2) {
+  const scope = context.scope.child();
+  const catchContext = {
+    ...context,
+    scope
+  };
+  if (node.param !== void 0) {
+    const binding = await bindPattern(node.param, thrownValue, catchContext, evaluateNode2);
+    if (!binding.ok) {
+      return binding.result;
+    }
+  }
+  return evaluateBlockCompletion(node.body, catchContext, evaluateNode2);
+}
+async function evaluateBlockCompletion(node, context, evaluateNode2) {
+  const blockContext = {
+    ...context,
+    scope: context.scope.child()
+  };
+  predeclareBlockBindings(node, blockContext.scope);
+  let result = {
+    kind: "normal",
+    hasValue: false,
+    value: void 0
+  };
+  for (const statement of node.body) {
+    result = await evaluateNode2(statement, blockContext);
+    if (result.kind !== "normal") {
+      return result;
+    }
+  }
+  return result;
+}
+function predeclareBlockBindings(node, scope) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of node.body) {
+    if (statement.type !== "VariableDeclaration" || statement.kind === "var") {
+      continue;
+    }
+    for (const name of getDeclarationBindingNames(statement)) {
+      if (names.has(name) || scope.hasOwnBinding(name)) {
+        throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
+      }
+      names.add(name);
+      scope.predeclare(name, statement.kind);
+    }
+  }
+}
+function getDeclarationBindingNames(node) {
+  return node.declarations.flatMap((declarator) => getPatternBindingNames(declarator.id));
+}
+function getPatternBindingNames(pattern) {
+  switch (pattern.type) {
+    case "Identifier":
+      return [pattern.name];
+    case "MemberExpression":
+      return [];
+    case "AssignmentPattern":
+      return getPatternBindingNames(pattern.left);
+    case "ArrayPattern":
+      return pattern.elements.flatMap(
+        (element) => element === null ? [] : getPatternBindingNames(element)
+      );
+    case "ObjectPattern":
+      return pattern.properties.flatMap(
+        (property) => property.type === "RestElement" ? getPatternBindingNames(property) : getPatternBindingNames(property.value)
+      );
+    case "RestElement":
+      return getPatternBindingNames(pattern.argument);
+  }
+}
+async function bindPattern(pattern, value, context, evaluateNode2) {
+  switch (pattern.type) {
+    case "Identifier":
+      context.scope.declare(pattern.name, "let", value);
+      return { ok: true };
+    case "MemberExpression":
+      throw new TypeError("Catch bindings do not support member expressions.");
+    case "AssignmentPattern":
+      return bindAssignmentPattern(pattern, value, context, evaluateNode2);
+    case "ArrayPattern":
+      return bindArrayPattern(pattern, value, context, evaluateNode2);
+    case "ObjectPattern":
+      return bindObjectPattern(pattern, value, context, evaluateNode2);
+    case "RestElement":
+      return bindPattern(pattern.argument, value, context, evaluateNode2);
+  }
+}
+async function bindAssignmentPattern(pattern, value, context, evaluateNode2) {
+  let nextValue = value;
+  if (nextValue === void 0) {
+    const defaultValue = await evaluateNode2(pattern.right, context);
+    if (defaultValue.kind !== "normal") {
+      return {
+        ok: false,
+        result: defaultValue
+      };
+    }
+    nextValue = defaultValue.value;
+  }
+  return bindPattern(pattern.left, nextValue, context, evaluateNode2);
+}
+async function bindArrayPattern(pattern, value, context, evaluateNode2) {
+  if (!Array.isArray(value)) {
+    throw new TypeError("Array catch bindings require an array value.");
+  }
+  for (let index = 0; index < pattern.elements.length; index += 1) {
+    const element = pattern.elements[index];
+    if (element === null) {
+      continue;
+    }
+    const elementValue = element.type === "RestElement" ? value.slice(index) : value[index];
+    const binding = await bindPattern(element, elementValue, context, evaluateNode2);
+    if (!binding.ok) {
+      return binding;
+    }
+  }
+  return { ok: true };
+}
+async function bindObjectPattern(pattern, value, context, evaluateNode2) {
+  if (typeof value !== "object" && !Array.isArray(value) || value === null) {
+    throw new TypeError("Object catch bindings require a non-null object value.");
+  }
+  const excludedKeys = /* @__PURE__ */ new Set();
+  for (const property of pattern.properties) {
+    if (property.type === "RestElement") {
+      const restValue = copyObjectRest(value, excludedKeys);
+      const binding2 = await bindPattern(property, restValue, context, evaluateNode2);
+      if (!binding2.ok) {
+        return binding2;
+      }
+      continue;
+    }
+    const key = await resolvePatternPropertyKey(property, context, evaluateNode2);
+    if (!key.ok) {
+      return key;
+    }
+    excludedKeys.add(String(key.value));
+    const binding = await bindPattern(
+      property.value,
+      getObjectPatternValue(value, key.value),
+      context,
+      evaluateNode2
+    );
+    if (!binding.ok) {
+      return binding;
+    }
+  }
+  return { ok: true };
+}
+async function resolvePatternPropertyKey(property, context, evaluateNode2) {
+  if (!property.computed) {
+    return {
+      ok: true,
+      value: getStaticPropertyKey(property.key)
+    };
+  }
+  const computedKey = await evaluateNode2(property.key, context);
+  if (computedKey.kind !== "normal") {
+    return {
+      ok: false,
+      result: computedKey
+    };
+  }
+  return {
+    ok: true,
+    value: await (context.toPropertyKey?.(computedKey.value) ?? toPropertyKey(
+      computedKey.value,
+      context.budget,
+      { stack: context.callStack, thisValue: void 0 }
+    ))
+  };
+}
+function getStaticPropertyKey(property) {
+  switch (property.type) {
+    case "Identifier":
+      return property.name;
+    case "StringLiteral":
+    case "NumericLiteral":
+      return property.value;
+    default:
+      throw new TypeError(`Unsupported catch binding property key '${property.type}'.`);
+  }
+}
+function getObjectPatternValue(value, key) {
+  return value[key];
+}
+function copyObjectRest(value, excludedKeys) {
+  const rest = /* @__PURE__ */ Object.create(null);
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (excludedKeys.has(key)) {
+      continue;
+    }
+    rest[key] = entryValue;
+  }
+  return rest;
+}
+
+// packages/safe-js/src/interp/running-state.ts
+var runningObjects = /* @__PURE__ */ new WeakSet();
+var lockedCollections = /* @__PURE__ */ new WeakSet();
+var activeSnapshots = /* @__PURE__ */ new WeakSet();
+function enterRunningState(object) {
+  if (runningObjects.has(object)) {
+    throw new SandboxError("reentry");
+  }
+  runningObjects.add(object);
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    runningObjects.delete(object);
+  };
+}
+function assertCollectionMutable(object) {
+  if (lockedCollections.has(object)) {
+    throw new SandboxError("reentry");
+  }
+}
+function enterSnapshotRun(snapshot) {
+  if (activeSnapshots.has(snapshot)) {
+    throw new SandboxError("reentry");
+  }
+  activeSnapshots.add(snapshot);
+  return () => activeSnapshots.delete(snapshot);
+}
+function assertSnapshotInactive(snapshot) {
+  if (activeSnapshots.has(snapshot)) {
+    throw new SandboxError("reentry");
+  }
+}
+
+// packages/safe-js/src/interp/iteration.ts
+function getSandboxIterator(value) {
+  if (isGuestHostObject(value)) return getHostObjectIterator(value);
+  if (isFloat32Array(value)) {
+    return syncIterator(Float32Array.prototype.values.call(value));
+  }
+  if (isSandboxGenerator(value)) {
+    return 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 (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return void 0;
+  }
+  const iteratorMethod = value[Symbol.iterator];
+  if (typeof iteratorMethod !== "function") {
+    return void 0;
+  }
+  return syncIterator(Reflect.apply(iteratorMethod, value, []));
+}
+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();
@@ -23715,565 +24018,288 @@ async function findLastInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = length - 1; index >= 0; index -= 1) {
     options.budget.visitNode();
-    const entry = index in value ? value[index] : void 0;
-    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
-      return entry;
-    }
-  }
-  return void 0;
-}
-async function findLastIndexInArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  for (let index = length - 1; index >= 0; index -= 1) {
-    options.budget.visitNode();
-    const entry = index in value ? value[index] : void 0;
-    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
-      return index;
-    }
-  }
-  return -1;
-}
-async function someInArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  for (let index = 0; index < length; index += 1) {
-    options.budget.visitNode();
-    if (!(index in value)) {
-      continue;
-    }
-    if (await callArrayCallback(callback, value[index], index, value, options, stack, thisValue)) {
-      return true;
-    }
-  }
-  return false;
-}
-async function everyInArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  for (let index = 0; index < length; index += 1) {
-    options.budget.visitNode();
-    if (!(index in value)) {
-      continue;
-    }
-    if (!await callArrayCallback(callback, value[index], index, value, options, stack, thisValue)) {
-      return false;
-    }
-  }
-  return true;
-}
-async function reduceArray(value, callback, hasInitialValue, initialValue, options, stack) {
-  const length = value.length;
-  if (hasInitialValue) {
-    return reduceFromLeft(value, callback, initialValue, 0, length, options, stack);
-  }
-  const start = findNextDefinedIndex(value, 0, 1, length, options.budget);
-  if (start < 0) {
-    throw new TypeError("Reduce of empty array with no initial value.");
-  }
-  return reduceFromLeft(value, callback, value[start], start + 1, length, options, stack);
-}
-async function reduceRightArray(value, callback, hasInitialValue, initialValue, options, stack) {
-  const length = value.length;
-  if (hasInitialValue) {
-    return reduceFromRight(value, callback, initialValue, length - 1, length, options, stack);
-  }
-  const start = findNextDefinedIndex(value, length - 1, -1, length, options.budget);
-  if (start < 0) {
-    throw new TypeError("Reduce of empty array with no initial value.");
-  }
-  return reduceFromRight(value, callback, value[start], start - 1, length, options, stack);
-}
-async function reduceFromLeft(value, callback, accumulator, startIndex, length, options, stack) {
-  let current = accumulator;
-  const retainedAccumulator = {};
-  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
-  try {
-    for (let index = startIndex; index < length; index += 1) {
-      options.budget.visitNode();
-      if (!(index in value)) {
-        continue;
-      }
-      current = await options.callClosure(callback, [current, value[index], index, value], stack);
-    }
-    return current;
-  } finally {
-    options.budget.setRetainedValues(retainedAccumulator, void 0);
-  }
-}
-async function reduceFromRight(value, callback, accumulator, startIndex, length, options, stack) {
-  let current = accumulator;
-  const retainedAccumulator = {};
-  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
-  try {
-    for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
-      options.budget.visitNode();
-      if (!(index in value)) {
-        continue;
-      }
-      current = await options.callClosure(callback, [current, value[index], index, value], stack);
-    }
-    return current;
-  } finally {
-    options.budget.setRetainedValues(retainedAccumulator, void 0);
-  }
-}
-async function forEachArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  for (let index = 0; index < length; index += 1) {
-    options.budget.visitNode();
-    if (!(index in value)) {
-      continue;
-    }
-    await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
-  }
-}
-async function flatMapArray(value, callback, options, stack, thisValue) {
-  const length = value.length;
-  const result = [];
-  options.budget.setRetainedValues(result, () => [result]);
-  try {
-    for (let index = 0; index < length; index += 1) {
-      options.budget.visitNode();
-      if (!(index in value)) {
-        continue;
-      }
-      const mapped = await callArrayCallback(
-        callback,
-        value[index],
-        index,
-        value,
-        options,
-        stack,
-        thisValue
-      );
-      if (Array.isArray(mapped)) {
-        for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
-          options.budget.visitNode();
-          if (!(mappedIndex in mapped)) {
-            continue;
-          }
-          result.push(mapped[mappedIndex]);
-          options.budget.allocateArrayLength(result.length);
-        }
-        continue;
-      }
-      result.push(mapped);
-      options.budget.allocateArrayLength(result.length);
-    }
-    return result;
-  } finally {
-    options.budget.setRetainedValues(result, void 0);
-  }
-}
-function flattenArray(value, depth, budget) {
-  const result = [];
-  appendFlattenedEntries(value, depth, result, budget);
-  return result;
-}
-function appendFlattenedEntries(value, depth, result, budget) {
-  for (let index = 0; index < value.length; index += 1) {
-    if (!(index in value)) {
-      continue;
-    }
-    const entry = value[index];
-    if (depth > 0 && Array.isArray(entry)) {
-      appendFlattenedEntries(entry, depth - 1, result, budget);
-      continue;
-    }
-    result.push(entry);
-    budget.allocateArrayLength(result.length);
-  }
-}
-async function sortArray(value, comparator, options, stack) {
-  const length = value.length;
-  const definedValues = [];
-  let undefinedCount = 0;
-  let currentEntry;
-  options.budget.setRetainedValues(definedValues, () => [definedValues, currentEntry]);
-  try {
-    for (let index = 0; index < length; index += 1) {
-      options.budget.visitNode();
-      if (!(index in value)) {
-        continue;
-      }
-      const entry = value[index];
-      if (entry === void 0) {
-        undefinedCount += 1;
-        continue;
-      }
-      definedValues.push(entry);
-    }
-    for (let index = 1; index < definedValues.length; index += 1) {
-      currentEntry = definedValues[index];
-      let cursor = index - 1;
-      while (cursor >= 0 && await compareEntries(definedValues[cursor], currentEntry, comparator, options, stack) > 0) {
-        definedValues[cursor + 1] = definedValues[cursor];
-        cursor -= 1;
-      }
-      definedValues[cursor + 1] = currentEntry;
-    }
-    currentEntry = void 0;
-    for (let index = 0; index < definedValues.length; index += 1) {
-      value[index] = definedValues[index];
-    }
-    for (let index = 0; index < undefinedCount; index += 1) {
-      value[definedValues.length + index] = void 0;
-    }
-    for (let index = definedValues.length + undefinedCount; index < length; index += 1) {
-      options.budget.visitNode();
-      delete value[index];
-    }
-  } finally {
-    options.budget.setRetainedValues(definedValues, void 0);
-  }
-}
-async function compareEntries(left, right, comparator, options, stack) {
-  options.budget.visitNode();
-  const result = Number(await options.callClosure(comparator, [left, right], stack));
-  return Number.isNaN(result) ? 0 : result;
-}
-async function callArrayCallback(callback, value, index, array, options, stack, thisValue) {
-  return options.callClosure(callback, [value, index, array], stack, thisValue);
-}
-function findNextDefinedIndex(value, startIndex, direction, length, budget) {
-  for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {
-    budget.visitNode();
-    if (index in value) {
-      return index;
-    }
-  }
-  return -1;
-}
-function budgetProducedValue(value, budget) {
-  allocateProducedValue(value, budget, /* @__PURE__ */ new WeakSet());
-  return value;
-}
-function allocateProducedValue(value, budget, seen) {
-  if (typeof value === "string") {
-    budget.allocateString(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    budget.allocateArrayLength(value.length);
-    if (seen.has(value)) {
-      return;
-    }
-    seen.add(value);
-    for (const entry of value) {
-      allocateProducedValue(entry, budget, seen);
+    const entry = index in value ? value[index] : void 0;
+    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+      return entry;
     }
-    return;
   }
-  if (isSandboxMap(value)) {
-    budget.allocateCollectionEntries(value.entries.size);
-    if (seen.has(value)) {
-      return;
-    }
-    seen.add(value);
-    for (const [key, entry] of value.entries) {
-      allocateProducedValue(key, budget, seen);
-      allocateProducedValue(entry, budget, seen);
+  return void 0;
+}
+async function findLastIndexInArray(value, callback, options, stack, thisValue) {
+  const length = value.length;
+  for (let index = length - 1; index >= 0; index -= 1) {
+    options.budget.visitNode();
+    const entry = index in value ? value[index] : void 0;
+    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+      return index;
     }
-    return;
   }
-  if (isSandboxSet(value)) {
-    budget.allocateCollectionEntries(value.values.size);
-    if (seen.has(value)) {
-      return;
+  return -1;
+}
+async function someInArray(value, callback, options, stack, thisValue) {
+  const length = value.length;
+  for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
+    if (!(index in value)) {
+      continue;
     }
-    seen.add(value);
-    for (const entry of value.values) {
-      allocateProducedValue(entry, budget, seen);
+    if (await callArrayCallback(callback, value[index], index, value, options, stack, thisValue)) {
+      return true;
     }
-    return;
-  }
-  if (typeof value !== "object" || value === null || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value)) {
-    return;
-  }
-  if (seen.has(value)) {
-    return;
-  }
-  seen.add(value);
-  for (const entry of Object.values(value)) {
-    allocateProducedValue(entry, budget, seen);
   }
+  return false;
 }
-function toIntegerOrInfinity(value) {
-  const number = Number(value);
-  if (Number.isNaN(number) || Object.is(number, 0) || Object.is(number, -0)) {
-    return 0;
-  }
-  if (!Number.isFinite(number)) {
-    return number;
+async function everyInArray(value, callback, options, stack, thisValue) {
+  const length = value.length;
+  for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
+    if (!(index in value)) {
+      continue;
+    }
+    if (!await callArrayCallback(callback, value[index], index, value, options, stack, thisValue)) {
+      return false;
+    }
   }
-  return Math.trunc(number);
+  return true;
 }
-
-// packages/safe-js/src/interp/methods/function.ts
-var functionMethodNames = /* @__PURE__ */ new Set(["apply", "bind", "call"]);
-function getFunctionMember(target, property, options) {
-  if (isGuestClosure(target)) {
-    const value = getGuestFunctionProperty(target, String(property));
-    if (value !== void 0 || Object.hasOwn(target.properties ?? {}, String(property))) return value;
-    if (!isFunctionMethodName(property)) return void 0;
-  }
-  const properties = target.properties;
-  if (properties !== void 0 && Object.hasOwn(properties, String(property))) {
-    return properties[String(property)];
-  }
-  if (property === "length") {
-    return target.length;
+async function reduceArray(value, callback, hasInitialValue, initialValue, options, stack) {
+  const length = value.length;
+  if (hasInitialValue) {
+    return reduceFromLeft(value, callback, initialValue, 0, length, options, stack);
   }
-  if (!isFunctionMethodName(property)) {
-    return void 0;
+  const start = findNextDefinedIndex(value, 0, 1, length, options.budget);
+  if (start < 0) {
+    throw new TypeError("Reduce of empty array with no initial value.");
   }
-  return createSandboxClosure({
-    sandbox: true,
-    name: `Function#${property}`,
-    call: (args, context) => callFunctionMethod(target, property, args, options, context?.stack ?? [])
-  });
-}
-function isFunctionMethodName(property) {
-  return typeof property === "string" && functionMethodNames.has(property);
+  return reduceFromLeft(value, callback, value[start], start + 1, length, options, stack);
 }
-function callFunctionMethod(target, methodName, args, options, stack) {
-  const thisValue = args[0];
-  if (methodName === "bind") {
-    const boundArgs = args.slice(1);
-    return createSandboxClosure({
-      guest: true,
-      sandbox: true,
-      name: `bound ${target.name ?? ""}`,
-      length: target.length === void 0 ? void 0 : Math.max(0, target.length - boundArgs.length),
-      boundTarget: target,
-      retainedValues: () => [target, thisValue, ...boundArgs],
-      call: (callArgs, context) => options.callClosure(target, [...boundArgs, ...callArgs], context?.stack ?? [], thisValue),
-      ...target.construct === void 0 ? {} : {
-        construct: (callArgs, context) => options.callClosure(
-          target,
-          [...boundArgs, ...callArgs],
-          context?.stack ?? [],
-          void 0,
-          true
-        )
-      }
-    });
-  }
-  if (methodName === "call") {
-    return options.callClosure(target, args.slice(1), stack, thisValue);
-  }
-  const applyArgs = args[1];
-  if (applyArgs === null || applyArgs === void 0) {
-    return options.callClosure(target, [], stack, thisValue);
+async function reduceRightArray(value, callback, hasInitialValue, initialValue, options, stack) {
+  const length = value.length;
+  if (hasInitialValue) {
+    return reduceFromRight(value, callback, initialValue, length - 1, length, options, stack);
   }
-  if (!Array.isArray(applyArgs)) {
-    throw new TypeError("Function#apply requires an array or nullish arguments value.");
+  const start = findNextDefinedIndex(value, length - 1, -1, length, options.budget);
+  if (start < 0) {
+    throw new TypeError("Reduce of empty array with no initial value.");
   }
-  return options.callClosure(target, applyArgs, stack, thisValue);
+  return reduceFromRight(value, callback, value[start], start - 1, length, options, stack);
 }
-
-// packages/safe-js/src/interp/methods/collection-callback.ts
-var activeCallbacks = /* @__PURE__ */ new WeakMap();
-function enterKeyedCollectionCallback(target, keys, budget) {
-  let state = activeCallbacks.get(target);
-  if (state === void 0) {
-    state = { cursors: /* @__PURE__ */ new Set(), leaveRunning: enterRunningState(target) };
-    activeCallbacks.set(target, state);
-  }
-  const cursor = { budget, pending: /* @__PURE__ */ new Set() };
-  state.cursors.add(cursor);
-  const leave = () => {
-    if (!state.cursors.delete(cursor)) return;
-    cursor.pending.clear();
-    budget.setRetainedDataUsage(cursor, 0);
-    budget.setRetainedValues(cursor, void 0);
-    if (state.cursors.size === 0) {
-      activeCallbacks.delete(target);
-      state.leaveRunning();
-    }
-  };
+async function reduceFromLeft(value, callback, accumulator, startIndex, length, options, stack) {
+  let current = accumulator;
+  const retainedAccumulator = {};
+  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
   try {
-    budget.setRetainedDataUsage(cursor, 1);
-    budget.setRetainedValues(cursor, () => cursor.pending);
-    for (const key of keys) updatePendingKeys(cursor, "add", key);
-  } catch (error) {
-    leave();
-    throw error;
-  }
-  return {
-    next: () => {
-      budget.visitNode();
-      for (const key of cursor.pending) {
-        cursor.pending.delete(key);
-        budget.setRetainedDataUsage(cursor, 1 + cursor.pending.size);
-        return { done: false, value: key };
+    for (let index = startIndex; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
       }
-      return { done: true, value: void 0 };
-    },
-    leave
-  };
-}
-function updateKeyedCollectionCallbacks(target, mutation, key) {
-  const state = activeCallbacks.get(target);
-  if (state === void 0) return;
-  for (const cursor of state.cursors) updatePendingKeys(cursor, mutation, key);
-}
-function updatePendingKeys(cursor, mutation, key) {
-  const { budget, pending } = cursor;
-  budget.visitNode();
-  if (mutation === "add") {
-    const nextSize = pending.has(key) ? pending.size : pending.size + 1;
-    budget.allocateCollectionEntries(nextSize);
-    budget.setRetainedDataUsage(cursor, 1 + nextSize);
-    pending.add(key);
-  } else {
-    if (mutation === "delete") pending.delete(key);
-    else pending.clear();
-    budget.setRetainedDataUsage(cursor, 1 + pending.size);
-  }
-}
-
-// packages/safe-js/src/interp/methods/map.ts
-var mapMethodNames = /* @__PURE__ */ new Set([
-  "get",
-  "set",
-  "has",
-  "delete",
-  "clear",
-  "forEach",
-  "keys",
-  "values",
-  "entries"
-]);
-function isMapMethodName(value) {
-  return typeof value === "string" && mapMethodNames.has(value);
-}
-function getMapMember(target, property, options) {
-  if (property === "size") {
-    return target.entries.size;
-  }
-  if (!isMapMethodName(property)) {
-    return void 0;
+      current = await options.callClosure(callback, [current, value[index], index, value], stack);
+    }
+    return current;
+  } finally {
+    options.budget.setRetainedValues(retainedAccumulator, void 0);
   }
-  return createSandboxClosure({
-    sandbox: true,
-    call: (args, context) => callMapMethod(target, property, args, options, context?.stack ?? []),
-    name: property
-  });
-}
-async function callMapMethod(target, methodName, args, options, stack = []) {
-  switch (methodName) {
-    case "get":
-      return target.entries.get(args[0]);
-    case "set": {
-      assertCollectionMutable(target);
-      const exists = target.entries.has(args[0]);
-      const nextSize = exists ? target.entries.size : target.entries.size + 1;
-      options.budget.allocateCollectionEntries(nextSize);
-      if (!exists) updateKeyedCollectionCallbacks(target, "add", args[0]);
-      target.entries.set(args[0], args[1]);
-      return target;
+}
+async function reduceFromRight(value, callback, accumulator, startIndex, length, options, stack) {
+  let current = accumulator;
+  const retainedAccumulator = {};
+  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+  try {
+    for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      current = await options.callClosure(callback, [current, value[index], index, value], stack);
     }
-    case "has":
-      return target.entries.has(args[0]);
-    case "delete": {
-      assertCollectionMutable(target);
-      const deleted = target.entries.delete(args[0]);
-      if (deleted) updateKeyedCollectionCallbacks(target, "delete", args[0]);
-      return deleted;
+    return current;
+  } finally {
+    options.budget.setRetainedValues(retainedAccumulator, void 0);
+  }
+}
+async function forEachArray(value, callback, options, stack, thisValue) {
+  const length = value.length;
+  for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
+    if (!(index in value)) {
+      continue;
     }
-    case "clear":
-      assertCollectionMutable(target);
-      target.entries.clear();
-      updateKeyedCollectionCallbacks(target, "clear");
-      return void 0;
-    case "forEach": {
-      const callback = args[0];
-      if (!isSandboxClosure(callback)) {
-        throw new TypeError("Map.prototype.forEach requires a callback function.");
+    await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
+  }
+}
+async function flatMapArray(value, callback, options, stack, thisValue) {
+  const length = value.length;
+  const result = [];
+  options.budget.setRetainedValues(result, () => [result]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
       }
-      const cursor = enterKeyedCollectionCallback(target, target.entries.keys(), options.budget);
-      try {
-        for (let entry = cursor.next(); !entry.done; entry = cursor.next()) {
-          const key = entry.value;
-          const value = target.entries.get(key);
-          await options.callClosure(callback, [value, key, target], stack, args[1]);
+      const mapped = await callArrayCallback(
+        callback,
+        value[index],
+        index,
+        value,
+        options,
+        stack,
+        thisValue
+      );
+      if (Array.isArray(mapped)) {
+        for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
+          options.budget.visitNode();
+          if (!(mappedIndex in mapped)) {
+            continue;
+          }
+          result.push(mapped[mappedIndex]);
+          options.budget.allocateArrayLength(result.length);
         }
-      } finally {
-        cursor.leave();
+        continue;
       }
-      return void 0;
+      result.push(mapped);
+      options.budget.allocateArrayLength(result.length);
     }
-    case "keys":
-      return allocateProducedSandboxValue([...target.entries.keys()], options.budget);
-    case "values":
-      return allocateProducedSandboxValue([...target.entries.values()], options.budget);
-    case "entries":
-      return allocateProducedSandboxValue(
-        [...target.entries].map(([key, value]) => [key, value]),
-        options.budget
-      );
+    return result;
+  } finally {
+    options.budget.setRetainedValues(result, void 0);
   }
 }
-
-// packages/safe-js/src/interp/methods/number.ts
-var numberMethodNames = /* @__PURE__ */ new Set([
-  "toExponential",
-  "toFixed",
-  "toPrecision",
-  "toString"
-]);
-function getNumberMember(value, property, budget) {
-  if (!isNumberMethodName(property)) {
-    return void 0;
+function flattenArray(value, depth, budget) {
+  const result = [];
+  appendFlattenedEntries(value, depth, result, budget);
+  return result;
+}
+function appendFlattenedEntries(value, depth, result, budget) {
+  for (let index = 0; index < value.length; index += 1) {
+    if (!(index in value)) {
+      continue;
+    }
+    const entry = value[index];
+    if (depth > 0 && Array.isArray(entry)) {
+      appendFlattenedEntries(entry, depth - 1, result, budget);
+      continue;
+    }
+    result.push(entry);
+    budget.allocateArrayLength(result.length);
   }
-  return createSandboxClosure({
-    sandbox: true,
-    name: `Number#${property}`,
-    call: (args) => callNumberMethod(value, property, args, budget)
-  });
 }
-function isNumberMethodName(property) {
-  return typeof property === "string" && numberMethodNames.has(property);
+async function sortArray(value, comparator, options, stack) {
+  const length = value.length;
+  const definedValues = [];
+  let undefinedCount = 0;
+  let currentEntry;
+  options.budget.setRetainedValues(definedValues, () => [definedValues, currentEntry]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      const entry = value[index];
+      if (entry === void 0) {
+        undefinedCount += 1;
+        continue;
+      }
+      definedValues.push(entry);
+    }
+    for (let index = 1; index < definedValues.length; index += 1) {
+      currentEntry = definedValues[index];
+      let cursor = index - 1;
+      while (cursor >= 0 && await compareEntries(definedValues[cursor], currentEntry, comparator, options, stack) > 0) {
+        definedValues[cursor + 1] = definedValues[cursor];
+        cursor -= 1;
+      }
+      definedValues[cursor + 1] = currentEntry;
+    }
+    currentEntry = void 0;
+    for (let index = 0; index < definedValues.length; index += 1) {
+      value[index] = definedValues[index];
+    }
+    for (let index = 0; index < undefinedCount; index += 1) {
+      value[definedValues.length + index] = void 0;
+    }
+    for (let index = definedValues.length + undefinedCount; index < length; index += 1) {
+      options.budget.visitNode();
+      delete value[index];
+    }
+  } finally {
+    options.budget.setRetainedValues(definedValues, void 0);
+  }
 }
-function callNumberMethod(value, methodName, args, budget) {
-  return budget.allocateString(callNativeNumberMethod(value, methodName, args));
+async function compareEntries(left, right, comparator, options, stack) {
+  options.budget.visitNode();
+  const result = Number(await options.callClosure(comparator, [left, right], stack));
+  return Number.isNaN(result) ? 0 : result;
 }
-function callNativeNumberMethod(value, methodName, args) {
-  switch (methodName) {
-    case "toString":
-      return value.toString(asValidatedRadix(args[0]));
-    case "toExponential":
-      return args[0] === void 0 ? value.toExponential() : value.toExponential(asValidatedFractionDigits(args[0], methodName));
-    case "toFixed":
-      return value.toFixed(asValidatedFractionDigits(args[0], methodName));
-    case "toPrecision":
-      return args[0] === void 0 ? value.toPrecision() : value.toPrecision(asValidatedPrecision(args[0]));
+async function callArrayCallback(callback, value, index, array, options, stack, thisValue) {
+  return options.callClosure(callback, [value, index, array], stack, thisValue);
+}
+function findNextDefinedIndex(value, startIndex, direction, length, budget) {
+  for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {
+    budget.visitNode();
+    if (index in value) {
+      return index;
+    }
   }
+  return -1;
 }
-function asValidatedRadix(value) {
-  if (value === void 0) {
-    return void 0;
+function budgetProducedValue(value, budget) {
+  allocateProducedValue(value, budget, /* @__PURE__ */ new WeakSet());
+  return value;
+}
+function allocateProducedValue(value, budget, seen) {
+  if (typeof value === "string") {
+    budget.allocateString(value);
+    return;
   }
-  const radix = toIntegerOrInfinity2(value);
-  if (radix < 2 || radix > 36) {
-    throw new RangeError("Number#toString radix must be between 2 and 36.");
+  if (Array.isArray(value)) {
+    budget.allocateArrayLength(value.length);
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    for (const entry of value) {
+      allocateProducedValue(entry, budget, seen);
+    }
+    return;
   }
-  return radix;
-}
-function asValidatedFractionDigits(value, methodName) {
-  const digits = toIntegerOrInfinity2(value);
-  if (digits < 0 || digits > 100) {
-    throw new RangeError(`Number#${methodName} digits must be between 0 and 100.`);
+  if (isSandboxMap(value)) {
+    budget.allocateCollectionEntries(value.entries.size);
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    for (const [key, entry] of value.entries) {
+      allocateProducedValue(key, budget, seen);
+      allocateProducedValue(entry, budget, seen);
+    }
+    return;
   }
-  return digits;
-}
-function asValidatedPrecision(value) {
-  const precision = toIntegerOrInfinity2(value);
-  if (precision < 1 || precision > 100) {
-    throw new RangeError("Number#toPrecision precision must be between 1 and 100.");
+  if (isSandboxSet(value)) {
+    budget.allocateCollectionEntries(value.values.size);
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    for (const entry of value.values) {
+      allocateProducedValue(entry, budget, seen);
+    }
+    return;
+  }
+  if (typeof value !== "object" || value === null || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value)) {
+    return;
+  }
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+  for (const entry of Object.values(value)) {
+    allocateProducedValue(entry, budget, seen);
   }
-  return precision;
 }
-function toIntegerOrInfinity2(value) {
+function toIntegerOrInfinity(value) {
   const number = Number(value);
   if (Number.isNaN(number) || Object.is(number, 0) || Object.is(number, -0)) {
     return 0;
@@ -24284,300 +24310,302 @@ function toIntegerOrInfinity2(value) {
   return Math.trunc(number);
 }
 
-// packages/safe-js/src/interp/methods/generator.ts
-var generatorMethodNames = /* @__PURE__ */ new Set(["next", "return", "throw"]);
-function getGeneratorMember(target, property, budget) {
-  if (typeof property !== "string" || !generatorMethodNames.has(property)) {
+// packages/safe-js/src/interp/methods/function.ts
+var functionMethodNames = /* @__PURE__ */ new Set(["apply", "bind", "call"]);
+function getFunctionMember(target, property, options) {
+  if (isGuestClosure(target)) {
+    const value = getGuestFunctionProperty(target, String(property));
+    if (value !== void 0 || Object.hasOwn(target.properties ?? {}, String(property))) return value;
+    if (!isFunctionMethodName(property)) return void 0;
+  }
+  const properties = target.properties;
+  if (properties !== void 0 && Object.hasOwn(properties, String(property))) {
+    return properties[String(property)];
+  }
+  if (property === "length") {
+    return target.length;
+  }
+  if (!isFunctionMethodName(property)) {
     return void 0;
   }
   return createSandboxClosure({
     sandbox: true,
-    name: property,
-    call: async ([value]) => {
-      const iterator = getSandboxIterator(target);
-      const result = await iterator[property](value);
-      return allocateProducedSandboxValue(
-        { value: result.value, done: result.done === true },
-        budget
-      );
-    }
+    name: `Function#${property}`,
+    call: (args, context) => callFunctionMethod(target, property, args, options, context?.stack ?? [])
   });
 }
-
-// packages/safe-js/src/interp/regex/engine.ts
-function matchRegex(pattern, input, lastIndex = 0) {
-  const startIndex = pattern.flags.global ? normalizeLastIndex(lastIndex) : 0;
-  return matchRegexFrom(pattern, input, startIndex);
-}
-function matchRegexFrom(pattern, input, startIndex) {
-  if (startIndex > input.length) {
-    return null;
-  }
-  for (let attempt = startIndex; attempt <= input.length; attempt += 1) {
-    const context = { input, flags: pattern.flags, steps: 0 };
-    charge(context);
-    const initialState = {
-      position: attempt,
-      captures: new Array(pattern.captureCount)
-    };
-    const result = matchNode(pattern.body, initialState, context).next();
-    if (!result.done) {
-      return toRegexMatch(input, attempt, result.value);
-    }
-  }
-  return null;
+function isFunctionMethodName(property) {
+  return typeof property === "string" && functionMethodNames.has(property);
 }
-function* matchNode(node, state, context) {
-  charge(context);
-  switch (node.type) {
-    case "empty":
-      yield state;
-      return;
-    case "literal":
-      if (charactersEqual(context.input[state.position], node.value, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + 1 };
-      }
-      return;
-    case "dot":
-      if (state.position < context.input.length && (context.flags.dotAll || !isLineTerminator(context.input[state.position]))) {
-        yield { ...state, position: state.position + 1 };
-      }
-      return;
-    case "anchor":
-      if (matchesAnchor(node.kind, state.position, context)) {
-        yield state;
-      }
-      return;
-    case "wordBoundary": {
-      const previousWord = state.position > 0 && isWordCharacter(context.input[state.position - 1]);
-      const nextWord = state.position < context.input.length && isWordCharacter(context.input[state.position]);
-      if (previousWord !== nextWord !== node.negated) {
-        yield state;
-      }
-      return;
-    }
-    case "characterClass": {
-      const 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 };
+function callFunctionMethod(target, methodName, args, options, stack) {
+  const thisValue = args[0];
+  if (methodName === "bind") {
+    const boundArgs = args.slice(1);
+    return createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: `bound ${target.name ?? ""}`,
+      length: target.length === void 0 ? void 0 : Math.max(0, target.length - boundArgs.length),
+      boundTarget: target,
+      retainedValues: () => [target, thisValue, ...boundArgs],
+      call: (callArgs, context) => options.callClosure(target, [...boundArgs, ...callArgs], context?.stack ?? [], thisValue),
+      ...target.construct === void 0 ? {} : {
+        construct: (callArgs, context) => options.callClosure(
+          target,
+          [...boundArgs, ...callArgs],
+          context?.stack ?? [],
+          void 0,
+          true
+        )
       }
-      return;
-    case "quantifier":
-      yield* matchQuantifier(node, state, context, 0);
+    });
   }
-}
-function* matchSequence(elements, index, state, context) {
-  charge(context);
-  if (index === elements.length) {
-    yield state;
-    return;
+  if (methodName === "call") {
+    return options.callClosure(target, args.slice(1), stack, thisValue);
   }
-  for (const result of matchNode(elements[index], state, context)) {
-    yield* matchSequence(elements, index + 1, result, context);
+  const applyArgs = args[1];
+  if (applyArgs === null || applyArgs === void 0) {
+    return options.callClosure(target, [], stack, thisValue);
+  }
+  if (!Array.isArray(applyArgs)) {
+    throw new TypeError("Function#apply requires an array or nullish arguments value.");
   }
+  return options.callClosure(target, applyArgs, stack, thisValue);
 }
-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;
+
+// packages/safe-js/src/interp/methods/collection-callback.ts
+var activeCallbacks = /* @__PURE__ */ new WeakMap();
+function enterKeyedCollectionCallback(target, keys, budget) {
+  let state = activeCallbacks.get(target);
+  if (state === void 0) {
+    state = { cursors: /* @__PURE__ */ new Set(), leaveRunning: enterRunningState(target) };
+    activeCallbacks.set(target, state);
   }
-  if (canRepeat) {
-    for (const result of matchNode(node.body, clearCaptures(node.body, state), context)) {
-      if (result.position === state.position) {
-        if (count >= node.min) {
-          continue;
-        }
-        if (count + 1 >= node.min) {
-          yield result;
-        } else {
-          yield* matchQuantifier(node, result, context, count + 1);
-        }
-        continue;
-      }
-      yield* matchQuantifier(node, result, context, count + 1);
+  const cursor = { budget, pending: /* @__PURE__ */ new Set() };
+  state.cursors.add(cursor);
+  const leave = () => {
+    if (!state.cursors.delete(cursor)) return;
+    cursor.pending.clear();
+    budget.setRetainedDataUsage(cursor, 0);
+    budget.setRetainedValues(cursor, void 0);
+    if (state.cursors.size === 0) {
+      activeCallbacks.delete(target);
+      state.leaveRunning();
     }
+  };
+  try {
+    budget.setRetainedDataUsage(cursor, 1);
+    budget.setRetainedValues(cursor, () => cursor.pending);
+    for (const key of keys) updatePendingKeys(cursor, "add", key);
+  } catch (error) {
+    leave();
+    throw error;
   }
-  if (node.greedy && count >= node.min) {
-    yield state;
+  return {
+    next: () => {
+      budget.visitNode();
+      for (const key of cursor.pending) {
+        cursor.pending.delete(key);
+        budget.setRetainedDataUsage(cursor, 1 + cursor.pending.size);
+        return { done: false, value: key };
+      }
+      return { done: true, value: void 0 };
+    },
+    leave
+  };
+}
+function updateKeyedCollectionCallbacks(target, mutation, key) {
+  const state = activeCallbacks.get(target);
+  if (state === void 0) return;
+  for (const cursor of state.cursors) updatePendingKeys(cursor, mutation, key);
+}
+function updatePendingKeys(cursor, mutation, key) {
+  const { budget, pending } = cursor;
+  budget.visitNode();
+  if (mutation === "add") {
+    const nextSize = pending.has(key) ? pending.size : pending.size + 1;
+    budget.allocateCollectionEntries(nextSize);
+    budget.setRetainedDataUsage(cursor, 1 + nextSize);
+    pending.add(key);
+  } else {
+    if (mutation === "delete") pending.delete(key);
+    else pending.clear();
+    budget.setRetainedDataUsage(cursor, 1 + pending.size);
+  }
+}
+
+// packages/safe-js/src/interp/methods/map.ts
+var mapMethodNames = /* @__PURE__ */ new Set([
+  "get",
+  "set",
+  "has",
+  "delete",
+  "clear",
+  "forEach",
+  "keys",
+  "values",
+  "entries"
+]);
+function isMapMethodName(value) {
+  return typeof value === "string" && mapMethodNames.has(value);
+}
+function getMapMember(target, property, options) {
+  if (property === "size") {
+    return target.entries.size;
   }
-}
-function matchesAnchor(kind, position, context) {
-  if (kind === "start") {
-    return position === 0 || context.flags.multiline && position > 0 && isLineTerminator(context.input[position - 1]);
+  if (!isMapMethodName(property)) {
+    return void 0;
   }
-  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;
+  return createSandboxClosure({
+    sandbox: true,
+    call: (args, context) => callMapMethod(target, property, args, options, context?.stack ?? []),
+    name: property
+  });
 }
-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;
+async function callMapMethod(target, methodName, args, options, stack = []) {
+  switch (methodName) {
+    case "get":
+      return target.entries.get(args[0]);
+    case "set": {
+      assertCollectionMutable(target);
+      const exists = target.entries.has(args[0]);
+      const nextSize = exists ? target.entries.size : target.entries.size + 1;
+      options.budget.allocateCollectionEntries(nextSize);
+      if (!exists) updateKeyedCollectionCallbacks(target, "add", args[0]);
+      target.entries.set(args[0], args[1]);
+      return target;
     }
-    if (!ignoreCase) {
-      return false;
+    case "has":
+      return target.entries.has(args[0]);
+    case "delete": {
+      assertCollectionMutable(target);
+      const deleted = target.entries.delete(args[0]);
+      if (deleted) updateKeyedCollectionCallbacks(target, "delete", args[0]);
+      return deleted;
     }
-    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;
+    case "clear":
+      assertCollectionMutable(target);
+      target.entries.clear();
+      updateKeyedCollectionCallbacks(target, "clear");
+      return void 0;
+    case "forEach": {
+      const callback = args[0];
+      if (!isSandboxClosure(callback)) {
+        throw new TypeError("Map.prototype.forEach requires a callback function.");
+      }
+      const cursor = enterKeyedCollectionCallback(target, target.entries.keys(), options.budget);
+      try {
+        for (let entry = cursor.next(); !entry.done; entry = cursor.next()) {
+          const key = entry.value;
+          const value = target.entries.get(key);
+          await options.callClosure(callback, [value, key, target], stack, args[1]);
+        }
+      } finally {
+        cursor.leave();
+      }
+      return void 0;
+    }
+    case "keys":
+      return allocateProducedSandboxValue([...target.entries.keys()], options.budget);
+    case "values":
+      return allocateProducedSandboxValue([...target.entries.values()], options.budget);
+    case "entries":
+      return allocateProducedSandboxValue(
+        [...target.entries].map(([key, value]) => [key, value]),
+        options.budget
+      );
   }
-  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)
-    )
-  };
+
+// packages/safe-js/src/interp/methods/number.ts
+var numberMethodNames = /* @__PURE__ */ new Set([
+  "toExponential",
+  "toFixed",
+  "toPrecision",
+  "toString"
+]);
+function getNumberMember(value, property, budget) {
+  if (!isNumberMethodName(property)) {
+    return void 0;
+  }
+  return createSandboxClosure({
+    sandbox: true,
+    name: `Number#${property}`,
+    call: (args) => callNumberMethod(value, property, args, budget)
+  });
 }
-function cloneState(state) {
-  return { position: state.position, captures: state.captures.slice() };
+function isNumberMethodName(property) {
+  return typeof property === "string" && numberMethodNames.has(property);
 }
-function clearCaptures(node, state) {
-  const captures = state.captures.slice();
-  clearNodeCaptures(node, captures);
-  return { position: state.position, captures };
+function callNumberMethod(value, methodName, args, budget) {
+  return budget.allocateString(callNativeNumberMethod(value, methodName, args));
 }
-function clearNodeCaptures(node, captures) {
-  if (node.type === "group") {
-    if (node.capturing && node.index !== void 0) {
-      captures[node.index - 1] = void 0;
-    }
-    clearNodeCaptures(node.body, captures);
-    return;
-  }
-  if (node.type === "sequence") {
-    for (const element of node.elements) {
-      clearNodeCaptures(element, captures);
-    }
-    return;
+function callNativeNumberMethod(value, methodName, args) {
+  switch (methodName) {
+    case "toString":
+      return value.toString(asValidatedRadix(args[0]));
+    case "toExponential":
+      return args[0] === void 0 ? value.toExponential() : value.toExponential(asValidatedFractionDigits(args[0], methodName));
+    case "toFixed":
+      return value.toFixed(asValidatedFractionDigits(args[0], methodName));
+    case "toPrecision":
+      return args[0] === void 0 ? value.toPrecision() : value.toPrecision(asValidatedPrecision(args[0]));
   }
-  if (node.type === "alternation") {
-    for (const alternative of node.alternatives) {
-      clearNodeCaptures(alternative, captures);
-    }
-    return;
+}
+function asValidatedRadix(value) {
+  if (value === void 0) {
+    return void 0;
   }
-  if (node.type === "quantifier") {
-    clearNodeCaptures(node.body, captures);
+  const radix = toIntegerOrInfinity2(value);
+  if (radix < 2 || radix > 36) {
+    throw new RangeError("Number#toString radix must be between 2 and 36.");
   }
+  return radix;
 }
-function charge(context) {
-  context.steps += 1;
-  allocateRegexSteps(context.steps);
-}
-function normalizeLastIndex(lastIndex) {
-  if (!Number.isFinite(lastIndex) || lastIndex <= 0) {
-    return 0;
+function asValidatedFractionDigits(value, methodName) {
+  const digits = toIntegerOrInfinity2(value);
+  if (digits < 0 || digits > 100) {
+    throw new RangeError(`Number#${methodName} digits must be between 0 and 100.`);
   }
-  return Math.floor(lastIndex);
-}
-function charactersEqual(left, right, ignoreCase) {
-  return left !== void 0 && foldCharacter(left, ignoreCase) === foldCharacter(right, ignoreCase);
+  return digits;
 }
-function foldCharacter(character, ignoreCase) {
-  if (!ignoreCase) {
-    return character;
+function asValidatedPrecision(value) {
+  const precision = toIntegerOrInfinity2(value);
+  if (precision < 1 || precision > 100) {
+    throw new RangeError("Number#toPrecision precision must be between 1 and 100.");
   }
-  const folded = character.toUpperCase();
-  if (folded.length !== 1) {
-    return character;
+  return precision;
+}
+function toIntegerOrInfinity2(value) {
+  const number = Number(value);
+  if (Number.isNaN(number) || Object.is(number, 0) || Object.is(number, -0)) {
+    return 0;
   }
-  if (character.charCodeAt(0) >= 128 && folded.charCodeAt(0) < 128) {
-    return character;
+  if (!Number.isFinite(number)) {
+    return number;
   }
-  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";
+  return Math.trunc(number);
 }
 
-// packages/safe-js/src/interp/methods/regex.ts
-var regexMethodNames = /* @__PURE__ */ new Set(["exec", "test"]);
-function isRegexMethodName(property) {
-  return typeof property === "string" && regexMethodNames.has(property);
-}
-function getRegexMember(target, property) {
-  if (property === "source" || property === "flags" || property === "lastIndex") {
-    return target[property];
-  }
-  if (!isRegexMethodName(property)) {
+// packages/safe-js/src/interp/methods/generator.ts
+var generatorMethodNames = /* @__PURE__ */ new Set(["next", "return", "throw"]);
+function getGeneratorMember(target, property, budget) {
+  if (typeof property !== "string" || !generatorMethodNames.has(property)) {
     return void 0;
   }
   return createSandboxClosure({
     sandbox: true,
-    name: `RegExp#${property}`,
-    call: (args) => callRegexMethod(target, property, args)
+    name: property,
+    call: async ([value]) => {
+      const iterator = getSandboxIterator(target);
+      const result = await iterator[property](value);
+      return allocateProducedSandboxValue(
+        { value: result.value, done: result.done === true },
+        budget
+      );
+    }
   });
 }
-function setRegexMember(target, property, value) {
-  if (property !== "lastIndex") {
-    throw new TypeError(`RegExp#${String(property)} is not writable.`);
-  }
-  target.lastIndex = Number(value);
-}
-function callRegexMethod(target, methodName, args) {
-  const match = executeRegex(target, String(args[0]));
-  return methodName === "test" ? match !== null : toMatchArray(match, String(args[0]));
-}
-function executeRegex(target, input) {
-  const pattern = getSandboxRegexPattern(target);
-  const match = matchRegex(pattern, input, target.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/string.ts
 var SPLIT_STRING_MESSAGE = "String#split only supports string separator values.";
@@ -27488,7 +27516,7 @@ function getPropertyValue(target, property, context) {
   if (isSandboxGenerator(target)) return getGeneratorMember(target, property, context.budget);
   if (isSandboxClosure(target)) return getClosureMemberValue(target, property, context);
   if (isSandboxPromise(target)) return getPromiseMember(property, context.budget);
-  if (isSandboxRegex(target)) return getRegexMember(target, property);
+  if (isSandboxRegex(target)) return getRegexMember(target, property, context.budget);
   if (!isIndexableSandboxValue(target)) {
     throw new TypeError("Attempted to read a property from a non-object value.");
   }
@@ -27753,7 +27781,7 @@ async function evaluateMemberCallExpression(node, context) {
   if (isSandboxRegex(member.object) && isRegexMethodName(member.property)) {
     return evaluateResolvedCallExpression(
       node,
-      getRegexMember(member.object, member.property),
+      getRegexMember(member.object, member.property, context.budget),
       context,
       member.object
     );
@@ -32866,4 +32894,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-M4M56OCI.js.map
+//# sourceMappingURL=chunk-774EXZKX.js.map