@poe-platform/safe-js 0.1.89 → 0.1.91

package/dist/safe-js/chunks/{chunk-M4M56OCI.js → chunk-JZXAWFPL.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,179 +8160,500 @@ 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) {
+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;
+    }
+    if (!ignoreCase) {
+      return false;
+    }
+    const foldedCandidate = foldCharacter(character, true).charCodeAt(0);
+    const foldedFrom = foldCharacter(item.from, true).charCodeAt(0);
+    const foldedTo = foldCharacter(item.to, true).charCodeAt(0);
+    return foldedCandidate >= foldedFrom && foldedCandidate <= foldedTo;
+  }
+  const matched = item.kind === "digit" ? isDigit(character) : item.kind === "word" ? isWordCharacter(character) : isSpaceCharacter(character);
+  return item.negated ? !matched : matched;
+}
+function toRegexMatch(input, start, state) {
+  return {
+    index: start,
+    text: input.slice(start, state.position),
+    captures: state.captures.map(
+      (capture) => capture === void 0 ? void 0 : input.slice(capture.start, capture.end)
+    )
+  };
+}
+function cloneState(state) {
+  return { position: state.position, captures: state.captures.slice() };
+}
+function clearCaptures(node, state) {
+  const captures = state.captures.slice();
+  clearNodeCaptures(node, captures);
+  return { position: state.position, captures };
+}
+function clearNodeCaptures(node, captures) {
+  if (node.type === "group") {
+    if (node.capturing && node.index !== void 0) {
+      captures[node.index - 1] = void 0;
+    }
+    clearNodeCaptures(node.body, captures);
+    return;
+  }
+  if (node.type === "sequence") {
+    for (const element of node.elements) {
+      clearNodeCaptures(element, captures);
+    }
+    return;
+  }
+  if (node.type === "alternation") {
+    for (const alternative of node.alternatives) {
+      clearNodeCaptures(alternative, captures);
+    }
+    return;
+  }
+  if (node.type === "quantifier") {
+    clearNodeCaptures(node.body, captures);
+  }
+}
+function charge(context) {
+  context.steps += 1;
+  allocateRegexSteps(context.steps);
+}
+function normalizeLastIndex(lastIndex) {
+  if (!Number.isFinite(lastIndex) || lastIndex <= 0) {
+    return 0;
+  }
+  return Math.floor(lastIndex);
+}
+function charactersEqual(left, right, ignoreCase) {
+  return left !== void 0 && foldCharacter(left, ignoreCase) === foldCharacter(right, ignoreCase);
+}
+function foldCharacter(character, ignoreCase) {
+  if (!ignoreCase) {
+    return character;
+  }
+  const folded = character.toUpperCase();
+  if (folded.length !== 1) {
+    return character;
+  }
+  if (character.charCodeAt(0) >= 128 && folded.charCodeAt(0) < 128) {
+    return character;
+  }
+  return folded;
+}
+function isDigit(character) {
+  return character >= "0" && character <= "9";
+}
+function isWordCharacter(character) {
+  return isDigit(character) || character >= "A" && character <= "Z" || character >= "a" && character <= "z" || character === "_";
+}
+function isSpaceCharacter(character) {
+  return character === " " || character === "\f" || character === "\n" || character === "\r" || character === "	" || character === "\v" || character === "\xA0" || character === "\u1680" || character >= "\u2000" && character <= "\u200A" || character === "\u2028" || character === "\u2029" || character === "\u202F" || character === "\u205F" || character === "\u3000" || character === "\uFEFF";
+}
+function isLineTerminator(character) {
+  return character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029";
+}
+
+// packages/safe-js/src/interp/methods/regex.ts
+var regexMethodNames = /* @__PURE__ */ new Set(["exec", "test"]);
+function isRegexMethodName(property) {
+  return typeof property === "string" && regexMethodNames.has(property);
+}
+function getRegexMember(target, property, budget) {
+  if (property === "source") return escapeRegexSource(target.source, budget);
+  if (property === "flags") {
+    const flags = [..."gims"].filter((flag) => target.flags.includes(flag)).join("");
+    return budget === void 0 ? flags : budget.allocateString(flags);
+  }
+  if (property === "lastIndex") return target.lastIndex;
+  if (!isRegexMethodName(property)) {
+    return void 0;
+  }
+  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);
+  }
+  text = text === "" ? "(?:)" : text;
+  return budget === void 0 ? text : budget.allocateString(text);
+}
+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/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();
+      }
+    }
+  };
+  return stringifyObject(value, budget, invocation, joining);
+}
+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);
+      }
+    }
+    throw new TypeError("Cannot convert object to primitive value");
+  } finally {
+    leaveCall();
+  }
+}
+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 void 0;
+}
+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)}`
+    );
+  }
+  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.");
+      }
+      return context.invokeClosure(join, [], value);
+    }
+    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);
+    }
+  }
+  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.");
+  }
+  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 {
+    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;
+  }
+  return finalizerResult;
+}
+function createCapturedException(reason, stackFrames, sandbox = false) {
+  return {
+    reason,
+    sandbox,
+    stackFrames,
+    [capturedExceptionBrand]: true
+  };
+}
+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;
   }
@@ -24185,399 +24488,127 @@ async function callMapMethod(target, methodName, args, options, stack = []) {
       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
-      );
-  }
-}
-
-// 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 isNumberMethodName(property) {
-  return typeof property === "string" && numberMethodNames.has(property);
-}
-function callNumberMethod(value, methodName, args, budget) {
-  return budget.allocateString(callNativeNumberMethod(value, methodName, args));
-}
-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]));
-  }
-}
-function asValidatedRadix(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const radix = toIntegerOrInfinity2(value);
-  if (radix < 2 || radix > 36) {
-    throw new RangeError("Number#toString radix must be between 2 and 36.");
-  }
-  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.`);
-  }
-  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.");
-  }
-  return precision;
-}
-function toIntegerOrInfinity2(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;
-  }
-  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)) {
-    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
-      );
-    }
-  });
-}
-
-// packages/safe-js/src/interp/regex/engine.ts
-function matchRegex(pattern, input, lastIndex = 0) {
-  const startIndex = pattern.flags.global ? normalizeLastIndex(lastIndex) : 0;
-  return matchRegexFrom(pattern, input, startIndex);
-}
-function matchRegexFrom(pattern, input, startIndex) {
-  if (startIndex > input.length) {
-    return null;
-  }
-  for (let attempt = startIndex; attempt <= input.length; attempt += 1) {
-    const context = { input, flags: pattern.flags, steps: 0 };
-    charge(context);
-    const initialState = {
-      position: attempt,
-      captures: new Array(pattern.captureCount)
-    };
-    const result = matchNode(pattern.body, initialState, context).next();
-    if (!result.done) {
-      return toRegexMatch(input, attempt, result.value);
-    }
-  }
-  return null;
-}
-function* matchNode(node, state, context) {
-  charge(context);
-  switch (node.type) {
-    case "empty":
-      yield state;
-      return;
-    case "literal":
-      if (charactersEqual(context.input[state.position], node.value, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + 1 };
-      }
-      return;
-    case "dot":
-      if (state.position < context.input.length && (context.flags.dotAll || !isLineTerminator(context.input[state.position]))) {
-        yield { ...state, position: state.position + 1 };
-      }
-      return;
-    case "anchor":
-      if (matchesAnchor(node.kind, state.position, context)) {
-        yield state;
-      }
-      return;
-    case "wordBoundary": {
-      const previousWord = state.position > 0 && isWordCharacter(context.input[state.position - 1]);
-      const nextWord = state.position < context.input.length && isWordCharacter(context.input[state.position]);
-      if (previousWord !== nextWord !== node.negated) {
-        yield state;
-      }
-      return;
-    }
-    case "characterClass": {
-      const 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 };
+    case "forEach": {
+      const callback = args[0];
+      if (!isSandboxClosure(callback)) {
+        throw new TypeError("Map.prototype.forEach requires a callback function.");
       }
-      return;
-    case "quantifier":
-      yield* matchQuantifier(node, state, context, 0);
-  }
-}
-function* matchSequence(elements, index, state, context) {
-  charge(context);
-  if (index === elements.length) {
-    yield state;
-    return;
-  }
-  for (const result of matchNode(elements[index], state, context)) {
-    yield* matchSequence(elements, index + 1, result, context);
-  }
-}
-function* matchQuantifier(node, state, context, count) {
-  charge(context);
-  const canRepeat = node.max === void 0 || count < node.max;
-  if (!node.greedy && count >= node.min) {
-    yield state;
-  }
-  if (canRepeat) {
-    for (const result of matchNode(node.body, clearCaptures(node.body, state), context)) {
-      if (result.position === state.position) {
-        if (count >= node.min) {
-          continue;
-        }
-        if (count + 1 >= node.min) {
-          yield result;
-        } else {
-          yield* matchQuantifier(node, result, context, count + 1);
+      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]);
         }
-        continue;
+      } finally {
+        cursor.leave();
       }
-      yield* matchQuantifier(node, result, context, count + 1);
+      return void 0;
     }
-  }
-  if (node.greedy && count >= node.min) {
-    yield state;
+    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
+      );
   }
 }
