poe-code 14.0.73 → 14.0.75

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-I2Z37MKZ.js";
+} from "./chunks/chunk-BAJI3K4B.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-XKCTB5FR.js";
+} from "./chunks/chunk-EOTY4PCT.js";
 import "./chunks/chunk-ZWJ5BJUI.js";
 import "./chunks/chunk-3YTQEPZI.js";
 import "./chunks/chunk-4YIDX44G.js";

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

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

package/packages/safe-js/dist/graph-depth.js

@@ -2,6 +2,7 @@ import { replaceErrorStack } from "./error/shape.js";
 import { SandboxError } from "./interp/budget.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "./interp/arguments.js";
 import { collectionIteratorState, isSandboxCollectionIterator } from "./interp/collection-iterator.js";
+import { regexpIteratorState, isSandboxRegExpIterator } from "./interp/regexp-iterator.js";
 import { isSandboxMap, isSandboxSet } from "./interp/collection-brands.js";
 import { boxedDataProperties, isSandboxBox } from "./interp/boxed.js";
 import { regexGuestProperties } from "./interp/regexp-properties.js";
@@ -90,6 +91,8 @@ function graphEntries(value) {
     const entries = [];
     if (isSandboxCollectionIterator(value))
         entries.push([".<collection>", collectionIteratorState(value).collection]);
+    if (isSandboxRegExpIterator(value))
+        entries.push([".<matcher>", regexpIteratorState(value).matcher]);
     for (const key of Object.keys(value)) {
         const descriptor = Object.getOwnPropertyDescriptor(value, key);
         if (descriptor !== undefined && "value" in descriptor)

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

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-I2Z37MKZ.js";
+} from "./chunks/chunk-BAJI3K4B.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-XKCTB5FR.js";
+} from "./chunks/chunk-EOTY4PCT.js";
 import "./chunks/chunk-ZWJ5BJUI.js";
 import "./chunks/chunk-3YTQEPZI.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -1,5 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { collectionIteratorState, isSandboxCollectionIterator } from "./collection-iterator.js";
+import { regexpIteratorState, isSandboxRegExpIterator } from "./regexp-iterator.js";
 import { getSandboxPrototype } from "./object-model.js";
 import { createSandboxPromise, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet } from "./values.js";
 import { assertPromiseExecutionAllowed, interruptOnFatalPromiseRejection, onFatalPromiseRejection, observeSandboxPromise, trackSandboxPromise } from "./promise-tracker.js";
