@poe-platform/safe-js 0.1.88 → 0.1.90

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

@@ -6997,6 +6997,9 @@ 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 hasExplicitSandboxPrototype(value) {
+  return prototypes.has(value);
+}
 function setSandboxPrototype(value, prototype, budget) {
   if (budget !== void 0 && intrinsicPrototypes.get(budget) === value && prototype !== null) {
     throw new TypeError("Object.prototype has an immutable null prototype.");
@@ -8157,98 +8160,532 @@ function isCounter(value) {
 // packages/safe-js/src/interp/cancel.ts
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 
-// 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;
+// 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;
   }
-  return {
-    kind: "throw",
-    hasValue: true,
-    span: node.span,
-    stackFrames: context.callStack,
-    value: argument.value
-  };
+  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;
 }
-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;
+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;
     }
-    fatalBudgetError = error;
-    tryResult = {
-      kind: "throw",
-      hasValue: true,
-      value: void 0
-    };
+    case "characterClass": {
+      const character = context.input[state.position];
+      if (character !== void 0 && matchesCharacterClass(character, node.items, node.negated, context.flags.ignoreCase)) {
+        yield { ...state, position: state.position + 1 };
+      }
+      return;
+    }
+    case "sequence":
+      yield* matchSequence(node.elements, 0, state, context);
+      return;
+    case "alternation":
+      for (const alternative of node.alternatives) {
+        yield* matchNode(alternative, cloneState(state), context);
+      }
+      return;
+    case "group":
+      for (const result of matchNode(node.body, cloneState(state), context)) {
+        if (!node.capturing || node.index === void 0) {
+          yield result;
+          continue;
+        }
+        const captures = result.captures.slice();
+        captures[node.index - 1] = { start: state.position, end: result.position };
+        yield { position: result.position, captures };
+      }
+      return;
+    case "quantifier":
+      yield* matchQuantifier(node, state, context, 0);
   }