-function matchesAnchor(kind, position, context) {
-  if (kind === "start") {
-    return position === 0 || context.flags.multiline && position > 0 && isLineTerminator(context.input[position - 1]);
+
+// packages/safe-js/src/interp/methods/number.ts
+var numberMethodNames = /* @__PURE__ */ new Set([
+  "toExponential",
+  "toFixed",
+  "toPrecision",
+  "toString"
+]);
+function getNumberMember(property, budget) {
+  if (!isNumberMethodName(property)) {
+    return void 0;
   }
-  return position === context.input.length || context.flags.multiline && position < context.input.length && isLineTerminator(context.input[position]);
+  return createSandboxClosure({
+    sandbox: true,
+    name: `Number#${property}`,
+    call: (args, context) => callNumberMethod(context?.thisValue, property, args, budget)
+  });
 }
-function matchesCharacterClass(character, items, negated, ignoreCase) {
-  const matched = items.some((item) => matchesCharacterClassItem(character, item, ignoreCase));
-  return negated ? !matched : matched;
+function isNumberMethodName(property) {
+  return typeof property === "string" && numberMethodNames.has(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;
-    }
-    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;
+function callNumberMethod(value, methodName, args, budget) {
+  if (typeof value !== "number") {
+    throw new TypeError(`Number#${methodName} requires a number receiver.`);
   }
-  const matched = item.kind === "digit" ? isDigit(character) : item.kind === "word" ? isWordCharacter(character) : isSpaceCharacter(character);
-  return item.negated ? !matched : matched;
-}
-function toRegexMatch(input, start, state) {
-  return {
-    index: start,
-    text: input.slice(start, state.position),
-    captures: state.captures.map(
-      (capture) => capture === void 0 ? void 0 : input.slice(capture.start, capture.end)
-    )
-  };
-}
-function cloneState(state) {
-  return { position: state.position, captures: state.captures.slice() };
-}
-function clearCaptures(node, state) {
-  const captures = state.captures.slice();
-  clearNodeCaptures(node, captures);
-  return { position: state.position, captures };
+  return 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.";
@@ -27479,7 +27510,7 @@ async function evaluateMemberExpression(node, context) {
 function getPropertyValue(target, property, context) {
   if (isGuestHostObject(target)) return getHostObjectMember(target, String(property));
   if (typeof target === "string") return getStringMember(target, property, context.budget);
-  if (typeof target === "number") return getNumberMember(target, property, context.budget);
+  if (typeof target === "number") return getNumberMember(property, context.budget);
   if (typeof target === "boolean") return void 0;
   if (isFloat32Array(target)) return getFloat32Member(target, property, context.budget);
   if (isSandboxDate(target)) return getDateMember(property, context.budget, context.compilation?.owner);
@@ -27488,7 +27519,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.");
   }
@@ -27686,7 +27717,7 @@ async function evaluateMemberCallExpression(node, context) {
       node,
       "Number",
       member.property,
-      getNumberMember(member.object, member.property, context.budget),
+      getNumberMember(member.property, context.budget),
       context
     );
   }
@@ -27753,7 +27784,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 +32897,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-M4M56OCI.js.map
+//# sourceMappingURL=chunk-JZXAWFPL.js.map