poe-code 14.0.56 → 14.0.58

package/packages/safe-js/dist/cli.js

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-SRYQTOX4.js";
+} from "./chunks/chunk-3VTLNK4E.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-XI33TU4X.js";
+} from "./chunks/chunk-DHD453E5.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/core.js

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-XI33TU4X.js";
+} from "./chunks/chunk-DHD453E5.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safe-js/dist/index.js

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-SRYQTOX4.js";
+} from "./chunks/chunk-3VTLNK4E.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-XI33TU4X.js";
+} from "./chunks/chunk-DHD453E5.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/globals/misc.js

@@ -1,11 +1,12 @@
 import { isSandboxCollectionIterator } from "../collection-iterator.js";
 import { assertSandboxGraphDepth } from "../../graph-depth.js";
-import { allocateProducedSandboxValue, cloneSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet } from "../values.js";
+import { CompileScope } from "../regex/compile-guard.js";
+import { allocateProducedSandboxValue, cloneSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet, reconcileCompiledValues } from "../values.js";
 export function createMiscGlobals(options) {
     return {
         structuredClone: createSandboxClosure({
             sandbox: true,
-            call: ([value]) => structuredCloneSandboxValue(value, options.budget),
+            call: ([value], context) => structuredCloneSandboxValue(value, options.budget, context?.compilation),
             name: "structuredClone"
         }),
         parseInt: createSandboxClosure({
@@ -30,11 +31,23 @@ export function createMiscGlobals(options) {
         })
     };
 }
-function structuredCloneSandboxValue(value, budget) {
-    assertSandboxGraphDepth(value);
-    const clone = cloneSandboxValue(value);
-    assertStructuredCloneable(clone, new WeakSet());
-    return allocateProducedSandboxValue(clone, budget);
+function structuredCloneSandboxValue(value, budget, parent) {
+    const operation = budget.acquireCompileOwner(false, parent?.owner);
+    const compilation = parent?.owner === operation.owner ? parent : new CompileScope(operation.owner);
+    try {
+        const clone = cloneSandboxValue(value, { compilation, resetRegexLastIndex: true });
+        assertSandboxGraphDepth(clone);
+        assertStructuredCloneable(clone, new WeakSet());
+        allocateProducedSandboxValue(clone, budget);
+        if (compilation !== parent)
+            reconcileCompiledValues(budget, [clone], compilation);
+        return clone;
+    }
+    finally {
+        if (compilation !== parent)
+            compilation.dispose();
+        operation.release();
+    }
 }
 function assertStructuredCloneable(value, seen) {
     if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value)) {

package/packages/safe-js/dist/interp/interpreter.js

@@ -4,6 +4,7 @@ import { toPropertyKey } from "./property-key.js";
 import { assertPromiseExecutionAllowed } from "./promise-tracker.js";
 import { SandboxJobQueue, runAsyncPrefix, suspendJob } from "./jobs.js";
 import { withCancellationSignal } from "./cancel.js";
+import { runResources } from "./resources.js";
 import { attachErrorSpan, formatErrorStack, replaceErrorStack } from "../error/shape.js";
 import { evaluateArrowFunctionExpression, evaluateFunctionExpression, evaluateAwaitExpression, emitResumeBreakpoint, createInterpretedClosure, normalizeClosureResult } from "./async.js";
 import { HostCallResumabilityError } from "./host-call.js";
@@ -519,66 +520,61 @@ async function evaluateMemberAssignmentExpression(node, context) {
     if (node.left.type !== "MemberExpression") {
         throw new TypeError("Expected member assignment target.");
     }
-    const member = await evaluateMemberAccess(node.left, context);
-    if (member.kind === "error") {
-        return member;
-    }
-    if (member.kind === "completion") {
-        return member.result;
-    }
-    if (member.kind === "nullish") {
-        throw new TypeError("Cannot assign properties of null or undefined.");
-    }
-    let property;
-    let current = undefined;
-    if (node.operator !== "=") {
+    return evaluateMemberAccess(node.left, context, async (member) => {
+        if (member.kind === "nullish") {
+            throw new TypeError("Cannot assign properties of null or undefined.");
+        }
+        let property;
+        let current = undefined;
+        if (node.operator !== "=") {
+            if (member.object === null || member.object === undefined) {
+                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",
+                hasValue: true,
+                value: current
+            };
+        }
+        if (node.operator === "||=" && isTruthy(current)) {
+            return {
+                kind: "normal",
+                hasValue: true,
+                value: current
+            };
+        }
+        if (node.operator === "??=" && current !== null && current !== undefined) {
+            return {
+                kind: "normal",
+                hasValue: true,
+                value: current
+            };
+        }
+        const right = await evaluateNode(node.right, context);
+        if (right.kind !== "normal") {
+            return right;
+        }
+        const value = node.operator === "=" ||
+            node.operator === "&&=" ||
+            node.operator === "||=" ||
+            node.operator === "??="
+            ? right.value
+            : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
         if (member.object === null || member.object === undefined) {
             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",
-            hasValue: true,
-            value: current
-        };
-    }
-    if (node.operator === "||=" && isTruthy(current)) {
+        property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+        setSandboxProperty(member.object, property, value, context.budget);
         return {
             kind: "normal",
             hasValue: true,
-            value: current
-        };
-    }
-    if (node.operator === "??=" && current !== null && current !== undefined) {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: current
+            value
         };
-    }
-    const right = await evaluateNode(node.right, context);
-    if (right.kind !== "normal") {
-        return right;
-    }
-    const value = node.operator === "=" ||
-        node.operator === "&&=" ||
-        node.operator === "||=" ||
-        node.operator === "??="
-        ? right.value
-        : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
-    if (member.object === null || member.object === undefined) {
-        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,
-        value
-    };
+    });
 }
 async function evaluateLogicalExpression(node, context) {
     const left = await evaluateNode(node.left, context);
@@ -1572,33 +1568,28 @@ async function evaluateDeleteExpression(node, context) {
     if (node.argument.type !== "MemberExpression") {
         throw createError("UNSUPPORTED_NODE", node, "Unary operator 'delete' requires a member target.");
     }
-    const member = await evaluateMemberAccess(node.argument, context);
-    if (member.kind === "error") {
-        return member;
-    }
-    if (member.kind === "completion") {
-        return member.result;
-    }
-    if (member.kind === "nullish" || member.object === null || member.object === undefined) {
-        if (member.kind === "nullish" && node.argument.optional) {
-            return {
-                kind: "normal",
-                hasValue: true,
-                value: true
-            };
+    return evaluateMemberAccess(node.argument, context, async (member) => {
+        if (member.kind === "nullish" || member.object === null || member.object === undefined) {
+            if (member.kind === "nullish") {
+                return {
+                    kind: "normal",
+                    hasValue: true,
+                    value: true
+                };
+            }
+            throw new TypeError("Cannot delete properties of null or undefined.");
         }
-        throw new TypeError("Cannot delete properties of null or undefined.");
-    }
-    if (!isIndexableSandboxValue(member.object)) {
-        throw new TypeError("Unary operator 'delete' requires a sandbox object property.");
-    }
-    const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-    const deleted = deleteSandboxProperty(member.object, property);
-    return {
-        kind: "normal",
-        hasValue: true,
-        value: deleted
-    };
+        if (!isIndexableSandboxValue(member.object)) {
+            throw new TypeError("Unary operator 'delete' requires a sandbox object property.");
+        }
+        const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+        const deleted = deleteSandboxProperty(member.object, property);
+        return {
+            kind: "normal",
+            hasValue: true,
+            value: deleted
+        };
+    });
 }
 async function evaluateUpdateExpression(node, context) {
     if (node.argument.type === "Identifier") {
@@ -1630,42 +1621,34 @@ async function evaluateMemberUpdateExpression(node, context) {
     if (node.argument.type !== "MemberExpression") {
         throw new TypeError("Expected member update target.");
     }
-    const member = await evaluateMemberAccess(node.argument, context);
-    if (member.kind === "error") {
-        return member;
-    }
-    if (member.kind === "completion") {
-        return member.result;
-    }
-    if (member.kind === "nullish" || member.object === null || member.object === undefined) {
-        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, property, context), context));
-    const next = node.operator === "++" ? current + 1 : current - 1;
-    setSandboxProperty(member.object, property, next, context.budget);
-    return {
-        kind: "normal",
-        hasValue: true,
-        value: node.prefix ? next : current
-    };
+    return evaluateMemberAccess(node.argument, context, async (member) => {
+        if (member.kind === "nullish" || member.object === null || member.object === undefined) {
+            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, property, context), context));
+        const next = node.operator === "++" ? current + 1 : current - 1;
+        setSandboxProperty(member.object, property, next, context.budget);
+        return {
+            kind: "normal",
+            hasValue: true,
+            value: node.prefix ? next : current
+        };
+    });
 }
 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" || member.object === null || member.object === undefined) {
-        if (member.kind === "nullish" && node.optional)
-            return { kind: "normal", hasValue: true, value: undefined };
-        throw new TypeError("Cannot read properties of null or undefined.");
-    }
-    return {
-        kind: "normal",
-        hasValue: true,
-        value: getPropertyValue(member.object, await toPropertyKey(member.property, context.budget, createCoercionContext(context)), context)
-    };
+    return evaluateMemberAccess(node, context, async (member) => {
+        if (member.kind === "nullish" || member.object === null || member.object === undefined) {
+            if (member.kind === "nullish")
+                return { kind: "normal", hasValue: true, value: undefined };
+            throw new TypeError("Cannot read properties of null or undefined.");
+        }
+        return {
+            kind: "normal",
+            hasValue: true,
+            value: getPropertyValue(member.object, await toPropertyKey(member.property, context.budget, createCoercionContext(context)), context)
+        };
+    });
 }
 function getPropertyValue(target, property, context) {
     if (isGuestHostObject(target))
@@ -1778,29 +1761,32 @@ function attachFatalSandboxErrorContext(error, node, stackFrames) {
     attachErrorSpan(error, node.span);
     replaceErrorStack(error, stackFrames);
 }
-async function evaluateMemberAccess(node, context) {
+async function evaluateMemberAccess(node, context, consume) {
     const object = await evaluateNode(node.object, context);
-    if (object.kind !== "normal") {
-        return {
-            kind: "completion",
-            result: object
-        };
-    }
+    if (object.kind !== "normal")
+        return object;
     if ((object.value === null || object.value === undefined) && node.optional) {
-        return {
-            kind: "nullish"
-        };
+        return consume({ kind: "nullish" });
+    }
+    const retained = {};
+    let property;
+    context.budget.setRetainedValues(retained, () => [object.value, property]);
+    const release = () => context.budget.setRetainedValues(retained, undefined);
+    const pending = runResources.getStore()?.referenceReleases;
+    pending?.add(release);
+    try {
+        const result = node.computed
+            ? await evaluateNode(node.property, context)
+            : { kind: "normal", value: getStaticPropertyName(node.property) };
+        if (result.kind !== "normal")
+            return result;
+        property = result.value;
+        return await consume({ kind: "resolved", object: object.value, property });
+    }
+    finally {
+        release();
+        pending?.delete(release);
     }
-    const property = node.computed
-        ? await evaluateNode(node.property, context)
-        : { kind: "normal", value: getStaticPropertyName(node.property) };
-    if (property.kind !== "normal")
-        return { kind: "completion", result: property };
-    return {
-        kind: "resolved",
-        object: object.value,
-        property: property.value
-    };
 }
 async function evaluateMemberProperty(node, context) {
     const property = await evaluateNode(node, context);
@@ -1837,89 +1823,84 @@ async function evaluateMemberCallExpression(node, context) {
     if (node.callee.type !== "MemberExpression") {
         throw new TypeError("Expected member call expression.");
     }
-    const reference = await evaluateMemberAccess(node.callee, context);
-    if (reference.kind === "error") {
-        return reference;
-    }
-    if (reference.kind === "completion") {
-        return reference.result;
-    }
-    if (reference.kind === "nullish" || reference.object === null || reference.object === undefined) {
-        if (reference.kind === "nullish") {
-            return {
-                kind: "normal",
-                hasValue: true,
-                value: undefined
-            };
+    return evaluateMemberAccess(node.callee, context, async (reference) => {
+        if (reference.kind === "nullish" || reference.object === null || reference.object === undefined) {
+            if (reference.kind === "nullish") {
+                return {
+                    kind: "normal",
+                    hasValue: true,
+                    value: undefined
+                };
+            }
+            throw new TypeError("Cannot read properties of null or undefined.");
         }
-        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);
-    }
-    if (typeof member.object === "number" && isNumberMethodName(member.property)) {
-        return evaluateNumberMethodCall(node, member.object, member.property, context);
-    }
-    if (Array.isArray(member.object) &&
-        isArrayMethodName(member.property) &&
-        !Object.hasOwn(member.object, member.property)) {
-        return evaluateArrayMethodCall(node, member.object, member.property, context);
-    }
-    if (isSandboxMap(member.object) && isMapMethodName(member.property)) {
-        return evaluateMapMethodCall(node, member.object, member.property, context);
-    }
-    if (isSandboxSet(member.object) && isSetMethodName(member.property)) {
-        return evaluateSetMethodCall(node, member.object, member.property, context);
-    }
-    if (typeof member.object === "string") {
-        return evaluatePrimitiveMemberCall(node, "String", member.property, getStringMember(member.object, member.property, context.budget), context);
-    }
-    if (typeof member.object === "number") {
-        return evaluatePrimitiveMemberCall(node, "Number", member.property, getNumberMember(member.property, context.budget), context);
-    }
-    if (Array.isArray(member.object) && !Object.hasOwn(member.object, member.property)) {
-        return evaluatePrimitiveMemberCall(node, "Array", member.property, getArrayMemberValue(member.object, member.property, context), context);
-    }
-    if (isSandboxMap(member.object)) {
-        return evaluatePrimitiveMemberCall(node, "Map", member.property, getMapMember(member.object, member.property, createMapMethodOptions(context)), context);
-    }
-    if (isSandboxDate(member.object)) {
-        return evaluateResolvedCallExpression(node, getDateMember(member.property, context.budget, context.compilation?.owner), context, member.object);
-    }
-    if (isFloat32Array(member.object)) {
-        return evaluateResolvedCallExpression(node, getFloat32Member(member.object, member.property, context.budget), context, member.object);
-    }
-    if (isSandboxSet(member.object)) {
-        return evaluatePrimitiveMemberCall(node, "Set", member.property, getSetMember(member.object, member.property, createSetMethodOptions(context)), context);
-    }
-    if (isSandboxGenerator(member.object)) {
-        const memberValue = getGeneratorMember(member.object, member.property, context.budget);
-        if (memberValue === undefined) {
-            throw new TypeError(`Generator#${String(member.property)} is not a supported method.`);
+        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);
         }
-        return evaluateResolvedCallExpression(node, memberValue, context, member.object);
-    }
-    if (isSandboxClosure(member.object)) {
-        const memberValue = getClosureMemberValue(member.object, member.property, context);
-        if (memberValue === undefined) {
-            throw new TypeError(`Function#${String(member.property)} is not a supported method.`);
+        if (typeof member.object === "number" && isNumberMethodName(member.property)) {
+            return evaluateNumberMethodCall(node, member.object, member.property, context);
         }
-        return evaluateResolvedCallExpression(node, memberValue, context, member.object);
-    }
-    if (isSandboxPromise(member.object)) {
-        return evaluateResolvedCallExpression(node, getPromiseMember(member.property, context.budget), context, member.object);
-    }
-    if (isSandboxRegex(member.object) && isRegexMethodName(member.property)) {
-        return evaluateResolvedCallExpression(node, getRegexMember(member.object, member.property, context.budget), context, member.object);
-    }
-    if (!isIndexableSandboxValue(member.object)) {
-        throw new TypeError("Attempted to read a property from a non-object value.");
-    }
-    return evaluateResolvedCallExpression(node, getMemberValue(member.object, member.property, context), context, member.object);
+        if (Array.isArray(member.object) &&
+            isArrayMethodName(member.property) &&
+            !Object.hasOwn(member.object, member.property)) {
+            return evaluateArrayMethodCall(node, member.object, member.property, context);
+        }
+        if (isSandboxMap(member.object) && isMapMethodName(member.property)) {
+            return evaluateMapMethodCall(node, member.object, member.property, context);
+        }
+        if (isSandboxSet(member.object) && isSetMethodName(member.property)) {
+            return evaluateSetMethodCall(node, member.object, member.property, context);
+        }
+        if (typeof member.object === "string") {
+            return evaluatePrimitiveMemberCall(node, "String", member.property, getStringMember(member.object, member.property, context.budget), context);
+        }
+        if (typeof member.object === "number") {
+            return evaluatePrimitiveMemberCall(node, "Number", member.property, getNumberMember(member.property, context.budget), context);
+        }
+        if (Array.isArray(member.object) && !Object.hasOwn(member.object, member.property)) {
+            return evaluatePrimitiveMemberCall(node, "Array", member.property, getArrayMemberValue(member.object, member.property, context), context);
+        }
+        if (isSandboxMap(member.object)) {
+            return evaluatePrimitiveMemberCall(node, "Map", member.property, getMapMember(member.object, member.property, createMapMethodOptions(context)), context);
+        }
+        if (isSandboxDate(member.object)) {
+            return evaluateResolvedCallExpression(node, getDateMember(member.property, context.budget, context.compilation?.owner), context, member.object);
+        }
+        if (isFloat32Array(member.object)) {
+            return evaluateResolvedCallExpression(node, getFloat32Member(member.object, member.property, context.budget), context, member.object);
+        }
+        if (isSandboxSet(member.object)) {
+            return evaluatePrimitiveMemberCall(node, "Set", member.property, getSetMember(member.object, member.property, createSetMethodOptions(context)), context);
+        }
+        if (isSandboxGenerator(member.object)) {
+            const memberValue = getGeneratorMember(member.object, member.property, context.budget);
+            if (memberValue === undefined) {
+                throw new TypeError(`Generator#${String(member.property)} is not a supported method.`);
+            }
+            return evaluateResolvedCallExpression(node, memberValue, context, member.object);
+        }
+        if (isSandboxClosure(member.object)) {
+            const memberValue = getClosureMemberValue(member.object, member.property, context);
+            if (memberValue === undefined) {
+                throw new TypeError(`Function#${String(member.property)} is not a supported method.`);
+            }
+            return evaluateResolvedCallExpression(node, memberValue, context, member.object);
+        }
+        if (isSandboxPromise(member.object)) {
+            return evaluateResolvedCallExpression(node, getPromiseMember(member.property, context.budget), context, member.object);
+        }
+        if (isSandboxRegex(member.object) && isRegexMethodName(member.property)) {
+            return evaluateResolvedCallExpression(node, getRegexMember(member.object, member.property, context.budget), context, member.object);
+        }
+        if (!isIndexableSandboxValue(member.object)) {
+            throw new TypeError("Attempted to read a property from a non-object value.");
+        }
+        return evaluateResolvedCallExpression(node, getMemberValue(member.object, member.property, context), context, member.object);
+    });
 }
 function evaluatePrimitiveMemberCall(node, receiverType, property, value, context) {
     if (value === undefined) {

package/packages/safe-js/dist/interp/methods/regex.d.ts

@@ -6,5 +6,5 @@ export declare function isRegexMethodName(property: string | number): property i
 export declare function getRegexMember(target: SandboxRegex, property: string | number, budget: Budget): SandboxValue | undefined;
 export declare function setRegexMember(target: SandboxRegex, property: string | number, value: SandboxValue): void;
 export declare function callRegexMethod(target: SandboxValue, methodName: RegexMethodName, args: readonly SandboxValue[], budget: Budget, context?: SandboxCallContext): Promise<SandboxValue>;
-export declare function executeRegex(target: SandboxRegex, input: string): RegexMatch | null;
+export declare function executeRegex(target: SandboxRegex, input: string, lastIndex: number): RegexMatch | null;
 export declare function toMatchArray(match: RegexMatch | null, input: string): SandboxValue;

package/packages/safe-js/dist/interp/methods/regex.js

@@ -2,8 +2,12 @@ import { createSandboxClosure, getSandboxRegexPattern, isSandboxClosure, isSandb
 import { matchRegex } from "../regex/engine.js";
 import { invokeBuiltinClosure } from "../builtin-call.js";
 import { getSandboxDataProperty } from "../object-model.js";
-import { sandboxString } from "../string-coercion.js";
+import { sandboxNumber, sandboxString } from "../string-coercion.js";
 const regexMethodNames = new Set(["exec", "test"]);
+const regexFlagProperties = {
+    hasIndices: "d", global: "g", ignoreCase: "i", multiline: "m",
+    dotAll: "s", unicode: "u", unicodeSets: "v", sticky: "y"
+};
 export function isRegexMethodName(property) {
     return typeof property === "string" && regexMethodNames.has(property);
 }
@@ -16,6 +20,8 @@ export function getRegexMember(target, property, budget) {
     }
     if (property === "lastIndex")
         return target.lastIndex;
+    if (Object.hasOwn(regexFlagProperties, property))
+        return target.flags.includes(regexFlagProperties[property]);
     if (!isRegexMethodName(property)) {
         return undefined;
     }
@@ -64,14 +70,16 @@ export function setRegexMember(target, property, value) {
     if (property !== "lastIndex") {
         throw new TypeError(`RegExp#${String(property)} is not writable.`);
     }
-    target.lastIndex = Number(value);
+    target.lastIndex = value;
 }
 export async function callRegexMethod(target, methodName, args, budget, context) {
     if (target === null || typeof target !== "object" || (methodName === "exec" && !isSandboxRegex(target))) {
         throw new TypeError(`RegExp#${methodName} requires ${methodName === "exec" ? "a regex" : "an object"} receiver.`);
     }
     const retained = {};
-    budget.setRetainedValues(retained, () => [target, ...args]);
+    let cursor;
+    let convertedInput;
+    budget.setRetainedValues(retained, () => [target, ...args, cursor, convertedInput]);
     try {
         const input = await sandboxString(args[0], budget, context);
         if (methodName === "test") {
@@ -87,16 +95,20 @@ export async function callRegexMethod(target, methodName, args, budget, context)
         }
         if (!isSandboxRegex(target))
             throw new TypeError("RegExp execution requires a regex receiver.");
-        const match = executeRegex(target, input);
+        if (typeof args[0] !== "string")
+            convertedInput = input;
+        cursor = target.lastIndex;
+        const lastIndex = await sandboxNumber(cursor, budget, context);
+        const match = executeRegex(target, input, lastIndex);
         return methodName === "test" ? match !== null : toMatchArray(match, input);
     }
     finally {
         budget.setRetainedValues(retained, undefined);
     }
 }
-export function executeRegex(target, input) {
+export function executeRegex(target, input, lastIndex) {
     const pattern = getSandboxRegexPattern(target);
-    const match = matchRegex(pattern, input, target.lastIndex);
+    const match = matchRegex(pattern, input, lastIndex);
     if (pattern.flags.global) {
         target.lastIndex = match === null ? 0 : match.index + match.text.length;
     }