poe-code 14.0.73 → 14.0.75

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

@@ -0,0 +1,23 @@
+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.global !== undefined || state.unicode !== undefined) &&
+        (typeof state.global !== "boolean" || typeof state.unicode !== "boolean"))
+        throw new TypeError("Invalid RegExp iterator modes.");
+    if (state.matcher !== undefined && (state.matcher === null || typeof state.matcher !== "object"))
+        throw new TypeError("Invalid RegExp iterator matcher.");
+    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
+        ? { ...state, 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";
@@ -18,7 +19,7 @@ import { invokeCancelableClosure, readPromiseCancellation, registerPromiseCancel
 import { parseRegex } from "./regex/parse.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { sandboxErrorTypes } from "../error/shape.js";
-import { getGuestFunctionProperties, getSandboxPrototype, hasGuestObjectState, hasManagedDescriptors, isGuestClosure, isIntrinsicConstructor, registerGuestClosure } from "./object-model.js";
+import { getGuestFunctionProperties, getSandboxPrototype, hasGuestObjectState, hasManagedDescriptors, hasNullObjectPrototype, isGuestClosure, isIntrinsicConstructor, registerGuestClosure, setSandboxPrototype } from "./object-model.js";
 import { copySandboxArgumentProperties, createSandboxArguments, getSandboxArgumentEntries, isSandboxArguments } from "./arguments.js";
 export { createSandboxArguments, isSandboxArguments } from "./arguments.js";
 export { isSandboxMap, isSandboxSet } from "./collection-brands.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 && (snapshot.global === undefined ? !isSandboxRegex(matcher) : matcher === null || typeof matcher !== "object"))
+            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.");
@@ -749,6 +781,8 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
             return existing;
         }
         const copy = createPlainObject(!cloneSandboxCollections || Object.getPrototypeOf(value) === null);
+        if (!state.structuredClone && hasNullObjectPrototype(value))
+            setSandboxPrototype(copy, null);
         state.seen.set(value, copy);
         const errorType = sandboxErrorTypes.get(value);
         if (errorType !== undefined)
@@ -890,6 +924,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.");
     }
@@ -943,7 +980,7 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
         if (existing !== undefined) {
             return existing;
         }
