poe-code 14.0.72 → 14.0.74

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

@@ -1,3 +1,4 @@
+import { type RegexPropertyData } from "./regexp-properties.js";
 import { type SerializedSymbol, type SerializedSymbolProperty } from "./symbols.js";
 import { type CollectionIterationMethod } from "../interp/collection-iterator.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
@@ -26,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;
@@ -70,12 +79,12 @@ type DataNode = SerializedSymbol | {
 } | {
     kind: "set";
     values: Atom[];
-} | {
+} | ({
     kind: "regex";
     source: string;
     flags: string;
     lastIndex: Atom;
-};
+} & RegexPropertyData<Atom>);
 export type ReplayData = {
     root: Atom;
     nodes: DataNode[];

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

@@ -1,7 +1,9 @@
 import { MAX_DATA_DEPTH } from "../graph-depth.js";
+import { serializeRegexProperties, restoreRegexProperties } from "./regexp-properties.js";
 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";
@@ -122,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);
@@ -152,7 +166,8 @@ export function encodeReplayData(value, options = {}) {
                 kind: "regex",
                 source: entry.source,
                 flags: entry.flags,
-                lastIndex: child(entry.lastIndex, "lastIndex")
+                lastIndex: child(entry.lastIndex, "lastIndex"),
+                ...serializeRegexProperties(entry, value => child(value, "<regex-property>"))
             };
         }
         else if (isSandboxArguments(entry)) {
@@ -342,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");
@@ -387,6 +420,7 @@ export function decodeReplayData(input, options = {}, parent) {
                 const result = createSandboxRegex(node.source, node.flags, 0, compilation);
                 restored.set(id, result);
                 result.lastIndex = child(own(node, "lastIndex"));
+                restoreRegexProperties(result, node, child);
                 return result;
             }
             if (kind === "arguments") {

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

@@ -1,4 +1,5 @@
 import { Budget, SandboxError } from "../interp/budget.js";
+import { restoreRegexProperties } from "./regexp-properties.js";
 import { executeAsyncFunction } from "../interp/async.js";
 import { toPropertyKey } from "../interp/property-key.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
@@ -13,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";
@@ -377,6 +379,7 @@ function restoreHeapValue(id, state) {
         const value = createSandboxRegex(serialized.source, serialized.flags, 0, state.compilation);
         state.heapValueById.set(id, value);
         value.lastIndex = deserializeValue(serialized.lastIndex, state);
+        restoreRegexProperties(value, serialized, entry => deserializeValue(entry, state));
         return value;
     }
     if (serialized.kind === "float32array") {
@@ -431,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,5 +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";
@@ -47,12 +49,19 @@ 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;
     lastIndex: SerializedSnapshotValue;
-} | {
+} & RegexPropertyData<SerializedSnapshotValue>) | {
     kind: "collection-iterator";
     collectionKind: "map" | "set";
     method: CollectionIterationMethod;
@@ -93,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

@@ -1,6 +1,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 { 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";
@@ -12,7 +14,7 @@ import { dateDataProperties, isSandboxDate } from "../interp/date.js";
 import { serializeDate } from "./date-properties.js";
 import { boxedDataProperties, isSandboxBox } from "../interp/boxed.js";
 import { encodeBoxedData } from "./boxed.js";
-import { isSandboxArguments, isSandboxGenerator, isSandboxMap, isSandboxRegex, isSandboxSet } from "../interp/values.js";
+import { isSandboxArguments, isSandboxGenerator, isSandboxMap, isSandboxRegex, getRegexProperties, isSandboxSet } from "../interp/values.js";
 export class UnsnapshotableValueError extends Error {
     path;
     constructor(path) {
@@ -179,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}.`);
@@ -210,7 +212,19 @@ function serializeHeapReference(value, path, state) {
         state.serializedHeapIds.add(id);
         if (isSandboxRegex(value)) {
             state.heap[String(id)] = { kind: "regex-object", source: value.source, flags: value.flags,
-                lastIndex: serializeValue(value.lastIndex, `${path}.lastIndex`, 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);
@@ -346,7 +360,7 @@ function indexHeapContainers(input) {
         if (stat.count > 1 ||
             stat.cyclic ||
             ownSerializableSymbolKeys(value).length > 0 ||
-            (isSandboxRegex(value) && (!Number.isSafeInteger(value.lastIndex) ||
+            (isSandboxRegex(value) && (hasCustomRegexProperties(value) || !Number.isSafeInteger(value.lastIndex) ||
                 (typeof value.lastIndex === "number" && value.lastIndex < 0) || Object.is(value.lastIndex, -0))) ||
             isSandboxBox(value) ||
             isSandboxDate(value) ||
@@ -355,6 +369,7 @@ function indexHeapContainers(input) {
             sandboxErrorTypes.has(value) ||
             isSandboxArguments(value) ||
             isSandboxCollectionIterator(value) ||
+            isSandboxRegExpIterator(value) ||
             isSandboxMap(value) ||
             isSandboxSet(value)) {
             heapIds.set(value, nextId);
@@ -377,6 +392,7 @@ function collectContainerStats(value, stats, ancestors) {
         !isFloat32Array(value) &&
         !isSandboxMap(value) &&
         !isSandboxCollectionIterator(value) &&
+        !isSandboxRegExpIterator(value) &&
         !isSandboxSet(value)) {
         return;
     }
@@ -399,19 +415,26 @@ function collectContainerStats(value, stats, ancestors) {
     }
     stat.expanded = true;
     ancestors.add(value);
-    const entries = isSandboxDate(value)
-        ? 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);
+    const entries = isSandboxRegex(value)
+        ? Reflect.ownKeys(getRegexProperties(value)).flatMap(key => {
+            const descriptor = Object.getOwnPropertyDescriptor(getRegexProperties(value), key);
+            return "value" in descriptor ? [descriptor.value] : [];
+        })
+        : isSandboxDate(value)
+            ? dateDataProperties(value).flatMap(([key, descriptor]) => typeof key === "string" ? [descriptor.value] : [])
+            : isSandboxBox(value)
+                ? boxedDataProperties(value).map(([, descriptor]) => descriptor.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);
     }

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

@@ -1,4 +1,5 @@
 import { replaceErrorStack, sandboxErrorNames } from "../error/shape.js";
+import { validateRegexProperties } from "./regexp-properties.js";
 import { wellKnownSymbols } from "../interp/symbols.js";
 import { types } from "node:util";
 import { DUMP_FORMAT_VERSION } from "./dump-format.js";
@@ -84,6 +85,14 @@ function validateDumpHeap(root, state) {
         const entry = requireRecord(value, path);
         validateErrorType(entry, path);
         validateSymbolEntries(entry, path, state, heap);
+        if (entry.kind === "regexp-iterator") {
+            validateHeapValue(entry, path, state, heap);
+            continue;
+        }
+        if (entry.kind === "regex-object") {
+            validateTaggedValue(entry, path, state);
+            continue;
+        }
         if (entry.kind === "boxed") {
             validateBoxedRecord(entry, path, heap);
             continue;
@@ -376,6 +385,12 @@ function validateTaggedValue(record, path, state) {
             requireString(record.flags, `${path}.flags`, state.limits);
             if (!Object.hasOwn(record, "lastIndex"))
                 fail("invalidValue", `${path}.lastIndex`, "missing regex cursor");
+            try {
+                validateRegexProperties(record);
+            }
+            catch {
+                fail("invalidValue", path, "invalid RegExp property data");
+            }
             return;
         case "array":
         case "arguments":
@@ -383,6 +398,7 @@ function validateTaggedValue(record, path, state) {
         case "map":
         case "set":
         case "collection-iterator":
+        case "regexp-iterator":
             return;
     }
 }
@@ -429,7 +445,7 @@ function validateGeneratorShape(record, path, state) {
 function validateHeapValue(value, path, state, heap) {
     const record = requireRecord(value, path);
     validateErrorType(record, path);
-    if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "date", "boxed", "collection-iterator", "regex-object"].includes(String(record.kind)))
+    if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "date", "boxed", "collection-iterator", "regexp-iterator", "regex-object"].includes(String(record.kind)))
         fail("unknownTag", `${path}.kind`, "unknown heap tag");
     validateValue(record, path, 1, state);
     if (record.kind === "symbol")
@@ -457,6 +473,13 @@ function validateHeapValue(value, path, state, heap) {
     }
     if (record.kind === "set")
         requireArray(record.values, `${path}.values`, state);
+    if (record.kind === "regexp-iterator") {
+        if (typeof record.exhausted !== "boolean")
+            fail("invalidValue", `${path}.exhausted`, "invalid iterator exhaustion");
+        if (!Object.hasOwn(record, "matcher") || !Object.hasOwn(record, "input"))
+            fail("invalidValue", path, "missing RegExp iterator state");
+        requireRecord(record.entries, `${path}.entries`);
+    }
     if (record.kind === "collection-iterator") {
         if (record.collectionKind !== "map" && record.collectionKind !== "set")
             fail("invalidValue", `${path}.collectionKind`, "invalid iterator brand");
@@ -473,7 +496,7 @@ function validateHeapValue(value, path, state, heap) {
 function validateSymbolEntries(record, path, state, heap) {
     if (record.symbolEntries === undefined)
         return;
-    if (record.kind !== "object" && record.kind !== "array" && record.kind !== "date" && record.kind !== "boxed")
+    if (record.kind !== "object" && record.kind !== "array" && record.kind !== "date" && record.kind !== "boxed" && record.kind !== "regex-object" && record.kind !== "regexp-iterator")
         fail("invalidValue", `${path}.symbolEntries`, "symbol properties are unsupported for this heap kind");
     const entries = requireArray(record.symbolEntries, `${path}.symbolEntries`, state);
     const keys = new Set();