-  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;
+}
+function* matchSequence(elements, index, state, context) {
+  charge(context);
+  if (index === elements.length) {
+    yield state;
+    return;
   }
-  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;
+  for (const result of matchNode(elements[index], state, context)) {
+    yield* matchSequence(elements, index + 1, result, context);
   }
-  if (finalizerResult.kind === "normal") {
-    return tryOrCatchResult;
+}
+function* matchQuantifier(node, state, context, count) {
+  charge(context);
+  const canRepeat = node.max === void 0 || count < node.max;
+  if (!node.greedy && count >= node.min) {
+    yield state;
+  }
+  if (canRepeat) {
+    for (const result of matchNode(node.body, clearCaptures(node.body, state), context)) {
+      if (result.position === state.position) {
+        if (count >= node.min) {
+          continue;
+        }
+        if (count + 1 >= node.min) {
+          yield result;
+        } else {
+          yield* matchQuantifier(node, result, context, count + 1);
+        }
+        continue;
+      }
+      yield* matchQuantifier(node, result, context, count + 1);
+    }
+  }
+  if (node.greedy && count >= node.min) {
+    yield state;
   }
-  return finalizerResult;
 }
-function createCapturedException(reason, stackFrames, sandbox = false) {
+function matchesAnchor(kind, position, context) {
+  if (kind === "start") {
+    return position === 0 || context.flags.multiline && position > 0 && isLineTerminator(context.input[position - 1]);
+  }
+  return position === context.input.length || context.flags.multiline && position < context.input.length && isLineTerminator(context.input[position]);
+}
+function matchesCharacterClass(character, items, negated, ignoreCase) {
+  const matched = items.some((item) => matchesCharacterClassItem(character, item, ignoreCase));
+  return negated ? !matched : matched;
+}
+function matchesCharacterClassItem(character, item, ignoreCase) {
+  if (item.type === "character") {
+    return charactersEqual(character, item.value, ignoreCase);
+  }
+  if (item.type === "range") {
+    const candidate = character.charCodeAt(0);
+    const from = item.from.charCodeAt(0);
+    const to = item.to.charCodeAt(0);
+    if (candidate >= from && candidate <= to) {
+      return true;
+    }
+    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 {
-    reason,
-    sandbox,
-    stackFrames,
-    [capturedExceptionBrand]: true
+    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 isCapturedException(value) {
-  return typeof value === "object" && value !== null && capturedExceptionBrand in value;
+function cloneState(state) {
+  return { position: state.position, captures: state.captures.slice() };
 }
-function coerceThrownValue(reason, budget, stackFrames, span, sandbox = false) {
-  if (reason instanceof HostCallResumabilityError) {
-    throw reason;
-  }
-  if (isSubsetErrorValue(reason)) {
-    attachErrorSpan(reason, readErrorSpan(reason) ?? span);
-    return reason;
+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 (reason instanceof Error) {
-    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
-      chargeBudget: false,
-      cause: readErrorCause(reason),
-      span
-    });
+  if (node.type === "sequence") {
+    for (const element of node.elements) {
+      clearNodeCaptures(element, captures);
+    }
+    return;
   }
-  if (sandbox) {
-    return reason;
+  if (node.type === "alternation") {
+    for (const alternative of node.alternatives) {
+      clearNodeCaptures(alternative, captures);
+    }
+    return;
   }
-  if (isErrorLikeValue(reason)) {
-    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
-      chargeBudget: false,
-      cause: readErrorCause(reason),
-      span
-    });
+  if (node.type === "quantifier") {
+    clearNodeCaptures(node.body, captures);
   }
-  return deepCopyToSandbox(reason);
 }
-function surfaceThrownValue(reason, budget, stackFrames = [], span) {
-  if (reason instanceof HostCallResumabilityError) {
-    throw reason;
+function charge(context) {
+  context.steps += 1;
+  allocateRegexSteps(context.steps);
+}
+function normalizeLastIndex(lastIndex) {
+  if (!Number.isFinite(lastIndex) || lastIndex <= 0) {
+    return 0;
   }
-  if (isSubsetErrorValue(reason)) {
-    normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
+  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;
+  }
+  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);
+}
+function surfaceThrownValue(reason, budget, stackFrames = [], span) {
+  if (reason instanceof HostCallResumabilityError) {
+    throw reason;
+  }
+  if (isSubsetErrorValue(reason)) {
+    normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
     return reason;
   }
   if (reason instanceof Error) {
@@ -8547,12 +8984,13 @@ async function resolvePatternPropertyKey(property, context, evaluateNode2) {
       result: computedKey
     };
   }
-  if (typeof computedKey.value !== "string" && typeof computedKey.value !== "number") {
-    throw new TypeError("Computed catch binding keys must evaluate to a string or number.");
-  }
   return {
     ok: true,
-    value: computedKey.value
+    value: await (context.toPropertyKey?.(computedKey.value) ?? toPropertyKey(
+      computedKey.value,
+      context.budget,
+      { stack: context.callStack, thisValue: void 0 }
+    ))
   };
 }
 function getStaticPropertyKey(property) {
@@ -23089,17 +23527,17 @@ async function bindMemberExpression(pattern, value, scope, context) {
   if (object.kind !== "normal") {
     return { ok: false, result: object };
   }
+  const property = pattern.computed ? await context.evaluate(pattern.property) : { kind: "normal", value: getStaticPropertyName(pattern.property) };
+  if (property.kind !== "normal") {
+    return { ok: false, result: property };
+  }
   if (object.value === null || object.value === void 0) {
     throw new TypeError("Cannot assign properties of null or undefined.");
   }
   if (!isIndexableValue(object.value)) {
     throw new TypeError("Assignment expressions require a sandbox object property.");
   }
-  const property = pattern.computed ? await evaluateProperty(pattern.property, context) : { ok: true, value: getStaticPropertyName(pattern.property) };
-  if (!property.ok) {
-    return property;
-  }
-  context.setProperty(object.value, property.value, value);
+  context.setProperty(object.value, await context.toPropertyKey(property.value), value);
   return { ok: true };
 }
 async function evaluatePatternKey(property, context) {
@@ -23110,10 +23548,7 @@ async function evaluateProperty(property, context) {
   if (result.kind !== "normal") {
     return { ok: false, result };
   }
-  if (typeof result.value !== "string" && typeof result.value !== "number") {
-    throw new TypeError("Computed property access requires a string or number key.");
-  }
-  return { ok: true, value: result.value };
+  return { ok: true, value: await context.toPropertyKey(result.value) };
 }
 function getStaticPropertyName(property) {
   if (property.type === "Identifier") {
@@ -23153,116 +23588,36 @@ function describeRuntimeValue(value) {
   if (typeof value === "object") return value.constructor?.name ?? "Object";
   return typeof value;
 }
-function copyObjectRestValue(value, excludedKeys) {
-  const rest = /* @__PURE__ */ Object.create(null);
-  for (const [key, entryValue] of ownEnumerableSandboxEntries(value)) {
-    if (!excludedKeys.has(key)) {
-      defineProperty(rest, key, entryValue);
-    }
-  }
-  return rest;
-}
-function isIndexableValue(value) {
-  return typeof value === "object" && value !== null;
-}
-function defineProperty(target, key, value) {
-  Object.defineProperty(target, key, {
-    configurable: true,
-    enumerable: true,
-    value,
-    writable: true
-  });
-}
-
-// packages/safe-js/src/interp/var-hoist.ts
-function hoistVarDeclarations(node, scope) {
-  for (const declaration of hoistedVarDeclarations([node])) {
-    for (const declarator of declaration.declarations) {
-      for (const identifier of boundIdentifiers(declarator.id)) {
-        scope.declareVar(identifier.name);
-      }
-    }
-  }
-}
-
-// packages/safe-js/src/interp/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);
-}
-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);
-      }
-    }
-    throw new TypeError("Cannot convert object to primitive value");
-  } finally {
-    leaveCall();
-  }
-}
-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.");
-      }
-      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);
+function copyObjectRestValue(value, excludedKeys) {
+  const rest = /* @__PURE__ */ Object.create(null);
+  for (const [key, entryValue] of ownEnumerableSandboxEntries(value)) {
+    if (!excludedKeys.has(key)) {
+      defineProperty(rest, key, entryValue);
     }
   }
-  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]";
+  return rest;
 }
-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 isIndexableValue(value) {
+  return typeof value === "object" && value !== null;
+}
+function defineProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
+}
+
+// packages/safe-js/src/interp/var-hoist.ts
+function hoistVarDeclarations(node, scope) {
+  for (const declaration of hoistedVarDeclarations([node])) {
+    for (const declarator of declaration.declarations) {
+      for (const identifier of boundIdentifiers(declarator.id)) {
+        scope.declareVar(identifier.name);
+      }
+    }
   }
-  return descriptor?.value;
 }
 
 // packages/safe-js/src/interp/methods/array.ts
@@ -24145,387 +24500,112 @@ async function callMapMethod(target, methodName, args, options, stack = []) {
           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 };
-      }
-      return;
-    case "quantifier":
-      yield* matchQuantifier(node, state, context, 0);
-  }
-}
-function* matchSequence(elements, index, state, context) {
-  charge(context);
-  if (index === elements.length) {
-    yield state;
-    return;
-  }
-  for (const result of matchNode(elements[index], state, context)) {
-    yield* matchSequence(elements, index + 1, result, context);
-  }
-}
-function* matchQuantifier(node, state, context, count) {
-  charge(context);
-  const canRepeat = node.max === void 0 || count < node.max;
-  if (!node.greedy && count >= node.min) {
-    yield state;
-  }
-  if (canRepeat) {
-    for (const result of matchNode(node.body, clearCaptures(node.body, state), context)) {
-      if (result.position === state.position) {
-        if (count >= node.min) {
-          continue;
-        }
-        if (count + 1 >= node.min) {
-          yield result;
-        } else {
-          yield* matchQuantifier(node, result, context, count + 1);
-        }
-        continue;
+      } finally {
+        cursor.leave();
       }
-      yield* matchQuantifier(node, result, context, count + 1);
+      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
+      );
   }
-  if (node.greedy && count >= node.min) {
-    yield state;
-  }
-}
-function matchesAnchor(kind, position, context) {
-  if (kind === "start") {
-    return position === 0 || context.flags.multiline && position > 0 && isLineTerminator(context.input[position - 1]);
-  }
-  return position === context.input.length || context.flags.multiline && position < context.input.length && isLineTerminator(context.input[position]);
-}
-function matchesCharacterClass(character, items, negated, ignoreCase) {
-  const matched = items.some((item) => matchesCharacterClassItem(character, item, ignoreCase));
-  return negated ? !matched : matched;
 }
