poe-code 14.0.63 → 14.0.65

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

@@ -5,6 +5,7 @@ import { assertPromiseExecutionAllowed } from "./promise-tracker.js";
 import { SandboxJobQueue, runAsyncPrefix, suspendJob } from "./jobs.js";
 import { withCancellationSignal } from "./cancel.js";
 import { retainValues } from "./resources.js";
+import { evaluateClass } from "./classes.js";
 import { sandboxString } from "./string-coercion.js";
 import { attachErrorSpan, formatErrorStack, replaceErrorStack } from "../error/shape.js";
 import { evaluateArrowFunctionExpression, evaluateFunctionExpression, evaluateAwaitExpression, emitResumeBreakpoint, createInterpretedClosure, normalizeClosureResult } from "./async.js";
@@ -14,7 +15,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, isDefaultBoxedMethod, isGuestClosure, materializeFunctionProperties, setSandboxPrototype } from "./object-model.js";
+import { getBoxedPrototype, getGuestFunctionProperty, 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";
@@ -50,6 +51,15 @@ const dispatchTable = {
     BlockStatement: evaluateBlockStatement,
     BooleanLiteral: evaluatePrimitiveLiteral,
     CallExpression: evaluateCallExpression,
+    ClassDeclaration: (node, context) => evaluateClass(node, context, evaluateNode, createCoercionContext(context)),
+    ClassExpression: (node, context) => evaluateClass(node, context, evaluateNode, createCoercionContext(context)),
+    NewTargetExpression: async (_node, context) => ({ kind: "normal", hasValue: true, value: context.functionEnvironment?.newTarget }),
+    Super: async (_node, context) => {
+        const home = context.functionEnvironment?.homeObject;
+        if (home === undefined)
+            throw new ReferenceError("Super binding is unavailable.");
+        return { kind: "normal", hasValue: true, value: getSandboxPrototype(home, context.budget) };
+    },
     ConditionalExpression: evaluateConditionalExpression,
     ContinueStatement: evaluateContinueStatement,
     DoWhileStatement: evaluateDoWhileStatement,
@@ -182,6 +192,8 @@ export async function interpret(node, options = {}) {
 export { Scope } from "./scope.js";
 async function evaluateNode(node, context) {
     context.assertActive?.();
+    if (context.inferredName !== undefined && node.type !== "ClassExpression")
+        context = { ...context, inferredName: undefined };
     const replayWait = promiseReplayContext.getStore()?.beforeNode(node.nodeId);
     if (replayWait !== undefined)
         await suspendJob(replayWait);
@@ -332,7 +344,7 @@ async function evaluateObjectExpression(node, context) {
             const releaseKey = retainValues(context.budget, () => [key.value]);
             let value;
             try {
-                value = await evaluateNode(property.value, context);
+                value = await evaluateNode(property.value, { ...context, inferredName: String(key.value) });
             }
             finally {
                 releaseKey();
@@ -390,22 +402,32 @@ async function evaluateTemplateLiteral(node, context) {
     }
 }
 async function evaluateTaggedTemplateExpression(node, context) {
-    const tag = await evaluateNode(node.tag, context);
-    if (tag.kind !== "normal") {
-        return tag;
-    }
-    if (!isSandboxClosure(tag.value)) {
-        throw new TypeError("Tagged template tag must be a function.");
-    }
-    const values = await evaluateTemplateExpressionValues(node.quasi, context);
-    if (!values.ok) {
-        return values.result;
-    }
-    return {
-        kind: "normal",
-        hasValue: true,
-        value: await invokeSandboxClosure(tag.value, [createTaggedTemplateStrings(node.quasi, context), ...values.value], context, [...context.callStack, formatStackFrame(node, tag.value.name)])
+    const invokeTag = async (tag, receiver) => {
+        if (!isSandboxClosure(tag))
+            throw new TypeError("Tagged template tag must be a function.");
+        const release = retainValues(context.budget, () => [tag, receiver]);
+        try {
+            const values = await evaluateTemplateExpressionValues(node.quasi, context);
+            if (!values.ok)
+                return values.result;
+            return {
+                kind: "normal", hasValue: true,
+                value: await invokeSandboxClosure(tag, [createTaggedTemplateStrings(node.quasi, context), ...values.value], context, [...context.callStack, formatStackFrame(node, tag.name)], node.span, receiver)
+            };
+        }
+        finally {
+            release();
+        }
     };
+    if (node.tag.type === "MemberExpression")
+        return evaluateMemberAccess(node.tag, context, async (member) => {
+            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 tag = await evaluateNode(node.tag, context);
+    return tag.kind === "normal" ? invokeTag(tag.value, undefined) : tag;
 }
 async function evaluateTemplateExpressionValues(node, context) {
     const values = [];
@@ -552,7 +574,7 @@ async function evaluateAssignmentExpression(node, context) {
             value: current
         };
     }
-    const right = await evaluateNode(node.right, context);
+    const right = await evaluateNode(node.right, { ...context, inferredName: node.left.type === "Identifier" ? node.left.name : undefined });
     if (right.kind !== "normal") {
         return right;
     }
@@ -626,7 +648,10 @@ async function evaluateMemberAssignmentExpression(node, context) {
             }
             operands = [value];
             property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-            setSandboxProperty(member.object, property, value, context.budget);
+            if (member.superReceiver === undefined)
+                setSandboxProperty(member.object, property, value, context.budget);
+            else
+                setSuperProperty(member.object, member.superReceiver.value, property, value, context.budget);
             return {
                 kind: "normal",
                 hasValue: true,
@@ -772,7 +797,7 @@ async function evaluateVariableDeclaration(node, context) {
                     hasValue: true,
                     value: undefined
                 }
-                : await evaluateNode(declarator.init, context);
+                : await evaluateNode(declarator.init, { ...context, inferredName: declarator.id.type === "Identifier" ? declarator.id.name : undefined });
         if (value.kind !== "normal") {
             return value;
         }
@@ -946,6 +971,11 @@ function predeclareStatementListBindings(statements, context, functionBody = fal
     const { scope } = context;
     const names = new Set();
     for (const statement of statements) {
+        if (statement.type === "ClassDeclaration") {
+            scope.predeclare(statement.id.name, "let");
+            names.add(statement.id.name);
+            continue;
+        }
         if (statement.type === "FunctionDeclaration") {
             const name = statement.id.name;
             if (names.has(name) && !(functionBody && scope.getOwnBindingKind(name) === "var")) {
@@ -1646,6 +1676,8 @@ async function evaluateDeleteExpression(node, context) {
         throw createError("UNSUPPORTED_NODE", node, "Unary operator 'delete' requires a member target.");
     }
     return evaluateMemberAccess(node.argument, context, async (member) => {
+        if (member.kind === "resolved" && member.superReceiver !== undefined)
+            throw new ReferenceError("Cannot delete a super property.");
         if (member.kind === "nullish" || member.object === null || member.object === undefined) {
             if (member.kind === "nullish") {
                 return {
@@ -1705,7 +1737,10 @@ async function evaluateMemberUpdateExpression(node, context) {
         const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
         const current = toNumber(await toNumericPrimitive(getPropertyValue(member.object, property, context), context));
         const next = node.operator === "++" ? current + 1 : current - 1;
-        setSandboxProperty(member.object, property, next, context.budget);
+        if (member.superReceiver === undefined)
+            setSandboxProperty(member.object, property, next, context.budget);
+        else
+            setSuperProperty(member.object, member.superReceiver.value, property, next, context.budget);
         return {
             kind: "normal",
             hasValue: true,
@@ -1771,13 +1806,22 @@ export function createPatternContext(context, scope = context.scope, evaluate =
     const evaluationContext = { ...context, scope };
     return {
         budget: context.budget,
-        evaluate: node => evaluate(node, evaluationContext),
+        evaluate: (node, inferredName) => evaluate(node, { ...evaluationContext, inferredName }),
         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)
     };
 }
 async function evaluateCallExpression(node, context) {
+    if (node.callee.type === "Super") {
+        const construction = context.functionEnvironment?.construction;
+        if (construction === undefined)
+            throw new ReferenceError("Super constructor binding is unavailable.");
+        const args = await evaluateCallArguments(node.arguments, context);
+        if (!args.ok)
+            return args.result;
+        return { kind: "normal", hasValue: true, value: await construction.superCall(args.value) };
+    }
     if (node.callee.type === "MemberExpression") {
         context.budget.visitNode();
         context.stats.nodeVisits += 1;
@@ -1847,6 +1891,7 @@ function attachFatalSandboxErrorContext(error, node, stackFrames) {
     replaceErrorStack(error, stackFrames);
 }
 async function evaluateMemberAccess(node, context, consume) {
+    const superReceiver = node.object.type === "Super" ? { value: context.scope.lookup("this") } : undefined;
     const object = await evaluateNode(node.object, context);
     if (object.kind !== "normal")
         return object;
@@ -1862,7 +1907,8 @@ async function evaluateMemberAccess(node, context, consume) {
         if (result.kind !== "normal")
             return result;
         property = result.value;
-        return await consume({ kind: "resolved", object: object.value, property });
+        return await consume({ kind: "resolved", object: object.value, property,
+            ...(superReceiver === undefined ? {} : { superReceiver: { value: superReceiver.value.found ? superReceiver.value.value : undefined } }) });
     }
     finally {
         release();
@@ -1918,6 +1964,8 @@ async function evaluateMemberCallExpression(node, context) {
             ...reference,
             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);
         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)) {
@@ -2219,8 +2267,9 @@ function hasSandboxProperty(value, key, context) {
             return hasHostObjectMember(current, key);
         if (hasOwnSandboxProperty(current, key, false))
             return true;
-        if (Array.isArray(current) || !isPlainSandboxObject(current) ||
-            isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current)) {
+        if (!(isGuestClosure(current) && hasExplicitSandboxPrototype(current)) &&
+            (Array.isArray(current) || !isPlainSandboxObject(current) ||
+                isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current))) {
             return getPropertyValue(current, key, context) !== undefined;
         }
         current = getSandboxPrototype(current, context.budget);
@@ -2467,7 +2516,7 @@ function getArrayMemberValue(target, property, context) {
     }
     return getArrayMember(target, property, createArrayMethodOptions(context));
 }
-export function setSandboxProperty(target, property, value, budget) {
+export function setSandboxProperty(target, property, value, budget, checkInherited = true) {
     if (isSandboxDate(target))
         throw new TypeError("Date own properties are not supported.");
     if (isGuestHostObject(target)) {
@@ -2504,7 +2553,7 @@ export function setSandboxProperty(target, property, value, budget) {
         Object.defineProperty(target, key, { value });
     }
     else {
-        if (typeof prototypeOwner === "object" && prototypeOwner !== null) {
+        if (checkInherited && typeof prototypeOwner === "object" && prototypeOwner !== null) {
             let depth = 0;
             for (let prototype = getSandboxPrototype(prototypeOwner, budget); prototype !== null; prototype = getSandboxPrototype(prototype, budget)) {
                 budget.visitNode();
@@ -2521,6 +2570,25 @@ export function setSandboxProperty(target, property, value, budget) {
         defineSandboxProperty(target, key, value);
     }
 }
+function setSuperProperty(base, receiver, key, value, budget) {
+    if (typeof base !== "object" || base === null)
+        throw new TypeError("Cannot assign a property of null.");
+    let depth = 0;
+    for (let current = base; current !== null; current = getSandboxPrototype(current, budget)) {
+        budget.visitNode();
+        assertSandboxDataDepth(depth++);
+        const properties = isSandboxClosure(current) ? current.properties : current;
+        const descriptor = properties === undefined ? undefined : Object.getOwnPropertyDescriptor(properties, key);
+        if (descriptor === undefined)
+            continue;
+        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);
+}
 function deleteSandboxProperty(target, property) {
     if (isGuestHostObject(target))
         return deleteHostObjectMember(target, String(property));
@@ -2599,10 +2667,10 @@ function createSetMethodOptions(context) {
 function createFunctionMethodOptions(context) {
     return {
         budget: context.budget,
-        callClosure: (closure, args, stack, thisValue, construct) => invokeSandboxClosure(closure, args, context, stack, undefined, thisValue, construct)
+        callClosure: (closure, args, stack, thisValue, construct, newTarget) => invokeSandboxClosure(closure, args, context, stack, undefined, thisValue, construct, newTarget)
     };
 }
-async function invokeSandboxClosure(callee, args, context, stack, span, thisValue = undefined, construct = false) {
+async function invokeSandboxClosure(callee, args, context, stack, span, thisValue = undefined, construct = false, newTarget) {
     const leaveCall = context.budget.enterCall();
     try {
         const invoke = construct ? callee.construct : callee.call;
@@ -2613,10 +2681,11 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
             {
                 stack,
                 thisValue,
+                newTarget: construct ? newTarget ?? callee : undefined,
                 compilation: context.compilation,
                 getProperty: (value, property) => getPropertyValue(value, property, context),
                 reconcileData: (value) => reconcileDataBudget(context.budget, context.stats, context.scope, value, context.compilation, context.compilation?.parent),
-                invokeClosure: (closure, argumentsList, receiver, asConstructor) => invokeSandboxClosure(closure, argumentsList, context, stack, span, receiver, asConstructor),
+                invokeClosure: (closure, argumentsList, receiver, asConstructor, target) => invokeSandboxClosure(closure, argumentsList, context, stack, span, receiver, asConstructor, target),
                 ...(span === undefined ? {} : { span })
             }
         ]);

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

@@ -2,6 +2,6 @@ import { type SandboxClosure, type SandboxValue } from "../values.js";
 import type { Budget } from "../budget.js";
 export type FunctionMethodOptions = {
     budget?: Budget;
-    callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue: SandboxValue, construct?: boolean) => Promise<SandboxValue> | SandboxValue;
+    callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue: SandboxValue, construct?: boolean, newTarget?: SandboxClosure) => Promise<SandboxValue> | SandboxValue;
 };
 export declare function getFunctionMember(target: SandboxClosure, property: string | number, options: FunctionMethodOptions): SandboxValue | undefined;

package/packages/safe-js/dist/interp/methods/function.js

@@ -1,23 +1,37 @@
 import { createSandboxClosure, isSandboxClosure } from "../values.js";
-import { getGuestFunctionProperty, isGuestClosure } from "../object-model.js";
+import { getGuestFunctionProperty, getSandboxPrototype, hasExplicitSandboxPrototype, isGuestClosure, setSandboxPrototype } from "../object-model.js";
+import { assertSandboxDataDepth } from "../../graph-depth.js";
 import { functionString } from "../function-string.js";
 import { runResources } from "../resources.js";
 const functionMethodNames = new Set(["apply", "bind", "call", "toString"]);
 export function getFunctionMember(target, property, options) {
-    if (isGuestClosure(target)) {
-        const value = getGuestFunctionProperty(target, String(property));
-        if (value !== undefined || Object.hasOwn(target.properties ?? {}, String(property)))
-            return value;
-        if (!isFunctionMethodName(property))
-            return undefined;
-    }
-    const properties = target.properties;
-    if (properties !== undefined && Object.hasOwn(properties, String(property))) {
-        return properties[String(property)];
-    }
-    if (property === "length") {
-        return target.length;
+    let current = target;
+    let depth = 0;
+    while (current !== null) {
+        if (isGuestClosure(current)) {
+            const value = getGuestFunctionProperty(current, String(property));
+            if (value !== undefined || Object.hasOwn(current.properties ?? {}, String(property)))
+                return value;
+        }
+        else if (isSandboxClosure(current)) {
+            if (current.properties !== undefined && Object.hasOwn(current.properties, String(property)))
+                return current.properties[String(property)];
+            if (property === "length")
+                return current.length;
+        }
+        else if (Object.hasOwn(current, String(property))) {
+            return current[String(property)];
+        }
+        if (isSandboxClosure(current) && !hasExplicitSandboxPrototype(current))
+            break;
+        current = getSandboxPrototype(current, options.budget);
+        if (current !== null) {
+            options.budget?.visitNode();
+            assertSandboxDataDepth(++depth);
+        }
     }
+    if (current === null)
+        return undefined;
     if (property === "toString" && runResources.getStore()?.functionSourceText === false)
         return undefined;
     if (!isFunctionMethodName(property)) {
@@ -44,7 +58,7 @@ function callFunctionMethod(target, methodName, args, options, stack) {
     const thisValue = args[0];
     if (methodName === "bind") {
         const boundArgs = args.slice(1);
-        return createSandboxClosure({
+        const bound = createSandboxClosure({
             guest: true,
             sandbox: true,
             name: `bound ${target.name ?? ""}`,
@@ -55,9 +69,12 @@ function callFunctionMethod(target, methodName, args, options, stack) {
             ...(target.construct === undefined
                 ? {}
                 : {
-                    construct: (callArgs, context) => options.callClosure(target, [...boundArgs, ...callArgs], context?.stack ?? [], undefined, true)
+                    construct: (callArgs, context) => options.callClosure(target, [...boundArgs, ...callArgs], context?.stack ?? [], undefined, true, context?.newTarget === bound ? target : context?.newTarget)
                 })
         });
+        if (hasExplicitSandboxPrototype(target))
+            setSandboxPrototype(bound, getSandboxPrototype(target, options.budget), options.budget);
+        return bound;
     }
     if (methodName === "call") {
         return options.callClosure(target, args.slice(1), stack, thisValue);

package/packages/safe-js/dist/interp/object-model.js

@@ -91,17 +91,26 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
     if (roots === undefined)
         intrinsicPrototypeRoots.set(budget, roots = new Set());
     roots.add(prototype);
-    const records = [prototype, materializeFunctionProperties(constructor)].map(value => ({
-        value, descriptors: new Map(Object.entries(Object.getOwnPropertyDescriptors(value)))
+    const records = [prototype, constructor].map(target => ({
+        target,
+        value: isGuestClosure(target) ? materializeFunctionProperties(target) : target,
+        prototype: getSandboxPrototype(target),
+        explicit: hasExplicitSandboxPrototype(target)
+    })).map(record => ({
+        ...record, descriptors: new Map(Object.entries(Object.getOwnPropertyDescriptors(record.value)))
     }));
     const unchanged = (before, after) => before !== undefined && after !== undefined && Object.is(before.value, after.value) &&
         before.writable === after.writable && before.configurable === after.configurable && before.enumerable === after.enumerable;
-    intrinsicConstructors.set(constructor, () => records.every(({ value, descriptors }) => {
+    intrinsicConstructors.set(constructor, () => records.every(({ target, value, descriptors, prototype: parent, explicit }) => {
         const current = Object.getOwnPropertyDescriptors(value);
-        return Object.keys(current).length === descriptors.size &&
+        return getSandboxPrototype(target) === parent && hasExplicitSandboxPrototype(target) === explicit &&
+            Object.keys(current).length === descriptors.size &&
             Object.keys(current).every(key => unchanged(descriptors.get(key), current[key]));
     }));
-    budget.setRetainedValues(prototype, () => records.flatMap(({ value, descriptors }) => Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(([key, descriptor]) => unchanged(descriptors.get(key), descriptor) ? [] : [key, descriptor.value])));
+    budget.setRetainedValues(prototype, () => records.flatMap(({ target, value, descriptors, prototype: parent }) => [
+        ...(getSandboxPrototype(target) === parent ? [] : [getSandboxPrototype(target)]),
+        ...Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(([key, descriptor]) => unchanged(descriptors.get(key), descriptor) ? [] : [key, descriptor.value])
+    ]));
 }
 export function releaseObjectPrototype(budget) {
     for (const prototype of intrinsicPrototypeRoots.get(budget) ?? [])
@@ -118,7 +127,7 @@ export function getSandboxPrototype(value, budget) {
         if (prototype !== undefined && prototype !== value)
             return prototype;
     }
-    return budget !== undefined && isPrototypeRecord(value)
+    return budget !== undefined && !isSandboxClosure(value) && isPrototypeRecord(value)
         ? intrinsicPrototypes.get(budget) ?? null
         : null;
 }
@@ -131,9 +140,12 @@ export function getSandboxDataProperty(value, key, budget) {
     while (typeof current === "object" && current !== null) {
         if (isGuestHostObject(current))
             return getHostObjectMember(current, String(key));
-        if (isGuestClosure(current))
-            return getGuestFunctionProperty(current, String(key));
-        if (isSandboxClosure(current)) {
+        if (isGuestClosure(current)) {
+            const entry = getGuestFunctionProperty(current, String(key));
+            if (entry !== undefined || Object.hasOwn(current.properties ?? {}, String(key)))
+                return entry;
+        }
+        else if (isSandboxClosure(current)) {
             const properties = current.properties;
             return properties !== undefined && Object.hasOwn(properties, String(key))
                 ? properties[String(key)]
@@ -145,7 +157,7 @@ export function getSandboxDataProperty(value, key, budget) {
             isSandboxRegex(current) ||
             isSandboxGenerator(current))
             return undefined;
-        if (Object.hasOwn(current, String(key)))
+        if (!isSandboxClosure(current) && Object.hasOwn(current, String(key)))
             return current[String(key)];
         current = getSandboxPrototype(current, budget);
         if (current !== null) {
@@ -160,7 +172,7 @@ export function setSandboxPrototype(value, prototype, budget) {
         throw new TypeError("Object.prototype has an immutable null prototype.");
     }
     if (!isPrototypeRecord(value) || (prototype !== null && !isPrototypeRecord(prototype))) {
-        throw new TypeError("Prototype links require ordinary sandbox objects; callable and exotic prototype chains are not supported.");
+        throw new TypeError("Prototype links require ordinary sandbox objects or guest functions.");
     }
     if (prototypes.has(value) && getSandboxPrototype(value, budget) === prototype)
         return;
@@ -177,6 +189,8 @@ export function setSandboxPrototype(value, prototype, budget) {
     prototypes.set(value, prototype);
 }
 function isPrototypeRecord(value) {
+    if (isGuestClosure(value))
+        return true;
     if (isGuestHostObject(value))
         return false;
     if (isSandboxClosure(value) ||

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

@@ -12,7 +12,7 @@ export type PatternTarget = {
 };
 export type PatternContext = {
     budget?: Budget;
-    evaluate(node: ParseResult): Promise<AsyncEvaluationResult>;
+    evaluate(node: ParseResult, inferredName?: string): Promise<AsyncEvaluationResult>;
     toPropertyKey(value: SandboxValue): Promise<string>;
     getProperty(value: SandboxValue, key: string | number): SandboxValue;
     setProperty(target: SandboxValue, key: string | number, value: SandboxValue): void;

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

@@ -40,7 +40,7 @@ async function bindAssignmentPattern(pattern, value, target, scope, context) {
     if (value !== undefined) {
         return bindPattern(pattern.left, value, target, scope, context);
     }
-    const defaultValue = await context.evaluate(pattern.right);
+    const defaultValue = await context.evaluate(pattern.right, pattern.left.type === "Identifier" ? pattern.left.name : undefined);
     if (defaultValue.kind !== "normal") {
         return { ok: false, result: defaultValue };
     }

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

@@ -38,6 +38,7 @@ export type SandboxRegex = {
     readonly [sandboxRegexPattern]: RegexPattern;
 };
 export type SandboxCallContext = {
+    readonly newTarget?: SandboxClosure;
     readonly compilation?: CompileScope;
     readonly span?: {
         readonly end: {
@@ -55,7 +56,7 @@ export type SandboxCallContext = {
     readonly thisValue: SandboxValue;
     readonly getProperty?: (value: SandboxValue, property: string | number) => SandboxValue;
     readonly reconcileData?: (value: SandboxValue) => void;
-    readonly invokeClosure?: (closure: SandboxClosure, args: readonly SandboxValue[], thisValue: SandboxValue, construct?: boolean) => Promise<SandboxValue>;
+    readonly invokeClosure?: (closure: SandboxClosure, args: readonly SandboxValue[], thisValue: SandboxValue, construct?: boolean, newTarget?: SandboxClosure) => Promise<SandboxValue>;
 };
 export type SandboxClosure = {
     readonly sourceRange?: FunctionSource;

package/packages/safe-js/dist/lint/class-elements.d.ts

@@ -0,0 +1,5 @@
+import type { BlockStatement, ClassNode, Expression } from "../parse.js";
+/** Visit both definition-time expressions and deferred element bodies. */
+export declare function visitClassElements(node: ClassNode, expression: (node: Expression) => void, statement: (node: BlockStatement) => void): void;
+/** Await in a computed key belongs to the defining function, unlike methods. */
+export declare function classDefinitionContains(node: ClassNode, expression: (node: Expression) => boolean): boolean;

package/packages/safe-js/dist/lint/class-elements.js

@@ -0,0 +1,20 @@
+/** Visit both definition-time expressions and deferred element bodies. */
+export function visitClassElements(node, expression, statement) {
+    if (node.superClass !== undefined)
+        expression(node.superClass);
+    for (const element of node.body.body) {
+        if (element.type === "StaticBlock") {
+            statement(element.body);
+            continue;
+        }
+        if (element.computed)
+            expression(element.key);
+        if (element.value !== undefined)
+            expression(element.value);
+    }
+}
+/** Await in a computed key belongs to the defining function, unlike methods. */
+export function classDefinitionContains(node, expression) {
+    return (node.superClass !== undefined && expression(node.superClass)) ||
+        node.body.body.some(element => element.type !== "StaticBlock" && element.computed && expression(element.key));
+}

package/packages/safe-js/dist/lint/rules/AS-async-not-needed.js

@@ -1,3 +1,4 @@
+import { classDefinitionContains, visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 export const AS_ASYNC_NOT_NEEDED_MESSAGE = "Async functions without await should remove the async keyword.";
 export function AS_ASYNC_NOT_NEEDED(source, options = {}) {
@@ -32,6 +33,10 @@ class ASAsyncNotNeededScanner {
         }
     }
     visitStatement(node) {
+        if (node.type === "ClassDeclaration") {
+            visitClassElements(node, expression => this.visitExpression(expression), statement => this.visitStatement(statement));
+            return;
+        }
         switch (node.type) {
             case "FunctionDeclaration":
                 this.visitFunctionExpression(node);
@@ -166,6 +171,10 @@ class ASAsyncNotNeededScanner {
         this.visitExpression(node.argument);
     }
     visitExpression(node) {
+        if (node.type === "ClassExpression") {
+            visitClassElements(node, expression => this.visitExpression(expression), statement => this.visitStatement(statement));
+            return;
+        }
         switch (node.type) {
             case "YieldExpression":
                 if (node.argument !== undefined) {
@@ -406,6 +415,8 @@ function statementListContainsAwait(statements) {
 }
 function statementContainsAwait(node) {
     switch (node.type) {
+        case "ClassDeclaration":
+            return classDefinitionContains(node, expressionContainsAwait);
         case "BlockStatement":
             return statementListContainsAwait(node.body);
         case "ExpressionStatement":
@@ -468,6 +479,11 @@ function variableDeclarationContainsAwait(node) {
 }
 function expressionContainsAwait(node) {
     switch (node.type) {
+        case "ClassExpression":
+            return classDefinitionContains(node, expressionContainsAwait);
+        case "NewTargetExpression":
+        case "Super":
+            return false;
         case "AwaitExpression":
             return true;
         case "YieldExpression":

package/packages/safe-js/dist/lint/rules/AS-destructure-null-default.js

@@ -1,3 +1,4 @@
+import { visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 const MESSAGE = "Destructuring default values only apply to undefined, not null.";
 const HINT = "Handle null explicitly before destructuring or use ?? after binding.";
@@ -20,6 +21,10 @@ class ASDestructureNullDefaultScanner {
         }
     }
     visitStatement(node) {
+        if (node.type === "ClassDeclaration") {
+            visitClassElements(node, expression => this.visitExpression(expression), statement => this.visitStatement(statement));
+            return;
+        }
         switch (node.type) {
             case "FunctionDeclaration":
                 this.visitArrowFunction(node);
@@ -147,6 +152,10 @@ class ASDestructureNullDefaultScanner {
         this.visitExpression(node.argument);
     }
     visitExpression(node) {
+        if (node.type === "ClassExpression") {
+            visitClassElements(node, expression => this.visitExpression(expression), statement => this.visitStatement(statement));
+            return;
+        }
         switch (node.type) {
             case "YieldExpression":
                 if (node.argument !== undefined) {

package/packages/safe-js/dist/lint/rules/AS-export-import-meta.js

@@ -1,3 +1,4 @@
+import { visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 export function AS_EXPORT_IMPORT_META(source, options = {}) {
     return new Scanner(options.filename ?? "<input>", new Set(options.allowedExportNames ?? []), options.defaultExport).scan(source);
@@ -35,6 +36,10 @@ class Scanner {
         }
     }
     visitStatement(node) {
+        if (node.type === "ClassDeclaration") {
+            visitClassElements(node, expression => this.visitExpression(expression), statement => this.visitStatement(statement));
+            return;
+        }
         switch (node.type) {
             case "FunctionDeclaration":
                 for (const param of node.params) {
@@ -176,6 +181,10 @@ class Scanner {
         this.visitExpression(node.argument);
     }
     visitExpression(node) {
+        if (node.type === "ClassExpression") {
+            visitClassElements(node, expression => this.visitExpression(expression), statement => this.visitStatement(statement));
+            return;
+        }
         switch (node.type) {
             case "YieldExpression":
                 if (node.argument !== undefined) {