@@ -100,6 +101,8 @@ function registerCancelablePromises(value, signal) {
         else {
             if (isSandboxCollectionIterator(current))
                 pending.push(collectionIteratorState(current).collection);
+            if (isSandboxRegExpIterator(current))
+                pending.push(regexpIteratorState(current).matcher);
             for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(current))) {
                 if ("value" in descriptor)
                     pending.push(descriptor.value);

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

@@ -1,4 +1,5 @@
 import { isSandboxCollectionIterator } from "../collection-iterator.js";
+import { isSandboxRegExpIterator } from "../regexp-iterator.js";
 import { assertSandboxGraphDepth } from "../../graph-depth.js";
 import { CompileScope } from "../regex/compile-guard.js";
 import { createNumericParsers } from "./numeric-parsers.js";
@@ -49,7 +50,7 @@ function structuredCloneSandboxValue(value, budget, parent) {
     }
 }
 function assertStructuredCloneable(value, seen) {
-    if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value)) {
+    if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value)) {
         throw new TypeError("structuredClone() cannot clone closures, promises, or collection iterators.");
     }
     if (typeof value !== "object" || value === null || seen.has(value)) {

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

@@ -7,6 +7,7 @@ import { isSandboxErrorConstructorInstance } from "../exceptions.js";
 import { isFloat32Array } from "../float32.js";
 import { hasHostObjectMember, isGuestHostObject } from "../host-capabilities.js";
 import { collectionIteratorState, isSandboxCollectionIterator } from "../collection-iterator.js";
+import { isSandboxRegExpIterator } from "../regexp-iterator.js";
 import { getSandboxPrototype, getSandboxPropertyDescriptor, hasExplicitSandboxPrototype, installObjectPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
 import { toPropertyKey } from "../property-key.js";
 import { createSandboxClosure, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, getRegexProperties, isSandboxSet } from "../values.js";
@@ -180,6 +181,8 @@ function typeTag(value, builtinOnly = false) {
         return "Map";
     if (isSandboxSet(value))
         return "Set";
+    if (isSandboxRegExpIterator(value))
+        return "RegExp String Iterator";
     if (isSandboxCollectionIterator(value))
         return collectionIteratorState(value).collectionKind === "map" ? "Map Iterator" : "Set Iterator";
     if (isSandboxPromise(value))

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

@@ -1,7 +1,17 @@
-import { createSandboxClosure, createSandboxRegex, isSandboxRegex, reconcileCompiledValues } from "../values.js";
+import { createSandboxClosure, createSandboxRegex, isSandboxClosure, isSandboxRegex, reconcileCompiledValues } from "../values.js";
 import { CompileScope } from "../regex/compile-guard.js";
 import { SandboxError } from "../budget.js";
-import { sandboxString } from "../string-coercion.js";
+import { sandboxNumber, sandboxString } from "../string-coercion.js";
+import { getSandboxPropertyDescriptor, installRegexPrototype, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
+import { accessorAdapter, readPropertyDescriptor } from "../accessors.js";
+import { callRegexMethod, getRegexMember, regexFlagProperties, regexSearch } from "../methods/regex.js";
+import { regexMatch, regexReplace } from "../methods/string.js";
+import { invokeBuiltinClosure } from "../builtin-call.js";
+import { restoreSandboxRegExpIterator } from "../regexp-iterator.js";
+import { normalizeLastIndex } from "../regex/engine.js";
+import { retainValues } from "../resources.js";
+import { setSandboxProperty } from "../interpreter.js";
+import { regexSplit } from "../methods/regex-split.js";
 export function createRegexGlobals(options) {
     const invoke = (construct) => async (args, context) => {
         const selected = options.compileOwner ?? context?.compilation?.owner;
@@ -12,18 +22,51 @@ export function createRegexGlobals(options) {
         const compilation = context?.compilation?.owner === operation.owner
             ? context.compilation : new CompileScope(operation.owner);
         let source = "";
+        let retainedSource;
+        let retainedFlags;
+        let retainedPrototype;
         const retained = {};
-        options.budget.setRetainedValues(retained, () => [...args, source]);
+        options.budget.setRetainedValues(retained, () => [...args, source, retainedSource, retainedFlags, retainedPrototype]);
         try {
             const pattern = args[0];
             const flags = args[1];
-            if (!construct && isSandboxRegex(pattern) && flags === undefined)
+            const read = (key) => {
+                const descriptor = getSandboxPropertyDescriptor(pattern, key, options.budget);
+                if (context?.getProperty !== undefined)
+                    return context.getProperty(pattern, key);
+                return descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, pattern, context);
+            };
+            let regexLike = false;
+            if (pattern !== null && typeof pattern === "object") {
+                const match = await read(Symbol.match);
+                regexLike = match === undefined ? isSandboxRegex(pattern) : Boolean(match);
+            }
+            if (!construct && regexLike && flags === undefined && await read("constructor") === constructor)
                 return pattern;
-            const sourceValue = isSandboxRegex(pattern) ? pattern.source : pattern;
-            const flagsValue = isSandboxRegex(pattern) && flags === undefined ? pattern.flags : flags;
+            let sourceValue = pattern;
+            let flagsValue = flags;
+            if (isSandboxRegex(pattern)) {
+                sourceValue = pattern.source;
+                if (flags === undefined)
+                    flagsValue = pattern.flags;
+            }
+            else if (regexLike) {
+                sourceValue = retainedSource = await read("source");
+                if (flags === undefined)
+                    flagsValue = retainedFlags = await read("flags");
+            }
+            if (construct && context?.newTarget !== undefined && context.newTarget !== constructor) {
+                retainedPrototype = context.getProperty !== undefined
+                    ? await context.getProperty(context.newTarget, "prototype")
+                    : await readPropertyDescriptor(getSandboxPropertyDescriptor(context.newTarget, "prototype", options.budget) ?? { value: undefined }, context.newTarget, context);
+            }
             source = sourceValue === undefined ? "" : await sandboxString(sourceValue, options.budget, context);
+            retainedSource = undefined;
             const flagText = flagsValue === undefined ? "" : await sandboxString(flagsValue, options.budget, context);
+            retainedFlags = undefined;
             const regex = createSandboxRegex(source, flagText, 0, compilation);
+            if (typeof retainedPrototype === "object" && retainedPrototype !== null)
+                setSandboxPrototype(regex, retainedPrototype, options.budget);
             if (compilation !== context?.compilation) {
                 reconcileCompiledValues(options.budget, [regex], compilation);
             }
@@ -36,7 +79,151 @@ export function createRegexGlobals(options) {
             operation.release();
         }
     };
-    return {
-        RegExp: createSandboxClosure({ sandbox: true, name: "RegExp", call: invoke(false), construct: invoke(true) })
-    };
+    const constructor = createSandboxClosure({ guest: true, sandbox: true, name: "RegExp", length: 2, call: invoke(false), construct: invoke(true) });
+    Object.defineProperty(materializeFunctionProperties(constructor), "escape", {
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "escape", length: 1,
+            call: (args) => {
+                const input = args[0];
+                if (typeof input !== "string")
+                    throw new TypeError("RegExp.escape requires a string.");
+                const allocation = {};
+                let escaped = "";
+                try {
+                    for (const character of input) {
+                        options.budget.visitNode();
+                        const point = character.codePointAt(0);
+                        let part = character;
+                        if (escaped.length === 0 && ((point >= 48 && point <= 57) ||
+                            (point >= 65 && point <= 90) || (point >= 97 && point <= 122))) {
+                            part = `\\x${point.toString(16)}`;
+                        }
+                        else if ("^$\\.*+?()[]{}|/".includes(character)) {
+                            part = "\\" + character;
+                        }
+                        else {
+                            const control = "\f\n\r\t\v".indexOf(character);
+                            if (control !== -1)
+                                part = "\\" + "fnrtv"[control];
+                            else if (",-=<>#&!%:;@~'`\"".includes(character) || character.trim() === "" ||
+                                (point >= 0xd800 && point <= 0xdfff)) {
+                                part = point <= 0xff ? `\\x${point.toString(16).padStart(2, "0")}`
+                                    : `\\u${point.toString(16).padStart(4, "0")}`;
+                            }
+                        }
+                        options.budget.setRetainedDataUsage(allocation, escaped.length + part.length);
+                        escaped = options.budget.allocateString(escaped + part);
+                    }
+                    return escaped;
+                }
+                finally {
+                    options.budget.setRetainedDataUsage(allocation, 0);
+                }
+            }
+        }), writable: true, configurable: true
+    });
+    const prototype = Object.create(null);
+    Object.defineProperty(materializeFunctionProperties(constructor), Symbol.species, {
+        get: accessorAdapter(createSandboxClosure({ sandbox: true, name: "get [Symbol.species]", length: 0,
+            call: (_args, context) => context?.thisValue }), "get"), configurable: true
+    });
+    Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
+    Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
+    Object.defineProperty(prototype, Symbol.search, {
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "[Symbol.search]", length: 1,
+            call: (args, context) => regexSearch(context?.thisValue, args[0], options.budget, context) }),
+        writable: true, configurable: true
+    });
+    Object.defineProperty(prototype, Symbol.match, {
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "[Symbol.match]", length: 1,
+            call: (args, context) => regexMatch(args[0], context?.thisValue, options.budget, context) }),
+        writable: true, configurable: true
+    });
+    Object.defineProperty(prototype, Symbol.replace, {
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "[Symbol.replace]", length: 2,
+            call: (args, context) => regexReplace(args[0], context?.thisValue, args[1], options.budget, (closure, values) => invokeBuiltinClosure(closure, values, options.budget, context, undefined), context) }),
+        writable: true, configurable: true
+    });
+    Object.defineProperty(prototype, Symbol.matchAll, {
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "[Symbol.matchAll]", length: 1,
+            call: async (args, context) => {
+                const target = context?.thisValue;
+                if (target === null || typeof target !== "object")
+                    throw new TypeError("RegExp matchAll requires an object receiver.");
+                let input = args[0];
+                let string;
+                let species;
+                let field;
+                let flags;
+                let matcher;
+                const release = retainValues(options.budget, () => [target, input, string, species, field, flags, matcher]);
+                const read = (value, key) => {
+                    if (context?.getProperty !== undefined)
+                        return context.getProperty(value, key);
+                    const descriptor = getSandboxPropertyDescriptor(value, key, options.budget);
+                    return descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, value, context);
+                };
+                try {
+                    string = await sandboxString(input, options.budget, context);
+                    input = undefined;
+                    field = await read(target, "constructor");
+                    species = constructor;
+                    if (field !== undefined) {
+                        if (field === null || typeof field !== "object")
+                            throw new TypeError("Invalid RegExp species constructor.");
+                        species = await read(field, Symbol.species);
+                        if (species === null || species === undefined)
+                            species = constructor;
+                    }
+                    field = undefined;
+                    if (!isSandboxClosure(species) || species.construct === undefined)
+                        throw new TypeError("RegExp species must be a constructor.");
+                    field = await read(target, "flags");
+                    flags = await sandboxString(field, options.budget, context);
+                    field = undefined;
+                    matcher = await invokeBuiltinClosure(species, [target, flags], options.budget, context, undefined, true);
+                    field = await read(target, "lastIndex");
+                    const cursor = normalizeLastIndex(await sandboxNumber(field, options.budget, context));
+                    field = undefined;
+                    await setSandboxProperty(matcher, "lastIndex", cursor, options.budget, true, context);
+                    return restoreSandboxRegExpIterator({ matcher, input: string, exhausted: false,
+                        global: flags.includes("g"), unicode: flags.includes("u") || flags.includes("v") });
+                }
+                finally {
+                    release();
+                }
+            } }),
+        writable: true, configurable: true
+    });
+    Object.defineProperty(prototype, Symbol.split, {
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "[Symbol.split]", length: 2,
+            call: (args, context) => regexSplit(context?.thisValue, args[0], args[1], constructor, options.budget, context) }),
+        writable: true, configurable: true
+    });
+    for (const name of ["exec", "test", "toString"]) {
+        Object.defineProperty(prototype, name, {
+            value: createSandboxClosure({ sandbox: true, name, length: name === "toString" ? 0 : 1,
+                call: (args, context) => callRegexMethod(context?.thisValue, name, args, options.budget, context) }),
+            writable: true, configurable: true
+        });
+    }
+    for (const name of ["source", "flags", ...Object.keys(regexFlagProperties)]) {
+        const getter = createSandboxClosure({ sandbox: true, name: `get ${name}`, length: 0,
+            call: (_args, context) => {
+                const receiver = context?.thisValue;
+                if (name === "flags") {
+                    if (receiver === null || typeof receiver !== "object")
+                        throw new TypeError("RegExp flags requires an object receiver.");
+                    return getRegexMember(receiver, name, options.budget, context);
+                }
+                if (receiver === prototype)
+                    return name === "source" ? "(?:)" : undefined;
+                if (!isSandboxRegex(receiver))
+                    throw new TypeError("RegExp accessor requires a regex receiver.");
+                return getRegexMember(receiver, name, options.budget, context);
+            }
+        });
+        Object.defineProperty(prototype, name, { get: accessorAdapter(getter, "get"), configurable: true });
+    }
+    installRegexPrototype(options.budget, prototype, constructor);
+    return { RegExp: constructor };
 }

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

