poe-code 14.0.64 → 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";
@@ -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)) {
@@ -2468,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)) {
@@ -2505,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();
@@ -2522,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));
@@ -2600,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;
@@ -2614,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

@@ -69,7 +69,7 @@ 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))

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) {

package/packages/safe-js/dist/lint/rules/AS-floating-promise.js

@@ -1,3 +1,4 @@
+import { visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 import { normalizeModuleRegistrations } from "./module-registry.js";
 const AS_FLOATING_PROMISE_MESSAGE = "Promise-returning call is not awaited, returned, stored, or chained.";
@@ -28,6 +29,10 @@ class ASFloatingPromiseScanner {
         });
     }
     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);
@@ -163,6 +168,10 @@ class ASFloatingPromiseScanner {
         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-frontmatter-field-unused.js

@@ -1,3 +1,4 @@
+import { visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 export function AS_FRONTMATTER_FIELD_UNUSED(source, options = {}) {
     if (options.frontmatterFields === undefined) {
@@ -34,6 +35,10 @@ class ASFrontmatterFieldUnusedScanner {
         }
     }
     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);
@@ -162,6 +167,10 @@ class ASFrontmatterFieldUnusedScanner {
         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-jsdoc-type.js

@@ -1,3 +1,4 @@
+import { visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 import { hasTypedModuleRegistrations } from "./module-registry.js";
 export function AS_JSDOC_TYPE(source, options = {}) {
@@ -27,6 +28,10 @@ class ASJsdocTypeScanner {
         }
     }
     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);
@@ -166,6 +171,10 @@ class ASJsdocTypeScanner {
         }
     }
     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-large-literal.js

@@ -1,3 +1,4 @@
+import { visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 const DEFAULT_LARGE_LITERAL_THRESHOLD = 1000;
 export function AS_LARGE_LITERAL(source, options = {}) {
@@ -21,6 +22,10 @@ class ASLargeLiteralScanner {
         }
     }
     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);
@@ -144,6 +149,10 @@ class ASLargeLiteralScanner {
         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-missing-async.js

@@ -1,3 +1,4 @@
+import { classDefinitionContains, visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 export const AS_MISSING_ASYNC_MESSAGE = "Functions that contain await must be marked async.";
 export function AS_MISSING_ASYNC(source, options = {}) {
@@ -27,6 +28,10 @@ class ASMissingAsyncScanner {
         }
     }
     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);
@@ -150,6 +155,10 @@ class ASMissingAsyncScanner {
         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) {
@@ -377,6 +386,8 @@ function statementListContainsAwait(statements) {
 }
 function statementContainsAwait(node) {
     switch (node.type) {
+        case "ClassDeclaration":
+            return classDefinitionContains(node, expressionContainsAwait);
         case "BlockStatement":
             return statementListContainsAwait(node.body);
         case "ExpressionStatement":
@@ -439,6 +450,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-mutating-frozen.js

@@ -1,3 +1,4 @@
+import { visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 const MUTATING_ARRAY_METHODS = new Set([
     "copyWithin",
@@ -32,6 +33,10 @@ class ASMutatingFrozenScanner {
         });
     }
     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);
@@ -172,6 +177,10 @@ class ASMutatingFrozenScanner {
         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) {