poe-code 14.0.65 → 14.0.66

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

@@ -1,4 +1,5 @@
 import { promiseReplayContext } from "./promise-replay.js";
+import { readPropertyDescriptor, writePropertyDescriptor } from "./accessors.js";
 import { deleteHostObjectMember, getHostObjectKeys, getHostObjectMember, hasHostObjectMember, isGuestHostObject, setHostObjectMember } from "./host-capabilities.js";
 import { toPropertyKey } from "./property-key.js";
 import { assertPromiseExecutionAllowed } from "./promise-tracker.js";
@@ -15,7 +16,7 @@ import { CompileScope, RegexCompileGuard } from "./regex/compile-guard.js";
 import { createCapturedException, createThrowCompletion, evaluateThrowStatement as evaluateThrowStatementResult, evaluateTryStatement as evaluateTryStatementResult, isCapturedException, isInterpreterError, surfaceThrownValue } from "./exceptions.js";
 import { callArrayMethod, getArrayMember, isArrayMethodName } from "./methods/array.js";
 import { getFunctionMember } from "./methods/function.js";
-import { getBoxedPrototype, getGuestFunctionProperty, getSandboxPrototype, hasExplicitSandboxPrototype, isDefaultBoxedMethod, isGuestClosure, materializeFunctionProperties, setSandboxPrototype } from "./object-model.js";
+import { getBoxedPrototype, getSandboxPropertyDescriptor, getSandboxPrototype, hasExplicitSandboxPrototype, isDefaultBoxedMethod, isGuestClosure, materializeFunctionProperties, setSandboxPrototype } from "./object-model.js";
 import { getStringIndex } from "./methods/string.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { callMapMethod, getMapMember, isMapMethodName } from "./methods/map.js";
