poe-code 14.0.64 → 14.0.66

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

@@ -2,3 +2,4 @@ import type { Budget } from "./budget.js";
 import { type SandboxCallContext, type SandboxValue } from "./values.js";
 export declare function sandboxNumber(value: SandboxValue, budget: Budget, context?: SandboxCallContext): number | Promise<number>;
 export declare function sandboxString(value: SandboxValue, budget: Budget, context?: SandboxCallContext, joining?: Set<object>): string | Promise<string>;
+export declare function joinSandboxArray(value: SandboxValue & object, length: number, separator: string, budget: Budget, context?: SandboxCallContext, joining?: Set<object>): Promise<string>;

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

@@ -38,6 +38,7 @@ export type SandboxRegex = {
     readonly [sandboxRegexPattern]: RegexPattern;
 };
 export type SandboxCallContext = {
+    readonly newTarget?: SandboxClosure;
     readonly compilation?: CompileScope;
     readonly span?: {
         readonly end: {
@@ -53,9 +54,9 @@ 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) => Promise<SandboxValue>;
+    readonly invokeClosure?: (closure: SandboxClosure, args: readonly SandboxValue[], thisValue: SandboxValue, construct?: boolean, newTarget?: SandboxClosure) => Promise<SandboxValue>;
 };
 export type SandboxClosure = {
     readonly sourceRange?: FunctionSource;
@@ -111,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/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) {

package/packages/safe-js/dist/lint/rules/AS-needless-template.js

@@ -1,3 +1,4 @@
+import { visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 export const AS_NEEDLESS_TEMPLATE_MESSAGE = "Template literals with only one interpolation should use the value or String(value).";
 export function AS_NEEDLESS_TEMPLATE(source, options = {}) {
@@ -44,6 +45,10 @@ class ASNeedlessTemplateScanner {
         }
     }
     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);
@@ -170,6 +175,10 @@ class ASNeedlessTemplateScanner {
         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-shadow-global.js

@@ -1,3 +1,4 @@
+import { visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 import { KNOWN_RUNTIME_GLOBALS } from "./known-globals.js";
 export function AS_SHADOW_GLOBAL(source, options = {}) {
@@ -21,6 +22,11 @@ class ASShadowGlobalScanner {
         }
     }
     visitStatement(node) {
+        if (node.type === "ClassDeclaration") {
+            this.reportIfGlobalShadow(node.id);
+            visitClassElements(node, expression => this.visitExpression(expression), statement => this.visitStatement(statement));
+            return;
+        }
         switch (node.type) {
             case "FunctionDeclaration":
                 this.visitArrowFunctionExpression(node);
@@ -147,6 +153,12 @@ class ASShadowGlobalScanner {
         }
     }
     visitExpression(node) {
+        if (node.type === "ClassExpression") {
+            if (node.id !== undefined)
+                this.reportIfGlobalShadow(node.id);
+            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-unbounded-loop.js

@@ -1,3 +1,4 @@
+import { visitClassElements } from "../class-elements.js";
 import { parseModule } from "../../parse/parser.js";
 const MESSAGE = "Unbounded loop or generator source has no static exit with break, return, or throw.";
 export function AS_UNBOUNDED_LOOP(source, options = {}) {
@@ -20,6 +21,10 @@ class ASUnboundedLoopScanner {
         }
     }
     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);
@@ -159,6 +164,10 @@ class ASUnboundedLoopScanner {
         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) {
@@ -330,6 +339,8 @@ function isTrueLiteral(node) {
 }
 function bodyHasExit(node, exitingLabels, allowUnlabeledBreak) {
     switch (node.type) {
+        case "ClassDeclaration":
+            return false;
         case "BlockStatement":
             return node.body.some((statement) => bodyHasExit(statement, exitingLabels, allowUnlabeledBreak));
         case "IfStatement":