poe-code 14.0.73 → 14.0.74

package/packages/safe-js/dist/interp/object-model.d.ts

@@ -9,6 +9,8 @@ export declare function getGuestFunctionProperty(closure: SandboxClosure, key: P
 export declare function installObjectPrototype(budget: Budget, prototype: SandboxObject, constructor: SandboxClosure): void;
 export declare function installBoxedPrototype(budget: Budget, prototype: SandboxObject, constructor: SandboxClosure, kind?: BoxedKind): void;
 export declare function getBoxedPrototype(value: BoxedPrimitive, budget: Budget): SandboxObject | undefined;
+export declare function installRegexPrototype(budget: Budget, prototype: SandboxObject, constructor: SandboxClosure): void;
+export declare function hasRegexPropertyOverride(value: SandboxValue, keys: readonly string[], budget: Budget): boolean;
 export declare function isDefaultBoxedMethod(value: BoxedPrimitive, key: string, budget: Budget): boolean;
 export declare function isIntrinsicConstructor(value: object): boolean;
 export declare function releaseObjectPrototype(budget: Budget): void;

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

@@ -9,6 +9,8 @@ const functionProperties = new WeakMap();
 const prototypes = new WeakMap();
 const intrinsicPrototypes = new WeakMap();
 const boxedPrototypes = new WeakMap();
+const regexPrototypes = new WeakMap();
+const initialRegexDescriptors = new WeakMap();
 const intrinsicPrototypeRoots = new WeakMap();
 const intrinsicConstructors = new WeakMap();
 const initialBoxedMethods = new WeakMap();
@@ -80,6 +82,24 @@ export function installBoxedPrototype(budget, prototype, constructor, kind = typ
 export function getBoxedPrototype(value, budget) {
     return boxedPrototypes.get(budget)?.get(typeof value);
 }
+export function installRegexPrototype(budget, prototype, constructor) {
+    regexPrototypes.set(budget, prototype);
+    initialRegexDescriptors.set(budget, Object.getOwnPropertyDescriptors(prototype));
+    registerIntrinsicPrototype(budget, prototype, constructor);
+}
+export function hasRegexPropertyOverride(value, keys, budget) {
+    const initial = initialRegexDescriptors.get(budget);
+    const prototype = regexPrototypes.get(budget);
+    const defaultPrototype = isSandboxRegex(value) && prototype !== undefined && getSandboxPrototype(value, budget) === prototype;
+    return keys.some(key => {
+        const current = defaultPrototype
+            ? Object.getOwnPropertyDescriptor(getRegexProperties(value), key) ?? Object.getOwnPropertyDescriptor(prototype, key)
+            : getSandboxPropertyDescriptor(value, key, budget);
+        const expected = initial?.[key];
+        return expected === undefined ? current !== undefined : current === undefined ||
+            current.value !== expected.value || current.get !== expected.get || current.set !== expected.set;
+    });
+}
 export function isDefaultBoxedMethod(value, key, budget) {
     const prototype = getBoxedPrototype(value, budget);
     return prototype !== undefined && initialBoxedMethods.get(prototype)?.has(key) === true &&
@@ -93,7 +113,10 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
     if (roots === undefined)
         intrinsicPrototypeRoots.set(budget, (roots = new Set()));
     roots.add(prototype);
-    const records = [prototype, constructor]
+    const methods = Reflect.ownKeys(prototype)
+        .map(key => Object.getOwnPropertyDescriptor(prototype, key)?.value)
+        .filter(isGuestClosure);
+    const records = [...new Set([prototype, constructor, ...methods])]
         .map((target) => ({
         target,
         value: isGuestClosure(target) ? materializeFunctionProperties(target) : target,
@@ -102,7 +125,7 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
     }))
         .map((record) => ({
         ...record,
-        descriptors: new Map(Object.entries(Object.getOwnPropertyDescriptors(record.value)))
+        descriptors: new Map(Reflect.ownKeys(record.value).map(key => [key, Object.getOwnPropertyDescriptor(record.value, key)]))
     }));
     const unchanged = (before, after) => before !== undefined &&
         after !== undefined &&
@@ -116,16 +139,19 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
         const current = Object.getOwnPropertyDescriptors(value);
         return (getSandboxPrototype(target) === parent &&
             hasExplicitSandboxPrototype(target) === explicit &&
-            Object.keys(current).length === descriptors.size &&
-            Object.keys(current).every((key) => unchanged(descriptors.get(key), current[key])));
+            Reflect.ownKeys(current).length === descriptors.size &&
+            Reflect.ownKeys(value).every((key) => unchanged(descriptors.get(key), Object.getOwnPropertyDescriptor(value, key))));
     }));
     budget.setRetainedValues(prototype, () => records.flatMap(({ target, value, descriptors, prototype: parent }) => [
         ...(getSandboxPrototype(target) === parent
             ? []
             : [getSandboxPrototype(target)]),
-        ...Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(([key, descriptor]) => unchanged(descriptors.get(key), descriptor)
-            ? []
-            : [key, descriptor.value, ...retainedAccessorClosures(descriptor)])
+        ...Reflect.ownKeys(value).flatMap(key => {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            return unchanged(descriptors.get(key), descriptor)
+                ? []
+                : [key, descriptor.value, ...retainedAccessorClosures(descriptor)];
+        })
     ]));
 }
 export function releaseObjectPrototype(budget) {
@@ -133,11 +159,15 @@ export function releaseObjectPrototype(budget) {
         budget.setRetainedValues(prototype, undefined);
     intrinsicPrototypeRoots.delete(budget);
     boxedPrototypes.delete(budget);
+    regexPrototypes.delete(budget);
+    initialRegexDescriptors.delete(budget);
     intrinsicPrototypes.delete(budget);
 }
 export function getSandboxPrototype(value, budget) {
     if (prototypes.has(value))
         return prototypes.get(value) ?? null;
+    if (budget !== undefined && isSandboxRegex(value))
+        return regexPrototypes.get(budget) ?? null;
     if (budget !== undefined && isSandboxBox(value)) {
         const prototype = getBoxedPrototype(boxedValue(value), budget);
         if (prototype !== undefined && prototype !== value)
@@ -213,13 +243,13 @@ export function setSandboxPrototype(value, prototype, budget) {
     if (budget !== undefined && intrinsicPrototypes.get(budget) === value && prototype !== null) {
         throw new TypeError("Object.prototype has an immutable null prototype.");
     }
-    if ((!Array.isArray(value) && !isPrototypeRecord(value)) ||
+    if ((!Array.isArray(value) && !isSandboxRegex(value) && !isPrototypeRecord(value)) ||
         (prototype !== null && !Array.isArray(prototype) && !isPrototypeRecord(prototype))) {
         throw new TypeError("Prototype links require ordinary sandbox objects, arrays, or guest functions.");
     }
     if (prototypes.has(value) && getSandboxPrototype(value, budget) === prototype)
         return;
-    if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : value)) {
+    if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value)) {
         throw new TypeError("Cannot change the prototype of a non-extensible object.");
     }
     let depth = 0;

package/packages/safe-js/dist/interp/regexp-iterator.d.ts

@@ -0,0 +1,14 @@
+import type { SandboxRegex } from "./values.js";
+declare const regexpIteratorBrand: unique symbol;
+export type SandboxRegExpIterator = {
+    readonly [regexpIteratorBrand]: true;
+};
+export type RegExpIteratorState = {
+    matcher: SandboxRegex | undefined;
+    input: string | undefined;
+    exhausted: boolean;
+};
+export declare function isSandboxRegExpIterator(value: unknown): value is SandboxRegExpIterator;
+export declare function restoreSandboxRegExpIterator(state: RegExpIteratorState, target?: SandboxRegExpIterator): SandboxRegExpIterator;
+export declare function regexpIteratorState(value: SandboxRegExpIterator): RegExpIteratorState;
+export {};

package/packages/safe-js/dist/interp/regexp-iterator.js

@@ -0,0 +1,18 @@
+const states = new WeakMap();
+export function isSandboxRegExpIterator(value) {
+    return typeof value === "object" && value !== null && states.has(value);
+}
+export function restoreSandboxRegExpIterator(state, target = Object.create(null)) {
+    if (!state.exhausted && (state.matcher === undefined || state.input === undefined))
+        throw new TypeError("A live RegExp iterator requires its matcher and input.");
+    states.set(target, state.exhausted
+        ? { matcher: undefined, input: undefined, exhausted: true }
+        : { ...state });
+    return target;
+}
+export function regexpIteratorState(value) {
+    const state = states.get(value);
+    if (state === undefined)
+        throw new TypeError("Expected a RegExp string iterator.");
+    return state;
+}

package/packages/safe-js/dist/interp/string-coercion.js

@@ -7,12 +7,13 @@ import { float32Storage, isFloat32Array } from "./float32.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { isGuestHostObject } from "./host-capabilities.js";
 import { collectionIteratorState, isSandboxCollectionIterator } from "./collection-iterator.js";
+import { isSandboxRegExpIterator } from "./regexp-iterator.js";
 import { getGuestFunctionProperties, getSandboxPrototype, hasExplicitSandboxPrototype, isGuestClosure } from "./object-model.js";
-import { getRegexMember } from "./methods/regex.js";
+import { regexToString } from "./methods/regex.js";
 import { retainValues } from "./resources.js";
 import { functionString } from "./function-string.js";
 import { boxedValue, isSandboxBox } from "./boxed.js";
-import { isSandboxClosure, isSandboxPromise, isSandboxMap, isSandboxSet, isSandboxRegex, isSandboxGenerator } from "./values.js";
+import { isSandboxClosure, isSandboxPromise, isSandboxMap, isSandboxSet, isSandboxRegex, getRegexProperties, isSandboxGenerator } from "./values.js";
 const defaultStringHook = Symbol("defaultStringHook");
 const defaultValueHook = Symbol("defaultValueHook");
 const joiningArrays = new WeakSet();
@@ -115,14 +116,16 @@ function conversionHook(value, name, budget, context) {
             isSandboxMap(value) ||
             isSandboxSet(value) ||
             isSandboxCollectionIterator(value) ||
+            isSandboxRegExpIterator(value) ||
             isSandboxPromise(value) ||
-            isSandboxRegex(value) ||
+            (isSandboxRegex(value) && getSandboxPrototype(value, budget) === null) ||
             isSandboxGenerator(value) ||
             isGuestHostObject(value));
     let current = value;
     let depth = 0;
     while (current !== null) {
-        const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : current;
+        const properties = isGuestClosure(current) ? getGuestFunctionProperties(current)
+            : isSandboxRegex(current) ? getRegexProperties(current) : current;
         const descriptor = properties === undefined ? undefined : Object.getOwnPropertyDescriptor(properties, name);
         if (descriptor !== undefined) {
             return readPropertyDescriptor(descriptor, value, context);
@@ -154,15 +157,16 @@ async function defaultToString(value, budget, context, joining) {
         return "[object Map]";
     if (isSandboxSet(value))
         return "[object Set]";
+    if (isSandboxRegExpIterator(value))
+        return "[object RegExp String Iterator]";
     if (isSandboxCollectionIterator(value))
         return collectionIteratorState(value).collectionKind === "map"
             ? "[object Map Iterator]"
             : "[object Set Iterator]";
     if (isSandboxGenerator(value))
         return "[object Generator]";
-    if (isSandboxRegex(value)) {
-        return budget.allocateString(`/${String(getRegexMember(value, "source", budget))}/${String(getRegexMember(value, "flags", budget))}`);
-    }
+    if (isSandboxRegex(value))
+        return regexToString(value, budget, context);
     if (isSandboxDate(value))
         return budget.allocateString(dateString(value));
     if (Array.isArray(value) || isFloat32Array(value)) {

package/packages/safe-js/dist/interp/values.d.ts

@@ -1,6 +1,7 @@
 export { getRegexProperties } from "./regexp-properties.js";
 import { sandboxMapBrand, sandboxSetBrand } from "./collection-brands.js";
 import { type SandboxCollectionIterator } from "./collection-iterator.js";
+import { type SandboxRegExpIterator } from "./regexp-iterator.js";
 import type { Budget, CompileTicket } from "./budget.js";
 import { CompileScope } from "./regex/compile-guard.js";
 import type { GeneratorChannel } from "./generator.js";
@@ -15,7 +16,7 @@ declare const sandboxRegexBrand: unique symbol;
 declare const sandboxRegexPattern: unique symbol;
 declare const sandboxRetainedValues: unique symbol;
 export type SandboxPrimitive = string | number | boolean | symbol | null | undefined;
-export type SandboxValue = SandboxPrimitive | Date | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxCollectionIterator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
+export type SandboxValue = SandboxPrimitive | Date | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxCollectionIterator | SandboxRegExpIterator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
 export type SandboxObject = {
     [key: string]: SandboxValue;
     [key: symbol]: SandboxValue;

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

@@ -5,6 +5,7 @@ export { getRegexProperties } from "./regexp-properties.js";
 import { retainedAccessorClosures } from "./accessors.js";
 import { isSandboxMap, isSandboxSet, sandboxMapBrand, sandboxSetBrand } from "./collection-brands.js";
 import { collectionIteratorState, isSandboxCollectionIterator, restoreSandboxCollectionIterator, snapshotCollectionIterator } from "./collection-iterator.js";
+import { regexpIteratorState, isSandboxRegExpIterator, restoreSandboxRegExpIterator } from "./regexp-iterator.js";
 import { copyNativeDate, dateDataProperties, exportDate, isSandboxDate } from "./date.js";
 import { boxedDataProperties, boxedValue, createSandboxBox, isSandboxBox, nativeBoxedValue } from "./boxed.js";
 import { getHostObjectKeys, getHostObjectMember, hasHostObjectMember, measureHostObjectData, isGuestHostObject, isLiveCapability } from "./host-capabilities.js";
@@ -400,6 +401,17 @@ export function measureSandboxData(values, options = {}) {
             }
             return;
         }
+        if (isSandboxRegExpIterator(value)) {
+            const state = regexpIteratorState(value);
+            visit(state.matcher, depth + 1);
+            visit(state.input, depth + 1);
+            for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+                usage += key.length + 1;
+                if ("value" in descriptor)
+                    visit(descriptor.value, depth + 1);
+            }
+            return;
+        }
         if (isSandboxCollectionIterator(value)) {
             visit(collectionIteratorState(value).collection, depth + 1);
             for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
@@ -588,6 +600,26 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
         isSandboxPromise(value)) {
         return value;
     }
+    if (isSandboxRegExpIterator(value)) {
+        if (hasGuestObjectState(value))
+            throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
+        if (!cloneSandboxCollections)
+            return value;
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        const snapshot = regexpIteratorState(value);
+        const copy = restoreSandboxRegExpIterator({ matcher: undefined, input: undefined, exhausted: true });
+        state.seen.set(value, copy);
+        const matcher = copyToSandbox(snapshot.matcher, state, `${path}.<matcher>`, true, depth + 1);
+        if (matcher !== undefined && !isSandboxRegex(matcher))
+            throw new TypeError("Invalid RegExp iterator matcher.");
+        restoreSandboxRegExpIterator({ ...snapshot, matcher }, copy);
+        for (const entry of getEnumerableObjectEntries(value, path)) {
+            defineOwnDataProperty(copy, entry.key, copyToSandbox(entry.value, state, joinPath(path, entry.key), true, depth + 1));
+        }
+        return copy;
+    }
     if (isSandboxCollectionIterator(value)) {
         if (hasGuestObjectState(value))
             throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
@@ -890,6 +922,9 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     if (isSandboxCollectionIterator(value)) {
         throw new TypeError("Sandbox collection iterators cannot cross into host values.");
     }
+    if (isSandboxRegExpIterator(value)) {
+        throw new TypeError("Sandbox RegExp iterators cannot cross into host values.");
+    }
     if (isSandboxRegex(value)) {
         throw new TypeError("Invalid sandbox RegExp brand.");
     }

package/packages/safe-js/dist/snapshot/dump-format.js

@@ -1,5 +1,6 @@
 export const DUMP_FORMAT_VERSION = 1;
 import { getRegexProperties, isSandboxRegex } from "../interp/values.js";
+import { isSandboxRegExpIterator, regexpIteratorState } from "../interp/regexp-iterator.js";
 import { hasCustomRegexProperties, serializeRegexProperties } from "./regexp-properties.js";
 export const EXECUTION_SEMANTICS = "jobs-v8";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
@@ -81,7 +82,7 @@ function serializeDumpValue(value, path, state) {
     if (hasGuestObjectState(value)) {
         throw new TypeError("Guest function properties and prototype links cannot be serialized.");
     }
-    if ((isSandboxRegex(value) && hasCustomRegexProperties(value)) || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value))
+    if (isSandboxRegExpIterator(value) || (isSandboxRegex(value) && hasCustomRegexProperties(value)) || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value))
         return serializeHeapReference(value, path, state);
     if (Array.isArray(value)) {
         const reference = serializeHeapReference(value, path, state);
@@ -106,7 +107,29 @@ function serializeHeapReference(value, path, state) {
     }
     if (!state.serializedHeapIds.has(id)) {
         state.serializedHeapIds.add(id);
-        if (isSandboxRegex(value) && hasCustomRegexProperties(value)) {
+        if (isSandboxRegExpIterator(value)) {
+            const snapshot = regexpIteratorState(value);
+            const matcher = snapshot.matcher;
+            const entries = Object.create(null);
+            state.heap[String(id)] = {
+                kind: "regexp-iterator", exhausted: snapshot.exhausted,
+                matcher: matcher === undefined ? { kind: "undefined" } : { kind: "regex", source: matcher.source, flags: matcher.flags, lastIndex: Number(matcher.lastIndex) },
+                input: snapshot.input ?? { kind: "undefined" }, entries,
+                symbolEntries: serializeSymbolProperties(value, entry => {
+                    const serialized = serializeDumpValue(entry, `${path}.[symbol]`, state);
+                    if (serialized === SKIP_VALUE)
+                        throw new TypeError("Unsupported RegExp iterator symbol property in public dump.");
+                    return serialized;
+                })
+            };
+            for (const [key, entry] of getEnumerableDataEntries(value)) {
+                const serialized = serializeDumpValue(entry, `${path}.${key}`, state);
+                if (serialized === SKIP_VALUE)
+                    throw new TypeError("Unsupported RegExp iterator property in public dump.");
+                entries[key] = serialized;
+            }
+        }
+        else if (isSandboxRegex(value) && hasCustomRegexProperties(value)) {
             const encode = (entry) => {
                 const serialized = serializeDumpValue(entry, `${path}.<regex-property>`, state);
                 if (serialized === SKIP_VALUE)
@@ -206,6 +229,7 @@ function indexHeapContainers(snapshot) {
             stat.cyclic ||
             ownSerializableSymbolKeys(value).length > 0 ||
             isSandboxBox(value) ||
+            isSandboxRegExpIterator(value) ||
             (isSandboxRegex(value) && hasCustomRegexProperties(value)) ||
             isSandboxDate(value) ||
             isFloat32Array(value) ||

package/packages/safe-js/dist/snapshot/replay-data.d.ts

@@ -27,7 +27,15 @@ type Properties = Record<string, {
     enumerable: boolean;
     writable: boolean;
 }>;
-type DataNode = SerializedSymbol | {
+type DataNode = {
+    kind: "regexp-iterator";
+    matcher: Atom;
+    input: Atom;
+    exhausted: boolean;
+    properties: Properties;
+    extensible: boolean;
+    symbolEntries?: Array<SerializedSymbolProperty<Atom>>;
+} | SerializedSymbol | {
     kind: "boxed";
     value: Atom;
     properties: Properties;

package/packages/safe-js/dist/snapshot/replay-data.js

@@ -3,6 +3,7 @@ import { serializeRegexProperties, restoreRegexProperties } from "./regexp-prope
 import { wellKnownSymbols } from "../interp/symbols.js";
 import { symbolData, serializeSymbolProperties } from "./symbols.js";
 import { isSandboxCollectionIterator, restoreSandboxCollectionIterator, snapshotCollectionIterator } from "../interp/collection-iterator.js";
+import { isSandboxRegExpIterator, regexpIteratorState, restoreSandboxRegExpIterator } from "../interp/regexp-iterator.js";
 import { hasGuestObjectState } from "../interp/object-model.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 import { float32DataProperties, isFloat32Array } from "../interp/float32.js";
@@ -123,6 +124,18 @@ export function encodeReplayData(value, options = {}) {
             }
             nodes[id] = { ...storage, properties, extensible: Object.isExtensible(entry) };
         }
+        else if (isSandboxRegExpIterator(entry)) {
+            const snapshot = regexpIteratorState(entry);
+            const properties = Object.create(null);
+            for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(entry))) {
+                if (!("value" in descriptor))
+                    throw new TypeError(`Cannot record replay data accessor '${key}'.`);
+                properties[key] = { value: child(descriptor.value, JSON.stringify(["property", key])), configurable: descriptor.configurable === true, enumerable: descriptor.enumerable === true, writable: descriptor.writable === true };
+            }
+            let symbolIndex = 0;
+            const symbolEntries = serializeSymbolProperties(entry, value => encode(value, depth + 1, [...path, { symbol: Math.floor(symbolIndex++ / 2) }]));
+            nodes[id] = { kind: "regexp-iterator", matcher: child(snapshot.matcher, "<matcher>"), input: child(snapshot.input, "<input>"), exhausted: snapshot.exhausted, properties, extensible: Object.isExtensible(entry), symbolEntries };
+        }
         else if (isSandboxCollectionIterator(entry)) {
             const snapshot = snapshotCollectionIterator(entry);
             const properties = Object.create(null);
@@ -344,6 +357,24 @@ export function decodeReplayData(input, options = {}, parent) {
                     Object.preventExtensions(result);
                 return result;
             }
+            if (kind === "regexp-iterator") {
+                const exhausted = own(node, "exhausted");
+                if (typeof exhausted !== "boolean" || typeof node.extensible !== "boolean")
+                    throw new TypeError("Invalid replay RegExp iterator.");
+                const result = restoreSandboxRegExpIterator({ matcher: undefined, input: undefined, exhausted: true });
+                restored.set(id, result);
+                const matcher = child(own(node, "matcher"));
+                const input = child(own(node, "input"));
+                if (matcher !== undefined && !isSandboxRegex(matcher))
+                    throw new TypeError("Invalid replay RegExp iterator matcher.");
+                if (input !== undefined && typeof input !== "string")
+                    throw new TypeError("Invalid replay RegExp iterator input.");
+                restoreSandboxRegExpIterator({ matcher, input, exhausted }, result);
+                defineProperties(result, record(own(node, "properties")), child, node.symbolEntries);
+                if (!node.extensible)
+                    Object.preventExtensions(result);
+                return result;
+            }
             if (kind === "collection-iterator") {
                 const collectionKind = own(node, "collectionKind");
                 const method = own(node, "method");

package/packages/safe-js/dist/snapshot/replay-inputs.js

@@ -1,4 +1,5 @@
 import { collectionIteratorState, isSandboxCollectionIterator } from "../interp/collection-iterator.js";
+import { regexpIteratorState, isSandboxRegExpIterator } from "../interp/regexp-iterator.js";
 import { createSandboxPromise, isSandboxClosure, isSandboxMap, isSandboxSet, isSandboxPromise } from "../interp/values.js";
 import { decodeReplayData, encodeReplayData } from "./replay-data.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
@@ -59,6 +60,20 @@ export function prepareReplayInputs(current, saved, preparePromise, onCapability
                 value = descriptor.value;
                 continue;
             }
+            if (isSandboxRegExpIterator(value)) {
+                if (key === "<matcher>")
+                    value = regexpIteratorState(value).matcher;
+                else if (key === "<input>")
+                    value = regexpIteratorState(value).input;
+                else {
+                    const property = JSON.parse(key);
+                    if (!Array.isArray(property) || property.length !== 2 || property[0] !== "property" || typeof property[1] !== "string")
+                        throw new TypeError("Invalid replay input iterator capability path.");
+                    const descriptor = Object.getOwnPropertyDescriptor(value, property[1]);
+                    value = descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+                }
+                continue;
+            }
             if (isSandboxCollectionIterator(value)) {
                 if (key === "<collection>")
                     value = collectionIteratorState(value).collection;
@@ -135,6 +150,7 @@ function assertReplayInputShape(restored) {
         isSandboxClosure(restored) ||
         isSandboxPromise(restored) ||
         isSandboxCollectionIterator(restored) ||
+        isSandboxRegExpIterator(restored) ||
         isSandboxMap(restored) ||
         isSandboxSet(restored))
         throw new TypeError("Invalid replay inputs.");
@@ -146,6 +162,7 @@ function assertReplayInputShape(restored) {
             isSandboxClosure(values[key]) ||
             isSandboxPromise(values[key]) ||
             isSandboxCollectionIterator(values[key]) ||
+            isSandboxRegExpIterator(values[key]) ||
             isSandboxMap(values[key]) ||
             isSandboxSet(values[key]))
             throw new TypeError(`Invalid replay input ${key}.`);

package/packages/safe-js/dist/snapshot/restore.js

@@ -14,10 +14,11 @@ import { getGuestFunctionProperties, getGuestFunctionProperty, getSandboxDataPro
 import { functionSources } from "../parse/function-source.js";
 import { wrapCallerInjectedBindings } from "../interp/host-bridge.js";
 import { restoreSandboxCollectionIterator } from "../interp/collection-iterator.js";
+import { restoreSandboxRegExpIterator } from "../interp/regexp-iterator.js";
 import { wellKnownSymbols } from "../interp/symbols.js";
 import { restoreSymbolProperties } from "./symbols.js";
 import { restoreDateProperties } from "./date-properties.js";
-import { isSandboxMap, isSandboxSet } from "../interp/values.js";
+import { isSandboxMap, isSandboxSet, isSandboxRegex } from "../interp/values.js";
 import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxMap, createSandboxPromise, createSandboxRegex, createSandboxSet, reconcileCompiledValues } from "../interp/values.js";
 import { createGeneratorChannel, restoreGeneratorChannel } from "../interp/generator.js";
 import { hashSource } from "../parse/hash.js";
@@ -433,6 +434,21 @@ function restoreHeapValue(id, state) {
             Object.preventExtensions(args);
         return args;
     }
+    if (serialized.kind === "regexp-iterator") {
+        const iterator = restoreSandboxRegExpIterator({ matcher: undefined, input: undefined, exhausted: true });
+        state.heapValueById.set(id, iterator);
+        const matcher = deserializeValue(serialized.matcher, state);
+        const input = deserializeValue(serialized.input, state);
+        if (matcher !== undefined && !isSandboxRegex(matcher))
+            throw new TypeError("Invalid RegExp iterator matcher.");
+        if (input !== undefined && typeof input !== "string")
+            throw new TypeError("Invalid RegExp iterator input.");
+        restoreSandboxRegExpIterator({ matcher, input, exhausted: serialized.exhausted }, iterator);
+        for (const [key, entry] of Object.entries(serialized.entries))
+            Object.defineProperty(iterator, key, { value: deserializeValue(entry, state), enumerable: true, configurable: true, writable: true });
+        restoreSymbolProperties(iterator, serialized.symbolEntries, entry => deserializeValue(entry, state));
+        return iterator;
+    }
     if (serialized.kind === "collection-iterator") {
         const iterator = restoreSandboxCollectionIterator({ collection: undefined, collectionKind: serialized.collectionKind, method: serialized.method, index: 0, exhausted: true });
         state.heapValueById.set(id, iterator);

package/packages/safe-js/dist/snapshot/serialize.d.ts

@@ -1,6 +1,7 @@
 import { type RegexPropertyData } from "./regexp-properties.js";
 import { type SerializedSymbol, type SerializedSymbolProperty } from "./symbols.js";
 import { type CollectionIterationMethod, type SandboxCollectionIterator } from "../interp/collection-iterator.js";
+import { type SandboxRegExpIterator } from "../interp/regexp-iterator.js";
 import { type SandboxErrorName } from "../error/shape.js";
 import { type SerializedArguments } from "./arguments.js";
 import { type SerializedArray } from "./arrays.js";
@@ -48,7 +49,14 @@ export type SerializedReferenceValue = {
     kind: "ref";
     id: number;
 };
-export type SerializedHeapValue = SerializedSymbol | BoxedData<SerializedSnapshotValue> | ({
+export type SerializedHeapValue = {
+    kind: "regexp-iterator";
+    matcher: SerializedSnapshotValue;
+    input: SerializedSnapshotValue;
+    exhausted: boolean;
+    entries: Record<string, SerializedSnapshotValue>;
+    symbolEntries?: Array<SerializedSymbolProperty<SerializedSnapshotValue>>;
+} | SerializedSymbol | BoxedData<SerializedSnapshotValue> | ({
     kind: "regex-object";
     source: string;
     flags: string;
@@ -94,7 +102,7 @@ export type RuntimePromiseValue = {
     id: SnapshotId;
     promise?: Promise<unknown>;
 };
-export type RuntimeSnapshotValue = symbol | SandboxBox | Date | Float32Array | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxGenerator | SandboxCollectionIterator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
+export type RuntimeSnapshotValue = symbol | SandboxBox | Date | Float32Array | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxGenerator | SandboxCollectionIterator | SandboxRegExpIterator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
     [key: string]: RuntimeSnapshotValue;
 };
 export type RuntimeScopeFrame = {

package/packages/safe-js/dist/snapshot/serialize.js

@@ -2,6 +2,7 @@ import { hashSource } from "../parse/hash.js";
 import { hasCustomRegexProperties, serializeRegexProperties } from "./regexp-properties.js";
 import { ownSerializableSymbolKeys, serializeSymbol, serializeSymbolProperties } from "./symbols.js";
 import { collectionIteratorState, isSandboxCollectionIterator, snapshotCollectionIterator } from "../interp/collection-iterator.js";
+import { isSandboxRegExpIterator, regexpIteratorState } from "../interp/regexp-iterator.js";
 import { hasGuestObjectState } from "../interp/object-model.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
@@ -180,7 +181,7 @@ function serializeValue(value, path, state) {
             throw new TypeError(`Missing regex heap reference at ${path}.`);
         return { kind: "regex", source: value.source, flags: value.flags, lastIndex: value.lastIndex };
     }
-    if (isSandboxBox(value) || isSandboxDate(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isFloat32Array(value)) {
+    if (isSandboxBox(value) || isSandboxDate(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxRegExpIterator(value) || isSandboxCollectionIterator(value) || isFloat32Array(value)) {
         const reference = serializeHeapReference(value, path, state);
         if (reference === undefined) {
             throw new TypeError(`Cannot serialize collection without a heap reference at ${path}.`);
@@ -214,6 +215,17 @@ function serializeHeapReference(value, path, state) {
                 lastIndex: serializeValue(value.lastIndex, `${path}.lastIndex`, state),
                 ...serializeRegexProperties(value, entry => serializeValue(entry, `${path}.<regex-property>`, state)) };
         }
+        else if (isSandboxRegExpIterator(value)) {
+            const snapshot = regexpIteratorState(value);
+            const entries = Object.create(null);
+            state.heap[String(id)] = {
+                kind: "regexp-iterator", matcher: serializeValue(snapshot.matcher, `${path}.<matcher>`, state),
+                input: serializeValue(snapshot.input, `${path}.<input>`, state), exhausted: snapshot.exhausted, entries,
+                symbolEntries: serializeSymbolProperties(value, entry => serializeValue(entry, `${path}.[symbol]`, state))
+            };
+            for (const [key, entry] of Object.entries(value))
+                entries[key] = serializeValue(entry, `${path}.${key}`, state);
+        }
         else if (isSandboxCollectionIterator(value)) {
             const snapshot = snapshotCollectionIterator(value);
             const entries = Object.create(null);
@@ -357,6 +369,7 @@ function indexHeapContainers(input) {
             sandboxErrorTypes.has(value) ||
             isSandboxArguments(value) ||
             isSandboxCollectionIterator(value) ||
+            isSandboxRegExpIterator(value) ||
             isSandboxMap(value) ||
             isSandboxSet(value)) {
             heapIds.set(value, nextId);
@@ -379,6 +392,7 @@ function collectContainerStats(value, stats, ancestors) {
         !isFloat32Array(value) &&
         !isSandboxMap(value) &&
         !isSandboxCollectionIterator(value) &&
+        !isSandboxRegExpIterator(value) &&
         !isSandboxSet(value)) {
         return;
     }
@@ -410,15 +424,17 @@ function collectContainerStats(value, stats, ancestors) {
             ? dateDataProperties(value).flatMap(([key, descriptor]) => typeof key === "string" ? [descriptor.value] : [])
             : isSandboxBox(value)
                 ? boxedDataProperties(value).map(([, descriptor]) => descriptor.value)
-                : isSandboxCollectionIterator(value)
-                    ? [collectionIteratorState(value).collection, ...Object.values(value)]
-                    : isSandboxArguments(value)
-                        ? Object.values(Object.getOwnPropertyDescriptors(value)).flatMap((descriptor) => "value" in descriptor ? [descriptor.value] : [])
-                        : isSandboxMap(value)
-                            ? [...value.entries].flatMap(([key, entry]) => [key, entry])
-                            : isSandboxSet(value)
-                                ? [...value.values]
-                                : Object.values(value);
+                : isSandboxRegExpIterator(value)
+                    ? [regexpIteratorState(value).matcher, regexpIteratorState(value).input, ...Object.values(value)]
+                    : isSandboxCollectionIterator(value)
+                        ? [collectionIteratorState(value).collection, ...Object.values(value)]
+                        : isSandboxArguments(value)
+                            ? Object.values(Object.getOwnPropertyDescriptors(value)).flatMap((descriptor) => "value" in descriptor ? [descriptor.value] : [])
+                            : isSandboxMap(value)
+                                ? [...value.entries].flatMap(([key, entry]) => [key, entry])
+                                : isSandboxSet(value)
+                                    ? [...value.values]
+                                    : Object.values(value);
     for (const entry of entries) {
         collectContainerStats(entry, stats, ancestors);
     }