@@ -35,6 +35,8 @@ import { hasOwnSandboxProperty } from "./globals/object.js";
 import { isSandboxMapConstructor, isSandboxSetConstructor } from "./globals/collections.js";
 import { collectionIteratorState, isSandboxCollectionIterator } from "./collection-iterator.js";
 import { getCollectionIteratorMember } from "./methods/collection-iterator.js";
+import { isSandboxRegExpIterator, regexpIteratorState } from "./regexp-iterator.js";
+import { getRegExpIteratorMember } from "./methods/regexp-iterator.js";
 import { getFloat32Member, isFloat32ArrayConstructor, setFloat32Member } from "./globals/float32array.js";
 import { isFloat32Array } from "./float32.js";
 import { dateString, dateTime, isSandboxDate } from "./date.js";
@@ -857,6 +859,8 @@ function isRestorableBindingValue(value, seen = new WeakSet()) {
     if (seen.has(value))
         return true;
     seen.add(value);
+    if (isSandboxRegExpIterator(value))
+        return isRestorableBindingValue(regexpIteratorState(value).matcher, seen);
     if (isSandboxCollectionIterator(value)) {
         return isRestorableBindingValue(collectionIteratorState(value).collection, seen);
     }
@@ -1116,7 +1120,7 @@ async function evaluateForOfStatement(node, context) {
         const restored = context.scope.consumeRestoredBinding(restoredIteration.values[0]);
         if (restored.found && Array.isArray(restored.value)) {
             restoredEntry = { done: false, value: restored.value[1] };
-            if (Array.isArray(restored.value[0]) || isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0]) || isSandboxCollectionIterator(restored.value[0])) {
+            if (Array.isArray(restored.value[0]) || isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0]) || isSandboxCollectionIterator(restored.value[0]) || isSandboxRegExpIterator(restored.value[0])) {
                 return evaluateForOfIterator(node, restored.value[0], context, restoredEntry);
             }
         }