@@ -344,7 +345,13 @@ async function evaluateObjectExpression(node, context) {
             const releaseKey = retainValues(context.budget, () => [key.value]);
             let value;
             try {
-                value = await evaluateNode(property.value, { ...context, inferredName: String(key.value) });
+                value = await evaluateNode(property.value, {
+                    ...context,
+                    inferredName: String(key.value),
+                    ...(property.value.type === "FunctionExpression" && property.value.method === true
+                        ? { functionEnvironment: { homeObject: object } }
+                        : {})
+                });
             }
             finally {
                 releaseKey();
@@ -371,7 +378,8 @@ async function evaluateObjectExpression(node, context) {
     }
 }
 function isObjectPrototypeSetterProperty(property, key) {
-    return !property.computed && !property.shorthand && key === "__proto__";
+    return !property.computed && !property.shorthand && key === "__proto__" &&
+        !(property.value.type === "FunctionExpression" && property.value.method === true);
 }
 async function evaluateTemplateLiteral(node, context) {
     let value = context.budget.allocateString(node.quasis[0]?.value.cooked ?? "");
@@ -424,7 +432,8 @@ async function evaluateTaggedTemplateExpression(node, context) {
             if (member.kind === "nullish")
                 throw new TypeError("Tagged template tag must be a function.");
             const key = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-            return invokeTag(getPropertyValue(member.object, key, context), member.superReceiver === undefined ? member.object : member.superReceiver.value);
+            const receiver = member.superReceiver === undefined ? member.object : member.superReceiver.value;
+            return invokeTag(await getPropertyValue(member.object, key, context, receiver), receiver);
         });
     const tag = await evaluateNode(node.tag, context);
     return tag.kind === "normal" ? invokeTag(tag.value, undefined) : tag;
@@ -512,7 +521,8 @@ async function evaluateBinaryExpression(node, context) {
             if (isSandboxBox(rightValue) && (!equality || (left.value !== null && left.value !== undefined && typeof left.value !== "object")))
                 rightValue = await toNumericPrimitive(rightValue, context);
         }
-        const value = applyBinaryOperator(node, leftValue, rightValue, context);
+        const operation = applyBinaryOperator(node, leftValue, rightValue, context);
+        const value = operation instanceof Promise ? await operation : operation;
         return {
             kind: "normal",
             hasValue: true,
@@ -606,7 +616,7 @@ async function evaluateMemberAssignmentExpression(node, context) {
                 throw new TypeError("Cannot assign properties of null or undefined.");
             }
             property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-            current = getPropertyValue(member.object, property, context);
+            current = await getPropertyValue(member.object, property, context, member.superReceiver === undefined ? member.object : member.superReceiver.value);
         }
         if (node.operator === "&&=" && !isTruthy(current)) {
             return {
@@ -649,9 +659,9 @@ async function evaluateMemberAssignmentExpression(node, context) {
             operands = [value];
             property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
             if (member.superReceiver === undefined)
-                setSandboxProperty(member.object, property, value, context.budget);
+                await setSandboxProperty(member.object, property, value, context.budget, true, createCoercionContext(context));
             else
-                setSuperProperty(member.object, member.superReceiver.value, property, value, context.budget);
+                await setSuperProperty(member.object, member.superReceiver.value, property, value, context);
             return {
                 kind: "normal",
                 hasValue: true,
@@ -1735,12 +1745,12 @@ async function evaluateMemberUpdateExpression(node, context) {
             throw new TypeError("Cannot update properties of null or undefined.");
         }
         const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-        const current = toNumber(await toNumericPrimitive(getPropertyValue(member.object, property, context), context));
+        const current = toNumber(await toNumericPrimitive(await getPropertyValue(member.object, property, context, member.superReceiver === undefined ? member.object : member.superReceiver.value), context));
         const next = node.operator === "++" ? current + 1 : current - 1;
         if (member.superReceiver === undefined)
-            setSandboxProperty(member.object, property, next, context.budget);
+            await setSandboxProperty(member.object, property, next, context.budget, true, createCoercionContext(context));
         else
-            setSuperProperty(member.object, member.superReceiver.value, property, next, context.budget);
+            await setSuperProperty(member.object, member.superReceiver.value, property, next, context);
         return {
             kind: "normal",
             hasValue: true,
@@ -1758,19 +1768,23 @@ async function evaluateMemberExpression(node, context) {
         return {
             kind: "normal",
             hasValue: true,
-            value: getPropertyValue(member.object, await toPropertyKey(member.property, context.budget, createCoercionContext(context)), context)
+            value: await getPropertyValue(member.object, await toPropertyKey(member.property, context.budget, createCoercionContext(context)), context, member.superReceiver === undefined ? member.object : member.superReceiver.value)
         };
     });
 }
-function getPropertyValue(target, property, context) {
+function getPropertyValue(target, property, context, receiver = target) {
     if (isGuestHostObject(target))
         return getHostObjectMember(target, String(property));
+    const descriptor = getSandboxPropertyDescriptor(target, property, context.budget);
+    if (descriptor !== undefined)
+        return readPropertyDescriptor(descriptor, receiver, createCoercionContext(context), true);
     if (typeof target === "string" || typeof target === "number" || typeof target === "boolean") {
         const prototype = getBoxedPrototype(target, context.budget);
         if (prototype !== undefined) {
-            if (typeof target === "string" && (property === "length" || getStringIndex(property) !== undefined))
+            if (typeof target === "string" &&
+                (property === "length" || getStringIndex(property) !== undefined))
                 return getStringMember(target, property, context.budget);
-            return getMemberValue(prototype, property, context);
+            return getPropertyValue(prototype, property, context, receiver);
         }
     }
     if (typeof target === "string")
@@ -1807,9 +1821,9 @@ export function createPatternContext(context, scope = context.scope, evaluate =
     return {
         budget: context.budget,
         evaluate: (node, inferredName) => evaluate(node, { ...evaluationContext, inferredName }),
-        toPropertyKey: value => toPropertyKey(value, context.budget, createCoercionContext(evaluationContext)),
+        toPropertyKey: (value) => toPropertyKey(value, context.budget, createCoercionContext(evaluationContext)),
         getProperty: (value, key) => getPropertyValue(value, key, evaluationContext),
-        setProperty: (target, key, value) => setSandboxProperty(target, key, value, context.budget)
+        setProperty: (target, key, value) => setSandboxProperty(target, key, value, context.budget, true, createCoercionContext(evaluationContext))
     };
 }
 async function evaluateCallExpression(node, context) {
@@ -1965,7 +1979,7 @@ async function evaluateMemberCallExpression(node, context) {
             property: await toPropertyKey(reference.property, context.budget, createCoercionContext(context))
         };
         if (member.superReceiver !== undefined)
-            return evaluateResolvedCallExpression(node, getPropertyValue(member.object, member.property, context), context, member.superReceiver.value);
+            return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context, member.superReceiver.value), context, member.superReceiver.value);
         if ((typeof member.object === "string" || typeof member.object === "number" || typeof member.object === "boolean") &&
             getBoxedPrototype(member.object, context.budget) !== undefined) {
             if (isDefaultBoxedMethod(member.object, member.property, context.budget)) {
@@ -1974,7 +1988,7 @@ async function evaluateMemberCallExpression(node, context) {
                 if (typeof member.object === "number" && isNumberMethodName(member.property))
                     return evaluateNumberMethodCall(node, member.object, member.property, context);
             }
-            return evaluateResolvedCallExpression(node, getPropertyValue(member.object, member.property, context), context, member.object);
+            return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
         }
         if (typeof member.object === "string" && isStringMethodName(member.property)) {
             return evaluateStringMethodCall(node, member.object, member.property, context);
@@ -2022,7 +2036,7 @@ async function evaluateMemberCallExpression(node, context) {
             return evaluateResolvedCallExpression(node, memberValue, context, member.object);
         }
         if (isSandboxClosure(member.object)) {
-            const memberValue = getClosureMemberValue(member.object, member.property, context);
+            const memberValue = await getPropertyValue(member.object, member.property, context);
             if (memberValue === undefined) {
                 throw new TypeError(`Function#${String(member.property)} is not a supported method.`);
             }
@@ -2037,7 +2051,7 @@ async function evaluateMemberCallExpression(node, context) {
         if (!isIndexableSandboxValue(member.object)) {
             throw new TypeError("Attempted to read a property from a non-object value.");
         }
-        return evaluateResolvedCallExpression(node, getMemberValue(member.object, member.property, context), context, member.object);
+        return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
     });
 }
 function evaluatePrimitiveMemberCall(node, receiverType, property, value, context) {
@@ -2222,7 +2236,8 @@ function applyBinaryOperator(node, left, right, context) {
             if (isFloat32ArrayConstructor(right))
                 return isFloat32Array(left);
             if (isDateConstructor(right))
-                return isSandboxDate(left) && getDatePrototype(left, context.budget, context.compilation?.owner) !== null;
+                return (isSandboxDate(left) &&
+                    getDatePrototype(left, context.budget, context.compilation?.owner) !== null);
             if (isSandboxSetConstructor(right) && isSandboxSet(left)) {
                 return true;
             }
@@ -2232,17 +2247,21 @@ function applyBinaryOperator(node, left, right, context) {
             if (isGuestClosure(right)) {
                 if (typeof left !== "object" || left === null)
                     return false;
-                const prototype = getGuestFunctionProperty(right, "prototype");
-                if (typeof prototype !== "object" || prototype === null) {
-                    throw new TypeError("Function has a non-object prototype in instanceof check.");
-                }
-                let depth = 0;
-                for (let current = getSandboxPrototype(left, context.budget); current !== null; current = getSandboxPrototype(current, context.budget)) {
-                    context.budget.visitNode();
-                    assertSandboxDataDepth(depth++);
-                    if (current === prototype)
-                        return true;
-                }
+                const check = (prototype) => {
+                    if (typeof prototype !== "object" || prototype === null) {
+                        throw new TypeError("Function has a non-object prototype in instanceof check.");
+                    }
+                    let depth = 0;
+                    for (let current = getSandboxPrototype(left, context.budget); current !== null; current = getSandboxPrototype(current, context.budget)) {
+                        context.budget.visitNode();
+                        assertSandboxDataDepth(depth++);
+                        if (current === prototype)
+                            return true;
+                    }
+                    return false;
+                };
+                const prototype = getPropertyValue(right, "prototype", context);
+                return prototype instanceof Promise ? prototype.then(check) : check(prototype);
             }
             return false;
         case "in":
@@ -2420,7 +2439,7 @@ async function toNumericPrimitive(value, context) {
     }
     if (isIndexableSandboxValue(value)) {
         for (const methodName of ["valueOf", "toString"]) {
-            const method = getMemberValue(value, methodName, context);
+            const method = await getPropertyValue(value, methodName, context);
             if (methodName === "toString" && method === undefined && !Object.hasOwn(value, methodName)) {
                 return toString(value);
             }
@@ -2516,7 +2535,7 @@ function getArrayMemberValue(target, property, context) {
     }
     return getArrayMember(target, property, createArrayMethodOptions(context));
 }
-export function setSandboxProperty(target, property, value, budget, checkInherited = true) {
+export function setSandboxProperty(target, property, value, budget, checkInherited = true, context) {
     if (isSandboxDate(target))
         throw new TypeError("Date own properties are not supported.");
     if (isGuestHostObject(target)) {
@@ -2524,6 +2543,11 @@ export function setSandboxProperty(target, property, value, budget, checkInherit
         return;
     }
     const prototypeOwner = target;
+    if (checkInherited) {
+        const descriptor = getSandboxPropertyDescriptor(target, property, budget);
+        if (descriptor !== undefined && !("value" in descriptor))
+            return writePropertyDescriptor(descriptor, target, value, context);
+    }
     if (isGuestClosure(target))
         target = materializeFunctionProperties(target);
     if (isFloat32Array(target)) {
@@ -2570,7 +2594,8 @@ export function setSandboxProperty(target, property, value, budget, checkInherit
         defineSandboxProperty(target, key, value);
     }
 }
-function setSuperProperty(base, receiver, key, value, budget) {
+function setSuperProperty(base, receiver, key, value, context) {
+    const budget = context.budget;
     if (typeof base !== "object" || base === null)
         throw new TypeError("Cannot assign a property of null.");
     let depth = 0;
@@ -2581,13 +2606,15 @@ function setSuperProperty(base, receiver, key, value, budget) {
         const descriptor = properties === undefined ? undefined : Object.getOwnPropertyDescriptor(properties, key);
         if (descriptor === undefined)
             continue;
+        if (!("value" in descriptor))
+            return writePropertyDescriptor(descriptor, receiver, value, createCoercionContext(context));
         if (descriptor.writable !== true)
             throw new TypeError(`Cannot assign to read only property '${key}'.`);
         break;
     }
     if (typeof receiver !== "object" || receiver === null)
         throw new TypeError("Super assignment requires an object receiver.");
-    setSandboxProperty(receiver, key, value, budget, false);
+    return setSandboxProperty(receiver, key, value, budget, false);
 }
 function deleteSandboxProperty(target, property) {
     if (isGuestHostObject(target))
@@ -2647,7 +2674,7 @@ function createArrayMethodOptions(context) {
         budget: context.budget,
         context: createCoercionContext(context),
         hasProperty: (value, property) => hasSandboxProperty(value, property, context),
-        setProperty: (value, property, entry) => setSandboxProperty(value, property, entry, context.budget),
+        setProperty: (value, property, entry) => setSandboxProperty(value, property, entry, context.budget, true, createCoercionContext(context)),
         deleteProperty: deleteSandboxProperty,
         callClosure: (closure, args, stack, thisValue) => invokeSandboxClosure(closure, args, context, stack, undefined, thisValue)
     };
@@ -2796,16 +2823,28 @@ async function evaluateObjectSpread(node, context) {
         }
         return { ok: true, value: entries };
     }
-    if ((isSandboxClosure(value.value) && !isGuestClosure(value.value)) || isSandboxPromise(value.value)) {
+    if ((isSandboxClosure(value.value) && !isGuestClosure(value.value)) ||
+        isSandboxPromise(value.value)) {
         throw new TypeError(`Cannot spread ${describeObjectSpreadValue(value.value)} into object literal.`);
     }
-    const spreadValue = isGuestClosure(value.value) ? value.value.properties ?? {} : Object(value.value);
+    const spreadValue = isGuestClosure(value.value)
+        ? (value.value.properties ?? {})
+        : Object(value.value);
     const keys = Object.keys(spreadValue);
     context.budget.allocateArrayLength(keys.length);
-    return {
-        ok: true,
-        value: keys.map((key) => [key, spreadValue[key]])
-    };
+    const entries = [];
+    const release = retainValues(context.budget, () => [value.value, entries]);
+    try {
+        for (const key of keys) {
+            if (!hasOwnSandboxProperty(value.value, key, true))
+                continue;
+            entries.push([key, await getPropertyValue(value.value, key, context)]);
+        }
+        return { ok: true, value: entries };
+    }
+    finally {
+        release();
+    }
 }
 function describeObjectSpreadValue(value) {
     if (value === null) {

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

@@ -44,6 +44,19 @@ export function getSandboxIterator(value, budget, context) {
     if (isSandboxSet(value)) {
         return collectionIterator(value.values);
     }
+    if (Array.isArray(value) && context?.getProperty !== undefined) {
+        let index = 0;
+        return {
+            asynchronous: true,
+            snapshotIndex: () => index,
+            next: async () => {
+                if (index >= value.length)
+                    return { done: true, value: undefined };
+                budget?.visitNode();
+                return { done: false, value: await context.getProperty(value, index++) };
+            }
+        };
+    }
     if ((typeof value !== "object" && typeof value !== "function") || value === null) {
         return undefined;
     }

package/packages/safe-js/dist/interp/methods/array.d.ts

@@ -9,7 +9,7 @@ export type ArrayMethodOptions = {
     budget: Budget;
     context?: SandboxCallContext;
     hasProperty?: (value: SandboxValue, property: string) => boolean;
-    setProperty?: (value: SandboxValue, property: string, entry: SandboxValue) => void;
+    setProperty?: (value: SandboxValue, property: string, entry: SandboxValue) => void | Promise<void>;
     deleteProperty?: (value: SandboxValue, property: string | number) => boolean;
     callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue?: SandboxValue) => Promise<SandboxValue>;
 };