poe-code 14.0.65 → 14.0.66

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

@@ -1,4 +1,5 @@
 import { sandboxErrorTypes } from "../error/shape.js";
+import { readPropertyDescriptor } from "./accessors.js";
 import { dateString, dateTime, isSandboxDate } from "./date.js";
 import { invokeBuiltinClosure } from "./builtin-call.js";
 import { float32Storage, isFloat32Array } from "./float32.js";
@@ -13,6 +14,7 @@ import { boxedValue, isSandboxBox } from "./boxed.js";
 import { isSandboxClosure, isSandboxPromise, isSandboxMap, isSandboxSet, isSandboxRegex, isSandboxGenerator } from "./values.js";
 const defaultStringHook = Symbol("defaultStringHook");
 const defaultValueHook = Symbol("defaultValueHook");
+const joiningArrays = new WeakSet();
 export function sandboxNumber(value, budget, context) {
     if (value === null || typeof value !== "object") {
         if (typeof value === "function")
@@ -30,18 +32,44 @@ export function sandboxString(value, budget, context, joining = new Set()) {
     return objectToPrimitive(value, budget, context, joining, "string")
         .then(primitive => budget.allocateString(String(primitive)));
 }
+export async function joinSandboxArray(value, length, separator, budget, context, joining = new Set()) {
+    if (joiningArrays.has(value))
+        return "";
+    joiningArrays.add(value);
+    let text = "";
+    const release = retainValues(budget, () => [value, text, separator]);
+    try {
+        for (let index = 0; index < length; index++) {
+            budget.visitNode();
+            const element = await readCoercionProperty(value, String(index), context);
+            const part = element === null || element === undefined
+                ? ""
+                : await sandboxString(element, budget, context, joining);
+            text = budget.allocateString(text + (index === 0 ? "" : separator) + part);
+        }
+        return text;
+    }
+    finally {
+        release();
+        joiningArrays.delete(value);
+    }
+}
 async function objectToPrimitive(value, budget, context, joining, hint) {
     const leaveCall = budget.enterCall();
     try {
         budget.visitNode();
         for (const name of hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"]) {
-            const hook = conversionHook(value, name, budget);
+            const hook = await conversionHook(value, name, budget, context);
             let result;
             if (hook === defaultStringHook) {
                 result = await defaultToString(value, budget, context, joining);
             }
             else if (hook === defaultValueHook) {
-                result = isSandboxDate(value) ? dateTime(value) : isSandboxBox(value) ? boxedValue(value) : value;
+                result = isSandboxDate(value)
+                    ? dateTime(value)
+                    : isSandboxBox(value)
+                        ? boxedValue(value)
+                        : value;
             }
             else {
                 if (!isSandboxClosure(hook))
@@ -60,7 +88,7 @@ async function objectToPrimitive(value, budget, context, joining, hint) {
         leaveCall();
     }
 }
-function conversionHook(value, name, budget) {
+function conversionHook(value, name, budget, context) {
     const implicitBuiltin = !hasExplicitSandboxPrototype(value) &&
         (Array.isArray(value) ||
             isSandboxDate(value) ||
@@ -80,9 +108,7 @@ function conversionHook(value, name, budget) {
         const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : current;
         const descriptor = properties === undefined ? undefined : Object.getOwnPropertyDescriptor(properties, name);
         if (descriptor !== undefined) {
-            if (!Object.hasOwn(descriptor, "value"))
-                throw new TypeError("String conversion requires sandbox data properties.");
-            return descriptor.value;
+            return readPropertyDescriptor(descriptor, value, context);
         }
         const parent = getSandboxPrototype(current, budget);
         if (current === value &&
@@ -107,7 +133,9 @@ async function defaultToString(value, budget, context, joining) {
     if (isSandboxSet(value))
         return "[object Set]";
     if (isSandboxCollectionIterator(value))
-        return collectionIteratorState(value).collectionKind === "map" ? "[object Map Iterator]" : "[object Set Iterator]";
+        return collectionIteratorState(value).collectionKind === "map"
+            ? "[object Map Iterator]"
+            : "[object Set Iterator]";
     if (isSandboxGenerator(value))
         return "[object Generator]";
     if (isSandboxRegex(value)) {
@@ -117,40 +145,23 @@ async function defaultToString(value, budget, context, joining) {
         return budget.allocateString(dateString(value));
     if (Array.isArray(value) || isFloat32Array(value)) {
         if (Object.hasOwn(value, "join")) {
-            const join = ownDataValue(value, "join");
+            const join = await readCoercionProperty(value, "join", context);
             if (!isSandboxClosure(join))
                 return isFloat32Array(value) ? "[object Float32Array]" : "[object Array]";
             return invokeBuiltinClosure(join, [], budget, context, value);
         }
-        if (joining.has(value))
-            return "";
-        joining.add(value);
-        let text = "";
-        const release = retainValues(budget, () => [text]);
-        try {
-            const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
-            for (let index = 0; index < length; index++) {
-                budget.visitNode();
-                const element = ownDataValue(value, String(index));
-                const part = element === null || element === undefined
-                    ? ""
-                    : await sandboxString(element, budget, context, joining);
-                text = budget.allocateString(text + (index === 0 ? "" : ",") + part);
-            }
-            return text;
-        }
-        finally {
-            release();
-            joining.delete(value);
-        }
+        const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
+        return joinSandboxArray(value, length, ",", budget, context, joining);
     }
     if (sandboxErrorTypes.has(value)) {
-        const nameValue = ownDataValue(value, "name");
+        const nameValue = await readCoercionProperty(value, "name", context);
         const name = nameValue === undefined ? "Error" : await sandboxString(nameValue, budget, context, joining);
         const release = retainValues(budget, () => [name]);
         try {
-            const messageValue = ownDataValue(value, "message");
-            const message = messageValue === undefined ? "" : await sandboxString(messageValue, budget, context, joining);
+            const messageValue = await readCoercionProperty(value, "message", context);
+            const message = messageValue === undefined
+                ? ""
+                : await sandboxString(messageValue, budget, context, joining);
             return name === "" ? message : message === "" ? name : `${name}: ${message}`;
         }
         finally {
@@ -159,10 +170,9 @@ async function defaultToString(value, budget, context, joining) {
     }
     return isSandboxPromise(value) ? "[object Promise]" : "[object Object]";
 }
-function ownDataValue(value, name) {
+function readCoercionProperty(value, name, context) {
+    if (context?.getProperty !== undefined)
+        return context.getProperty(value, name);
     const descriptor = Object.getOwnPropertyDescriptor(value, name);
-    if (descriptor !== undefined && !Object.hasOwn(descriptor, "value")) {
-        throw new TypeError("String conversion requires sandbox data properties.");
-    }
-    return descriptor?.value;
+    return descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, value, context);
 }

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

@@ -54,7 +54,7 @@ export type SandboxCallContext = {
     };
     readonly stack: readonly string[];
     readonly thisValue: SandboxValue;
-    readonly getProperty?: (value: SandboxValue, property: string | number) => SandboxValue;
+    readonly getProperty?: (value: SandboxValue, property: string | number) => SandboxValue | Promise<SandboxValue>;
     readonly reconcileData?: (value: SandboxValue) => void;
     readonly invokeClosure?: (closure: SandboxClosure, args: readonly SandboxValue[], thisValue: SandboxValue, construct?: boolean, newTarget?: SandboxClosure) => Promise<SandboxValue>;
 };
@@ -112,6 +112,7 @@ export declare function createSandboxClosure(input: {
     retainedValues?: () => Iterable<SandboxValue>;
 }): SandboxClosure;
 export declare function ownEnumerableSandboxEntries(value: SandboxValue, excludedKeys?: ReadonlySet<string>): Array<[string, SandboxValue]>;
+export declare function ownEnumerableSandboxKeys(value: SandboxValue): string[];
 export declare function createSandboxPromise(promise: Promise<SandboxValue>, metadata?: {
     trackReplay?: boolean;
     synchronousPrefix?: Promise<void>;

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

@@ -1,4 +1,5 @@
 import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.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 { copyNativeDate, exportDate, isSandboxDate } from "./date.js";
@@ -100,6 +101,17 @@ export function ownEnumerableSandboxEntries(value, excludedKeys) {
         entries = Object.entries(Object(value));
     return excludedKeys === undefined ? entries : entries.filter(([key]) => !excludedKeys.has(key));
 }
+export function ownEnumerableSandboxKeys(value) {
+    if (isGuestHostObject(value))
+        return getHostObjectKeys(value);
+    if (value === null || value === undefined)
+        throw new TypeError("Cannot convert undefined or null to object.");
+    if (isGuestClosure(value))
+        return Object.keys(value.properties ?? {});
+    if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value))
+        return [];
+    return Object.keys(Object(value));
+}
 export function createSandboxPromise(promise, metadata = {}) {
     const original = metadata.trackReplay === false
         ? promise
@@ -254,6 +266,9 @@ export function measureSandboxData(values, options = {}) {
                 usage += key.length + 1;
                 if ("value" in descriptor)
                     visit(descriptor.value, depth + 1);
+                else
+                    for (const closure of retainedAccessorClosures(descriptor))
+                        visit(closure, depth + 1);
             }
             return;
         }
@@ -289,6 +304,9 @@ export function measureSandboxData(values, options = {}) {
                     usage += key.length + 1;
                     if ("value" in descriptor)
                         visit(descriptor.value, depth + 1);
+                    else
+                        for (const closure of retainedAccessorClosures(descriptor))
+                            visit(closure, depth + 1);
                 }
                 return;
             }
@@ -333,6 +351,9 @@ export function measureSandboxData(values, options = {}) {
                         usage += key.length + 1;
                         if ("value" in descriptor)
                             visit(descriptor.value, depth + 1);
+                        else
+                            for (const closure of retainedAccessorClosures(descriptor))
+                                visit(closure, depth + 1);
                     }
                 }
                 else
@@ -386,7 +407,11 @@ export function measureSandboxData(values, options = {}) {
             if (!descriptor.enumerable && !hasManagedDescriptors(value))
                 continue;
             usage += key.length;
-            visit("value" in descriptor ? descriptor.value : undefined, depth + 1);
+            if ("value" in descriptor)
+                visit(descriptor.value, depth + 1);
+            else
+                for (const closure of retainedAccessorClosures(descriptor))
+                    visit(closure, depth + 1);
         }
     };
     for (const value of values)

package/packages/safe-js/dist/parse/parser.d.ts

@@ -251,7 +251,7 @@ export type ClassElement = (BaseNode & {
     type: "MethodDefinition";
     computed: boolean;
     key: Expression;
-    kind: "constructor" | "method";
+    kind: "constructor" | "method" | "get" | "set";
     static: boolean;
     value: FunctionExpression;
 }) | (BaseNode & {

package/packages/safe-js/dist/parse/parser.js

@@ -980,7 +980,7 @@ class Parser {
             });
         });
     }
-    parseFunctionParts(generator, lexicalContext) {
+    parseFunctionParts(generator, lexicalContext, accessor) {
         return this.withLexicalContext(lexicalContext, () => {
             const params = this.withScope(() => {
                 const parsed = this.parseArrowParameters();
@@ -989,7 +989,27 @@ class Parser {
                         this.declareBinding(identifier);
                 return parsed;
             });
+            if (accessor === "get" && params.length !== 0)
+                throw new Error("A getter cannot have parameters.");
+            if (accessor === "set" && (params.length !== 1 || params[0]?.type === "RestElement"))
+                throw new Error("A setter must have exactly one non-rest parameter.");
+            const bodyTokenIndex = this.index;
             const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
+            if (accessor === "set" && params[0]?.type !== "Identifier") {
+                let directiveTokenIndex = bodyTokenIndex + 1;
+                for (const statement of body.body) {
+                    const token = this.tokens[directiveTokenIndex];
+                    if (statement.type !== "ExpressionStatement" ||
+                        statement.expression.type !== "StringLiteral" ||
+                        token?.type !== "string" ||
+                        statement.span.start.offset !== token.start.offset ||
+                        statement.span.end.offset !== token.end.offset)
+                        break;
+                    if (statement.expression.raw === '"use strict"' || statement.expression.raw === "'use strict'")
+                        throw new Error("A setter with a non-simple parameter cannot contain a use strict directive.");
+                    directiveTokenIndex += this.tokens[directiveTokenIndex + 1]?.value === ";" ? 2 : 1;
+                }
+            }
             return { params, body };
         });
     }
@@ -1017,8 +1037,14 @@ class Parser {
         const generator = this.consumePunctuator("*") !== undefined;
         if (async && generator)
             throw new DisallowedSyntaxError("async generator", methodStart.start);
-        if ((this.currentToken().value === "get" || this.currentToken().value === "set") && this.isObjectMethodStart())
-            throw new DisallowedSyntaxError("class accessor", this.currentToken().start);
+        let accessor;
+        const modifier = this.currentToken();
+        if ((modifier.value === "get" || modifier.value === "set") && this.isObjectMethodStart()) {
+            if (async || generator || modifier.end.offset - modifier.start.offset !== modifier.value.length)
+                throw unexpectedTokenError(modifier);
+            accessor = modifier.value;
+            this.index++;
+        }
         const computed = this.consumePunctuator("[") !== undefined;
         const key = computed
             ? this.parseExpression({ allowSequence: true }).node
@@ -1035,19 +1061,19 @@ class Parser {
             throw new Error("A static class element cannot be named prototype.");
         if (this.currentToken().value === "(") {
             const constructor = !isStatic && name === "constructor";
-            if (constructor && (async || generator))
-                throw new Error("A class constructor cannot be async or a generator.");
+            if (constructor && (async || generator || accessor !== undefined))
+                throw new Error("A class constructor must be an ordinary method.");
             const { params, body } = this.parseFunctionParts(generator, {
                 newTarget: true, superProperty: true, superCall: constructor && derived,
                 arguments: true, return: true, await: async, strictAwait: true
-            });
+            }, accessor);
             const value = this.withFunctionSource({
                 type: "FunctionExpression", async, generator, method: true, params, body,
                 span: createSpan(methodStart.start, body.span.end)
             });
             return {
                 type: "MethodDefinition", key, computed, static: isStatic,
-                kind: constructor ? "constructor" : "method", value,
+                kind: accessor ?? (constructor ? "constructor" : "method"), value,
                 span: createSpan(start.start, value.span.end)
             };
         }
@@ -2285,7 +2311,10 @@ class Parser {
             this.peekToken(2).value === "(");
     }
     parseObjectMethod(asyncToken, methodStart) {
-        const { params, body } = this.parseFunctionParts(false, ordinaryFunctionContext);
+        const { params, body } = this.parseFunctionParts(false, {
+            ...ordinaryFunctionContext,
+            superProperty: true
+        });
         return this.withFunctionSource({
             type: "FunctionExpression",
             async: asyncToken !== undefined,