poe-code 14.0.72 → 14.0.73

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

@@ -1,4 +1,6 @@
 export const DUMP_FORMAT_VERSION = 1;
+import { getRegexProperties, isSandboxRegex } from "../interp/values.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";
@@ -79,7 +81,7 @@ function serializeDumpValue(value, path, state) {
     if (hasGuestObjectState(value)) {
         throw new TypeError("Guest function properties and prototype links cannot be serialized.");
     }
-    if (isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value))
+    if ((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);
@@ -104,7 +106,17 @@ function serializeHeapReference(value, path, state) {
     }
     if (!state.serializedHeapIds.has(id)) {
         state.serializedHeapIds.add(id);
-        if (isSandboxBox(value)) {
+        if (isSandboxRegex(value) && hasCustomRegexProperties(value)) {
+            const encode = (entry) => {
+                const serialized = serializeDumpValue(entry, `${path}.<regex-property>`, state);
+                if (serialized === SKIP_VALUE)
+                    throw new TypeError("Unsupported RegExp property in public dump.");
+                return serialized;
+            };
+            state.heap[String(id)] = { kind: "regex-object", source: value.source, flags: value.flags,
+                lastIndex: encode(value.lastIndex), ...serializeRegexProperties(value, encode) };
+        }
+        else if (isSandboxBox(value)) {
             state.heap[String(id)] = encodeBoxedData(value, (entry, key) => {
                 if (Object.is(entry, -0))
                     return { kind: "number", value: "-0" };
@@ -194,6 +206,7 @@ function indexHeapContainers(snapshot) {
             stat.cyclic ||
             ownSerializableSymbolKeys(value).length > 0 ||
             isSandboxBox(value) ||
+            (isSandboxRegex(value) && hasCustomRegexProperties(value)) ||
             isSandboxDate(value) ||
             isFloat32Array(value) ||
             (Array.isArray(value) && requiresArrayEntries(value)) ||
@@ -231,13 +244,18 @@ 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)
-            : isSandboxArguments(value)
-                ? getSandboxArgumentEntries(value).map(([, entry]) => entry)
-                : getEnumerableDataValues(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)
+                : isSandboxArguments(value)
+                    ? getSandboxArgumentEntries(value).map(([, entry]) => entry)
+                    : getEnumerableDataValues(value);
     for (const entry of entries) {
         collectContainerStats(entry, stats, ancestors);
     }

package/packages/safe-js/dist/snapshot/regexp-properties.d.ts

@@ -0,0 +1,18 @@
+import { type SandboxRegex } from "../interp/values.js";
+import { type SerializedSymbolProperty } from "./symbols.js";
+type DataProperty<T> = {
+    value: T;
+    enumerable: boolean;
+    writable: boolean;
+    configurable: boolean;
+};
+export type RegexPropertyData<T> = {
+    properties?: Record<string, DataProperty<T>>;
+    symbolEntries?: Array<SerializedSymbolProperty<T>>;
+    extensible?: boolean;
+};
+export declare function hasCustomRegexProperties(value: SandboxRegex): boolean;
+export declare function serializeRegexProperties<T>(value: SandboxRegex, encode: (entry: unknown) => T): RegexPropertyData<T>;
+export declare function validateRegexProperties(data: RegexPropertyData<unknown>): void;
+export declare function restoreRegexProperties<T>(value: SandboxRegex, data: RegexPropertyData<T>, decode: (entry: T) => unknown): void;
+export {};

package/packages/safe-js/dist/snapshot/regexp-properties.js

@@ -0,0 +1,58 @@
+import { getRegexProperties } from "../interp/values.js";
+import { restoreSymbolProperties, serializeSymbolProperties } from "./symbols.js";
+export function hasCustomRegexProperties(value) {
+    const properties = getRegexProperties(value);
+    return Reflect.ownKeys(properties).length !== 1 || !Object.isExtensible(properties) ||
+        Object.getOwnPropertyDescriptor(properties, "lastIndex")?.writable !== true;
+}
+export function serializeRegexProperties(value, encode) {
+    if (!hasCustomRegexProperties(value))
+        return {};
+    const source = getRegexProperties(value);
+    const properties = Object.create(null);
+    for (const key of Object.getOwnPropertyNames(source)) {
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (!("value" in descriptor))
+            throw new TypeError("RegExp accessor properties cannot be serialized as data.");
+        properties[key] = { value: encode(descriptor.value), enumerable: descriptor.enumerable === true,
+            configurable: descriptor.configurable === true, writable: descriptor.writable === true };
+    }
+    const symbolEntries = serializeSymbolProperties(source, encode);
+    return { properties, ...(symbolEntries.length === 0 ? {} : { symbolEntries }),
+        ...(Object.isExtensible(source) ? {} : { extensible: false }) };
+}
+export function validateRegexProperties(data) {
+    const descriptor = (value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value) ||
+            !Object.hasOwn(value, "value") ||
+            !["enumerable", "configurable", "writable"].every(key => Object.hasOwn(value, key) && typeof value[key] === "boolean") ||
+            Object.keys(value).some(key => !["value", "enumerable", "configurable", "writable"].includes(key)))
+            throw new TypeError("Invalid RegExp data property descriptor.");
+    };
+    if (data.extensible !== undefined && typeof data.extensible !== "boolean")
+        throw new TypeError("Invalid RegExp extensibility.");
+    if (data.properties !== undefined) {
+        if (typeof data.properties !== "object" || data.properties === null || Array.isArray(data.properties))
+            throw new TypeError("Invalid RegExp property data.");
+        for (const entry of Object.values(data.properties))
+            descriptor(entry);
+    }
+    if (data.symbolEntries !== undefined) {
+        if (!Array.isArray(data.symbolEntries))
+            throw new TypeError("Invalid RegExp symbol properties.");
+        for (const entry of data.symbolEntries) {
+            if (!Array.isArray(entry) || entry.length !== 2)
+                throw new TypeError("Invalid RegExp symbol property.");
+            descriptor(entry[1]);
+        }
+    }
+}
+export function restoreRegexProperties(value, data, decode) {
+    validateRegexProperties(data);
+    const properties = getRegexProperties(value);
+    for (const [key, descriptor] of Object.entries(data.properties ?? {}))
+        Object.defineProperty(properties, key, { ...descriptor, value: decode(descriptor.value) });
+    restoreSymbolProperties(properties, data.symbolEntries, decode);
+    if (data.extensible === false)
+        Object.preventExtensions(properties);
+}

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";
@@ -70,12 +71,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,4 +1,5 @@
 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";
@@ -152,7 +153,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)) {
@@ -387,6 +389,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/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";
@@ -377,6 +378,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") {

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

@@ -1,3 +1,4 @@
+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 SandboxErrorName } from "../error/shape.js";
@@ -47,12 +48,12 @@ export type SerializedReferenceValue = {
     kind: "ref";
     id: number;
 };
-export type SerializedHeapValue = SerializedSymbol | BoxedData<SerializedSnapshotValue> | {
+export type SerializedHeapValue = SerializedSymbol | BoxedData<SerializedSnapshotValue> | ({
     kind: "regex-object";
     source: string;
     flags: string;
     lastIndex: SerializedSnapshotValue;
-} | {
+} & RegexPropertyData<SerializedSnapshotValue>) | {
     kind: "collection-iterator";
     collectionKind: "map" | "set";
     method: CollectionIterationMethod;

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

@@ -1,4 +1,5 @@
 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";
@@ -12,7 +13,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) {
@@ -210,7 +211,8 @@ 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 (isSandboxCollectionIterator(value)) {
             const snapshot = snapshotCollectionIterator(value);
@@ -346,7 +348,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) ||
@@ -399,19 +401,24 @@ 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)
+                : 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,10 @@ function validateDumpHeap(root, state) {
         const entry = requireRecord(value, path);
         validateErrorType(entry, path);
         validateSymbolEntries(entry, path, state, heap);
+        if (entry.kind === "regex-object") {
+            validateTaggedValue(entry, path, state);
+            continue;
+        }
         if (entry.kind === "boxed") {
             validateBoxedRecord(entry, path, heap);
             continue;
@@ -376,6 +381,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":
@@ -473,7 +484,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")
         fail("invalidValue", `${path}.symbolEntries`, "symbol properties are unsupported for this heap kind");
     const entries = requireArray(record.symbolEntries, `${path}.symbolEntries`, state);
     const keys = new Set();