-        const copy = createPlainObject(Object.getPrototypeOf(value) === null);
+        const copy = createPlainObject(hasNullObjectPrototype(value) || Object.getPrototypeOf(value) === null);
         state.seen.set(value, copy);
         for (const entry of getEnumerableObjectEntries(value, path)) {
             defineOwnDataProperty(copy, entry.key, copyFromSandbox(entry.value, state, joinPath(path, entry.key), options, depth + 1));

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

@@ -1,9 +1,10 @@
 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";
-import { hasGuestObjectState } from "../interp/object-model.js";
+import { hasGuestObjectState, hasNullObjectPrototype } from "../interp/object-model.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "../interp/arguments.js";
 import { serializeArguments } from "./arguments.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,35 @@ 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 serializedMatcher = snapshot.global === undefined && isSandboxRegex(matcher)
+                ? { kind: "regex", source: matcher.source, flags: matcher.flags, lastIndex: Number(matcher.lastIndex) }
+                : serializeDumpValue(matcher, `${path}.<matcher>`, state);
+            if (serializedMatcher === SKIP_VALUE)
+                throw new TypeError("Unsupported RegExp iterator matcher in public dump.");
+            const entries = Object.create(null);
+            state.heap[String(id)] = {
+                kind: "regexp-iterator", exhausted: snapshot.exhausted,
+                matcher: serializedMatcher,
+                ...(snapshot.global === undefined ? {} : { global: snapshot.global, unicode: snapshot.unicode }),
+                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)
@@ -169,6 +198,7 @@ function serializeHeapReference(value, path, state) {
             });
             state.heap[String(id)] = {
                 kind: "object",
+                ...(hasNullObjectPrototype(value) ? { sandboxNullPrototype: true } : {}),
                 entries: serializeObjectEntries(value, path, state),
                 ...(symbolEntries.length === 0 ? {} : { symbolEntries }),
                 ...(errorType === undefined ? {} : { errorType })
@@ -204,8 +234,10 @@ function indexHeapContainers(snapshot) {
     for (const [value, stat] of stats.entries()) {
         if (stat.count > 1 ||
             stat.cyclic ||
+            hasNullObjectPrototype(value) ||
             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,17 @@ type Properties = Record<string, {
     enumerable: boolean;
     writable: boolean;
 }>;
-type DataNode = SerializedSymbol | {
+type DataNode = {
+    kind: "regexp-iterator";
+    matcher: Atom;
+    input: Atom;
+    exhausted: boolean;
+    global?: boolean;
+    unicode?: boolean;
+    properties: Properties;
+    extensible: boolean;
+    symbolEntries?: Array<SerializedSymbolProperty<Atom>>;
+} | SerializedSymbol | {
     kind: "boxed";
     value: Atom;
     properties: Properties;
@@ -61,6 +71,7 @@ type DataNode = SerializedSymbol | {
     symbolProperties?: Array<SerializedSymbolProperty<Atom>>;
     extensible: boolean;
     nullPrototype: boolean;
+    sandboxNullPrototype?: true;
     errorType?: SandboxErrorName;
 } | {
     kind: "arguments";

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

@@ -3,7 +3,8 @@ 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 { hasGuestObjectState } from "../interp/object-model.js";
+import { isSandboxRegExpIterator, regexpIteratorState, restoreSandboxRegExpIterator } from "../interp/regexp-iterator.js";
+import { hasGuestObjectState, hasNullObjectPrototype, setSandboxPrototype } from "../interp/object-model.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 import { float32DataProperties, isFloat32Array } from "../interp/float32.js";
 import { decodeFloat32Storage, encodeFloat32Storage } from "./float32array.js";
@@ -123,6 +124,19 @@ 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,
+                ...(snapshot.global === undefined ? {} : { global: snapshot.global, unicode: snapshot.unicode }) };
+        }
         else if (isSandboxCollectionIterator(entry)) {
             const snapshot = snapshotCollectionIterator(entry);
             const properties = Object.create(null);
@@ -182,6 +196,7 @@ export function encodeReplayData(value, options = {}) {
             nodes[id] = {
                 kind: Array.isArray(entry) ? "array" : "object",
                 nullPrototype: prototype === null,
+                ...(hasNullObjectPrototype(entry) ? { sandboxNullPrototype: true } : {}),
                 ...(errorType === undefined ? {} : { errorType }),
                 extensible: Object.isExtensible(entry),
                 properties,
@@ -344,6 +359,27 @@ 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 ((node.global !== undefined || node.unicode !== undefined) && (typeof node.global !== "boolean" || typeof node.unicode !== "boolean"))
+                    throw new TypeError("Invalid replay RegExp iterator modes.");
+                if (matcher !== undefined && (node.global === undefined ? !isSandboxRegex(matcher) : matcher === null || typeof matcher !== "object"))
+                    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,
+                    ...(node.global === undefined ? {} : { global: node.global, unicode: node.unicode }) }, 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");
@@ -419,6 +455,11 @@ export function decodeReplayData(input, options = {}, parent) {
                 throw new TypeError("Invalid replay object metadata.");
             }
             const result = kind === "array" ? [] : Object.create(node.nullPrototype ? null : Object.prototype);
+            if (Object.hasOwn(node, "sandboxNullPrototype")) {
+                if (kind !== "object" || node.sandboxNullPrototype !== true)
+                    throw new TypeError("Invalid replay object prototype.");
+                setSandboxPrototype(result, null);
+            }
             if (Object.hasOwn(node, "errorType")) {
                 sandboxErrorTypes.set(result, node.errorType);
             }

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,22 @@ 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 && (serialized.global === undefined ? !isSandboxRegex(matcher) : matcher === null || typeof matcher !== "object"))
+            throw new TypeError("Invalid RegExp iterator matcher.");
+        if (input !== undefined && typeof input !== "string")
+            throw new TypeError("Invalid RegExp iterator input.");
+        restoreSandboxRegExpIterator({ matcher: matcher, input, exhausted: serialized.exhausted,
+            ...(serialized.global === undefined ? {} : { global: serialized.global, unicode: serialized.unicode }) }, 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);
@@ -462,6 +479,11 @@ function restoreHeapValue(id, state) {
     }
     const object = Object.create(null);
     state.heapValueById.set(id, object);
+    if (Object.hasOwn(serialized, "sandboxNullPrototype")) {
+        if (serialized.sandboxNullPrototype !== true)
+            throw new TypeError("Invalid object prototype.");
+        setSandboxPrototype(object, null);
+    }
     if (serialized.errorType !== undefined)
         sandboxErrorTypes.set(object, serialized.errorType);
     for (const [key, entry] of Object.entries(serialized.entries)) {

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,16 @@ 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;
+    global?: boolean;
+    unicode?: boolean;
+    entries: Record<string, SerializedSnapshotValue>;
+    symbolEntries?: Array<SerializedSymbolProperty<SerializedSnapshotValue>>;
+} | SerializedSymbol | BoxedData<SerializedSnapshotValue> | ({
     kind: "regex-object";
     source: string;
     flags: string;
@@ -65,6 +75,7 @@ export type SerializedHeapValue = SerializedSymbol | BoxedData<SerializedSnapsho
     entries: Record<string, SerializedSnapshotValue>;
 }) | SerializedArguments<SerializedSnapshotValue> | SerializedArray<SerializedSnapshotValue> | {
     kind: "object";
+    sandboxNullPrototype?: true;
     entries: Record<string, SerializedSnapshotValue>;
     symbolEntries?: Array<SerializedSymbolProperty<SerializedSnapshotValue>>;
     errorType?: SandboxErrorName;
@@ -94,7 +105,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,7 +2,8 @@ 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 { hasGuestObjectState } from "../interp/object-model.js";
+import { isSandboxRegExpIterator, regexpIteratorState } from "../interp/regexp-iterator.js";
+import { hasGuestObjectState, hasNullObjectPrototype } from "../interp/object-model.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
 import { serializeArguments } from "./arguments.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,18 @@ 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),
+                ...(snapshot.global === undefined ? {} : { global: snapshot.global, unicode: snapshot.unicode }),
+                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);
@@ -271,6 +284,7 @@ function serializeHeapReference(value, path, state) {
             const errorType = sandboxErrorTypes.get(value);
             const serializedObject = {
                 kind: "object",
+                ...(hasNullObjectPrototype(value) ? { sandboxNullPrototype: true } : {}),
                 entries,
                 ...(errorType === undefined ? {} : { errorType })
             };
@@ -347,6 +361,7 @@ function indexHeapContainers(input) {
     for (const [value, stat] of stats.entries()) {
         if (stat.count > 1 ||
             stat.cyclic ||
+            hasNullObjectPrototype(value) ||
             ownSerializableSymbolKeys(value).length > 0 ||
             (isSandboxRegex(value) && (hasCustomRegexProperties(value) || !Number.isSafeInteger(value.lastIndex) ||
                 (typeof value.lastIndex === "number" && value.lastIndex < 0) || Object.is(value.lastIndex, -0))) ||
@@ -357,6 +372,7 @@ function indexHeapContainers(input) {
             sandboxErrorTypes.has(value) ||
             isSandboxArguments(value) ||
             isSandboxCollectionIterator(value) ||
+            isSandboxRegExpIterator(value) ||
             isSandboxMap(value) ||
             isSandboxSet(value)) {
             heapIds.set(value, nextId);
@@ -379,6 +395,7 @@ function collectContainerStats(value, stats, ancestors) {
         !isFloat32Array(value) &&
         !isSandboxMap(value) &&
         !isSandboxCollectionIterator(value) &&
+        !isSandboxRegExpIterator(value) &&
         !isSandboxSet(value)) {
         return;
     }
@@ -410,15 +427,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);
     }