@@ -1510,7 +1514,7 @@ function createLoopIterationContext(context, scope) {
             snapshot.loopIterations = {};
             for (const [nodeId, iteration] of context.activeLoopIterations) {
                 if (typeof iteration !== "number" &&
-                    (Array.isArray(iteration.values[0]) || isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]) || isSandboxCollectionIterator(iteration.values[0]))) {
+                    (Array.isArray(iteration.values[0]) || isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]) || isSandboxCollectionIterator(iteration.values[0]) || isSandboxRegExpIterator(iteration.values[0]))) {
                     const bindingName = `#for-of:${nodeId}`;
                     snapshot.bindings[bindingName] = iteration.values;
                     snapshot.loopIterations[nodeId] = { index: iteration.index, values: [bindingName] };
@@ -1852,6 +1856,8 @@ function getPropertyValue(target, property, context, receiver = target) {
     const descriptor = getSandboxPropertyDescriptor(target, property, context.budget);
     if (descriptor !== undefined)
         return readPropertyDescriptor(descriptor, receiver, createCoercionContext(context), true);
+    if (isSandboxRegExpIterator(target))
+        return getRegExpIteratorMember(property, context.budget);
     if (typeof target === "symbol") {
         const prototype = getBoxedPrototype(target, context.budget);
         return prototype === undefined ? undefined : getPropertyValue(prototype, property, context, receiver);
@@ -1892,7 +1898,8 @@ function getPropertyValue(target, property, context, receiver = target) {
     if (isSandboxPromise(target))
         return getPromiseMember(property, context.budget);
     if (isSandboxRegex(target))
-        return getRegexMember(target, property, context.budget);
+        return hasExplicitSandboxPrototype(target) || getSandboxPrototype(target, context.budget) !== null
+            ? undefined : getRegexMember(target, property, context.budget, createCoercionContext(context));
     if (!isIndexableSandboxValue(target)) {
         throw new TypeError("Attempted to read a property from a non-object value.");
     }
@@ -2381,9 +2388,9 @@ function hasSandboxProperty(value, key, context) {
             return typeof key === "symbol" ? false : hasHostObjectMember(current, String(key));
         if (hasOwnSandboxProperty(current, key, false))
             return true;
-        if (!((isGuestClosure(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) &&
+        if (!isSandboxRegex(current) && !((isGuestClosure(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) &&
             (Array.isArray(current) || !isPlainSandboxObject(current) ||
-                isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current))) {
+                isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current))) {
             return getPropertyValue(current, key, context) !== undefined;
         }
         current = getSandboxPrototype(current, context.budget);
@@ -2603,7 +2610,7 @@ function getMemberValue(target, property, context) {
             return getClosureMemberValue(current, property, context);
         if (Array.isArray(current))
             return getArrayMemberValue(current, property, context);
-        if (!isPlainSandboxObject(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isFloat32Array(current)) {
+        if (!isPlainSandboxObject(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current) || isFloat32Array(current)) {
             return getPropertyValue(current, property, context);
         }
         if (Object.hasOwn(current, String(property)))
@@ -2646,7 +2653,7 @@ export function setSandboxProperty(target, property, value, budget, checkInherit
         return;
     }
     if (isSandboxRegex(target)) {
-        setRegexMember(target, property, value);
+        setRegexMember(target, property, value, budget);
         return;
     }
     if (!isIndexableSandboxValue(target)) {

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

@@ -4,6 +4,8 @@ import { isFloat32Array } from "./float32.js";
 import { boxedValue, isSandboxBox } from "./boxed.js";
 import { getHostObjectIterator, isGuestHostObject } from "./host-capabilities.js";
 import { isSandboxCollectionIterator, nextCollectionIterator } from "./collection-iterator.js";
+import { isSandboxRegExpIterator } from "./regexp-iterator.js";
+import { nextObservableRegExpIterator, nextRegExpIterator } from "./methods/regexp-iterator.js";
 import { Budget, isFatalSandboxError } from "./budget.js";
 import { sandboxString } from "./string-coercion.js";
 import { awaitSandboxValue, awaitWithSignal } from "./cancel.js";
@@ -17,7 +19,8 @@ export async function acquireSandboxIterator(value, budget, context, asyncProtoc
         return asyncProtocol
             ? getSandboxAsyncIterator(value, budget, context, signal)
             : getSandboxIterator(value, budget, context);
-    if (getSandboxPropertyDescriptor(value, key, budget) === undefined) {
+    if (getSandboxPropertyDescriptor(value, key, budget) === undefined &&
+        !(isSandboxRegExpIterator(value) && !asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== undefined)) {
         if (!asyncProtocol)
             return getSandboxIterator(value, budget, context);
         if (isSandboxGenerator(value) && value.async)
@@ -222,6 +225,11 @@ export function getSandboxIterator(value, budget, context) {
     }
     if (isSandboxCollectionIterator(value))
         return { next: () => nextCollectionIterator(value, budget), snapshotIndex: () => 0 };
+    if (isSandboxRegExpIterator(value)) {
+        if (context !== undefined && budget !== undefined)
+            return { asynchronous: true, next: () => nextObservableRegExpIterator(value, budget, context), snapshotIndex: () => 0 };
+        return { next: () => nextRegExpIterator(value, budget), snapshotIndex: () => 0 };
+    }
     if (isGuestHostObject(value))
         return getHostObjectIterator(value);
     if (isFloat32Array(value)) {

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

@@ -0,0 +1,3 @@
+import { type Budget } from "../budget.js";
+import { type SandboxCallContext, type SandboxClosure, type SandboxValue } from "../values.js";
+export declare function regexSplit(target: SandboxValue, input: SandboxValue, limit: SandboxValue, constructor: SandboxClosure, budget: Budget, context?: SandboxCallContext): Promise<SandboxValue[]>;

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

@@ -0,0 +1,102 @@
+import { isSandboxClosure } from "../values.js";
+import { getSandboxPropertyDescriptor } from "../object-model.js";
+import { readPropertyDescriptor } from "../accessors.js";
+import { invokeBuiltinClosure } from "../builtin-call.js";
+import { setSandboxProperty } from "../interpreter.js";
+import { sandboxNumber, sandboxString } from "../string-coercion.js";
+import { normalizeLastIndex } from "../regex/engine.js";
+import { retainValues } from "../resources.js";
+import { regexExec } from "./regex.js";
+export async function regexSplit(target, input, limit, constructor, budget, context) {
+    if (target === null || typeof target !== "object")
+        throw new TypeError("RegExp split requires an object receiver.");
+    let string;
+    let species;
+    let field;
+    let flags;
+    let matcher;
+    let match;
+    const result = [];
+    const release = retainValues(budget, () => [target, input, limit, string, species, field, flags, matcher, match, result]);
+    const read = (value, key) => {
+        if (context?.getProperty !== undefined)
+            return context.getProperty(value, key);
+        const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+        return descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, value, context);
+    };
+    const append = (value) => {
+        budget.allocateArrayLength(result.length + 1);
+        result.push(value);
+    };
+    try {
+        string = await sandboxString(input, budget, context);
+        input = undefined;
+        field = await read(target, "constructor");
+        species = constructor;
+        if (field !== undefined) {
+            if (field === null || typeof field !== "object")
+                throw new TypeError("Invalid RegExp species constructor.");
+            species = await read(field, Symbol.species);
+            if (species === null || species === undefined)
+                species = constructor;
+        }
+        field = undefined;
+        if (!isSandboxClosure(species) || species.construct === undefined)
+            throw new TypeError("RegExp species must be a constructor.");
+        field = await read(target, "flags");
+        flags = await sandboxString(field, budget, context);
+        field = undefined;
+        const unicode = flags.includes("u") || flags.includes("v");
+        if (!flags.includes("y"))
+            flags = budget.allocateString(flags + "y");
+        matcher = await invokeBuiltinClosure(species, [target, flags], budget, context, undefined, true);
+        const maximum = limit === undefined ? 2 ** 32 - 1 : (await sandboxNumber(limit, budget, context)) >>> 0;
+        limit = undefined;
+        if (maximum === 0)
+            return result;
+        if (string.length === 0) {
+            match = await regexExec(matcher, string, budget, context);
+            if (match === null)
+                append(string);
+            return result;
+        }
+        let end = 0;
+        let index = 0;
+        while (index < string.length) {
+            budget.visitNode();
+            match = undefined;
+            await setSandboxProperty(matcher, "lastIndex", index, budget, true, context);
+            match = await regexExec(matcher, string, budget, context);
+            if (match !== null) {
+                field = await read(matcher, "lastIndex");
+                const next = Math.min(normalizeLastIndex(await sandboxNumber(field, budget, context)), string.length);
+                field = undefined;
+                if (next !== end) {
+                    append(budget.allocateString(string.slice(end, index)));
+                    if (result.length === maximum)
+                        return result;
+                    end = next;
+                    field = await read(match, "length");
+                    const length = normalizeLastIndex(await sandboxNumber(field, budget, context));
+                    field = undefined;
+                    for (let capture = 1; capture < length; capture++) {
+                        budget.visitNode();
+                        field = await read(match, String(capture));
+                        append(field);
+                        field = undefined;
+                        if (result.length === maximum)
+                            return result;
+                    }
+                    index = end;
+                    continue;
+                }
+            }
+            index += unicode && (string.codePointAt(index) ?? 0) > 0xffff ? 2 : 1;
+        }
+        append(budget.allocateString(string.slice(end)));
+        return result;
+    }
+    finally {
+        release();
+    }
+}

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

@@ -1,10 +1,14 @@
 import { type SandboxCallContext, type SandboxRegex, type SandboxValue } from "../values.js";
 import { type RegexMatch } from "../regex/engine.js";
 import type { Budget } from "../budget.js";
-export type RegexMethodName = "exec" | "test";
+export declare function regexSearch(target: SandboxValue, input: SandboxValue, budget: Budget, context?: SandboxCallContext): Promise<SandboxValue>;
+export type RegexMethodName = "exec" | "test" | "toString";
+export declare const regexFlagProperties: Readonly<Record<string, string>>;
 export declare function isRegexMethodName(property: string | number): property is RegexMethodName;
-export declare function getRegexMember(target: SandboxRegex, property: string | number, budget: Budget): SandboxValue | undefined;
-export declare function setRegexMember(target: SandboxRegex, property: PropertyKey, value: SandboxValue): void;
+export declare function getRegexMember(target: SandboxRegex, property: string | number, budget: Budget, context?: SandboxCallContext): SandboxValue | Promise<SandboxValue>;
+export declare function setRegexMember(target: SandboxRegex, property: PropertyKey, value: SandboxValue, budget?: Budget): void;
 export declare function callRegexMethod(target: SandboxValue, methodName: RegexMethodName, args: readonly SandboxValue[], budget: Budget, context?: SandboxCallContext): Promise<SandboxValue>;
+export declare function regexExec(target: SandboxValue, input: string, budget: Budget, context?: SandboxCallContext): Promise<SandboxValue>;
+export declare function regexToString(target: SandboxValue, budget: Budget, context?: SandboxCallContext): Promise<string>;
 export declare function executeRegex(target: SandboxRegex, input: string, lastIndex: number): RegexMatch | null;
-export declare function toMatchArray(match: RegexMatch | null, input: string): SandboxValue;
+export declare function toMatchArray(match: RegexMatch | null, input: string, budget?: Budget): SandboxValue;