-function matchesCharacterClassItem(character, item, ignoreCase) {
-  if (item.type === "character") {
-    return charactersEqual(character, item.value, ignoreCase);
-  }
-  if (item.type === "range") {
-    const candidate = character.charCodeAt(0);
-    const from = item.from.charCodeAt(0);
-    const to = item.to.charCodeAt(0);
-    if (candidate >= from && candidate <= to) {
-      return true;
-    }
-    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;
+
+// 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;
   }
-  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)
-    )
-  };
+  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.";
@@ -26217,7 +26297,7 @@ async function evaluateBinaryExpression(node, context) {
     if (typeof right.value !== "object" || right.value === null) {
       throw new TypeError("Right-hand side of 'in' must be an object.");
     }
-    leftValue = await toPropertyKey(leftValue, context);
+    leftValue = await toPropertyKey(leftValue, context.budget, createCoercionContext(context));
   }
   const value = applyBinaryOperator(node, leftValue, right.value, context);
   return {
@@ -26307,7 +26387,15 @@ async function evaluateMemberAssignmentExpression(node, context) {
   if (member.kind === "nullish") {
     throw new TypeError("Cannot assign properties of null or undefined.");
   }
-  const current = node.operator === "=" ? void 0 : getPropertyValue(member.object, member.property, context);
+  let property;
+  let current = void 0;
+  if (node.operator !== "=") {
+    if (member.object === null || member.object === void 0) {
+      throw new TypeError("Cannot assign properties of null or undefined.");
+    }
+    property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+    current = getPropertyValue(member.object, property, context);
+  }
   if (node.operator === "&&=" && !isTruthy(current)) {
     return {
       kind: "normal",
@@ -26334,7 +26422,11 @@ async function evaluateMemberAssignmentExpression(node, context) {
     return right;
   }
   const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
-  setSandboxProperty(member.object, member.property, value, context.budget);
+  if (member.object === null || member.object === void 0) {
+    throw new TypeError("Cannot assign properties of null or undefined.");
+  }
+  property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+  setSandboxProperty(member.object, property, value, context.budget);
   return {
     kind: "normal",
     hasValue: true,
@@ -27273,7 +27365,10 @@ async function evaluateThrowStatement2(node, context) {
   return evaluateThrowStatement(node, context, evaluateNode);
 }
 async function evaluateTryStatement2(node, context) {
-  return evaluateTryStatement(node, context, evaluateNode);
+  return evaluateTryStatement(node, {
+    ...context,
+    toPropertyKey: (value) => toPropertyKey(value, context.budget, createCoercionContext(context))
+  }, evaluateNode);
 }
 async function evaluateUnaryExpression(node, context) {
   if (node.operator === "delete") {
@@ -27318,8 +27413,8 @@ async function evaluateDeleteExpression(node, context) {
   if (member.kind === "completion") {
     return member.result;
   }
-  if (member.kind === "nullish") {
-    if (node.argument.optional) {
+  if (member.kind === "nullish" || member.object === null || member.object === void 0) {
+    if (member.kind === "nullish" && node.argument.optional) {
       return {
         kind: "normal",
         hasValue: true,
@@ -27331,7 +27426,8 @@ async function evaluateDeleteExpression(node, context) {
   if (!isIndexableSandboxValue(member.object)) {
     throw new TypeError("Unary operator 'delete' requires a sandbox object property.");
   }
-  const deleted = deleteSandboxProperty(member.object, member.property);
+  const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+  const deleted = deleteSandboxProperty(member.object, property);
   return {
     kind: "normal",
     hasValue: true,
@@ -27379,14 +27475,15 @@ async function evaluateMemberUpdateExpression(node, context) {
   if (member.kind === "completion") {
     return member.result;
   }
-  if (member.kind === "nullish") {
+  if (member.kind === "nullish" || member.object === null || member.object === void 0) {
     throw new TypeError("Cannot update properties of null or undefined.");
   }
+  const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
   const current = toNumber(
-    await toNumericPrimitive(getPropertyValue(member.object, member.property, context), context)
+    await toNumericPrimitive(getPropertyValue(member.object, property, context), context)
   );
   const next = node.operator === "++" ? current + 1 : current - 1;
-  setSandboxProperty(member.object, member.property, next, context.budget);
+  setSandboxProperty(member.object, property, next, context.budget);
   return {
     kind: "normal",
     hasValue: true,
@@ -27397,14 +27494,14 @@ async function evaluateMemberExpression(node, context) {
   const member = await evaluateMemberAccess(node, context);
   if (member.kind === "error") return member;
   if (member.kind === "completion") return member.result;
-  if (member.kind === "nullish") {
-    if (node.optional) return { kind: "normal", hasValue: true, value: void 0 };
+  if (member.kind === "nullish" || member.object === null || member.object === void 0) {
+    if (member.kind === "nullish" && node.optional) return { kind: "normal", hasValue: true, value: void 0 };
     throw new TypeError("Cannot read properties of null or undefined.");
   }
   return {
     kind: "normal",
     hasValue: true,
-    value: getPropertyValue(member.object, member.property, context)
+    value: getPropertyValue(member.object, await toPropertyKey(member.property, context.budget, createCoercionContext(context)), context)
   };
 }
 function getPropertyValue(target, property, context) {
@@ -27419,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.");
   }
@@ -27429,6 +27526,7 @@ function createPatternContext(context, scope = context.scope, evaluate = evaluat
   const evaluationContext = { ...context, scope };
   return {
     evaluate: (node) => evaluate(node, evaluationContext),
+    toPropertyKey: (value) => toPropertyKey(value, context.budget, createCoercionContext(evaluationContext)),
     getProperty: (value, key) => getPropertyValue(value, key, evaluationContext),
     setProperty: (target, key, value) => setSandboxProperty(target, key, value, context.budget)
   };
@@ -27523,21 +27621,8 @@ async function evaluateMemberAccess(node, context) {
       kind: "nullish"
     };
   }
-  const property = node.computed ? await evaluateMemberProperty(node.property, context) : { ok: true, value: getStaticPropertyName2(node.property) };
-  if (!property.ok) {
-    return property.result.kind === "error" ? {
-      kind: "error",
-      error: property.result.error
-    } : {
-      kind: "completion",
-      result: property.result
-    };
-  }
-  if (object.value === null || object.value === void 0) {
-    return {
-      kind: "nullish"
-    };
-  }
+  const property = node.computed ? await evaluateNode(node.property, context) : { kind: "normal", value: getStaticPropertyName2(node.property) };
+  if (property.kind !== "normal") return { kind: "completion", result: property };
   return {
     kind: "resolved",
     object: object.value,
@@ -27552,13 +27637,10 @@ async function evaluateMemberProperty(node, context) {
       result: property
     };
   }
-  if (typeof property.value === "string" || typeof property.value === "number") {
-    return {
-      ok: true,
-      value: property.value
-    };
-  }
-  throw new TypeError("Computed property access requires a string or number key.");
+  return {
+    ok: true,
+    value: await toPropertyKey(property.value, context.budget, createCoercionContext(context))
+  };
 }
 async function evaluateObjectPropertyKey(node, context) {
   if (!node.computed) {
@@ -27582,15 +27664,15 @@ async function evaluateMemberCallExpression(node, context) {
   if (node.callee.type !== "MemberExpression") {
     throw new TypeError("Expected member call expression.");
   }
-  const member = await evaluateMemberAccess(node.callee, context);
-  if (member.kind === "error") {
-    return member;
+  const reference = await evaluateMemberAccess(node.callee, context);
+  if (reference.kind === "error") {
+    return reference;
   }
-  if (member.kind === "completion") {
-    return member.result;
+  if (reference.kind === "completion") {
+    return reference.result;
   }
-  if (member.kind === "nullish") {
-    if (node.optional || node.callee.optional) {
+  if (reference.kind === "nullish" || reference.object === null || reference.object === void 0) {
+    if (reference.kind === "nullish") {
       return {
         kind: "normal",
         hasValue: true,
@@ -27599,6 +27681,10 @@ async function evaluateMemberCallExpression(node, context) {
     }
     throw new TypeError("Cannot read properties of null or undefined.");
   }
+  const member = {
+    ...reference,
+    property: await toPropertyKey(reference.property, context.budget, createCoercionContext(context))
+  };
   if (typeof member.object === "string" && isStringMethodName(member.property)) {
     return evaluateStringMethodCall(node, member.object, member.property, context);
   }
@@ -27695,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
     );
@@ -27930,23 +28016,13 @@ function applyBinaryOperator(node, left, right, context) {
       return hasSandboxProperty(right, left, context);
   }
 }
-async function toPropertyKey(value, context) {
-  if (isPlainSandboxObject(value) && !isSandboxDate(value) && !isFloat32Array(value) && !isSandboxGenerator(value) && !isGuestHostObject(value)) {
-    for (const name of ["toString", "valueOf"]) {
-      const method = getMemberValue(value, name, context);
-      if (!isSandboxClosure(method)) continue;
-      const primitive = await invokeSandboxClosure(method, [], context, context.callStack, void 0, value);
-      if (primitive === null || typeof primitive !== "object") {
-        return context.budget.allocateString(String(primitive));
-      }
-    }
-    throw new TypeError("Cannot convert object to primitive value.");
-  }
-  return sandboxString(value, context.budget, {
+function createCoercionContext(context) {
+  return {
     stack: context.callStack,
     thisValue: void 0,
+    compilation: context.compilation,
     invokeClosure: (closure, args, thisValue) => invokeSandboxClosure(closure, args, context, context.callStack, void 0, thisValue)
-  });
+  };
 }
 function hasSandboxProperty(value, key, context) {
   let current = value;
@@ -32818,4 +32894,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-5J6BX3HD.js.map
+//# sourceMappingURL=chunk-774EXZKX.js.map