octane 0.2.11 → 0.2.13

package/dist/compiler/slot-hooks.js

@@ -17,14 +17,16 @@ import { parseModule, builders as b } from '@tsrx/core';
 import { parseModule as parseFallbackModule } from '#octane/compiler-parser';
 import { HOOK_NAMES, hookSlotHash } from './compile.js';
 import { NATIVE_SIGNAL_HOOK_NAMES } from './hook-names.js';
-import { METHOD_DEP_IMPORT, annotateHookCalls } from './hook-deps.js';
+import { METHOD_DEP_IMPORT, annotateHookCalls, analyzeStrongMemoCandidates } from './hook-deps.js';
 import { inlinePlainHookMemos } from './plain-hook-memo.js';
 import { assertStrongMode } from './strong-mode.js';
+import { unsupportedStrongAutomaticMemo } from './strong-auto-memo.js';
 import { assertNativeReadDiagnostics, nativeReadOptions } from './native-read-diagnostics.js';
 import { nativeReadActivationIndex } from './native-read-codegen.js';
 import { findManualHookProviders, manualHookWrapperParameters } from './manual-hooks.js';
 import { findLeadingJsxImportSourcePragma } from './pragma.js';
 import { collectProvenContextBindings, isProvenContextUse } from './context-use.js';
+import { signalDeclarationSourceEdits } from './signal-declarations.js';
 import {
 	hookMethodName,
 	hasHookMethods,
@@ -1109,6 +1111,43 @@ function emitHookMethodChain(node, owner, st) {
 	return true;
 }
 
+function strongCallSeparator(node, st) {
+	// Parser expression ranges omit grouping parentheses. Append at the CALL
+	// delimiter so a new slot never becomes part of an authored comma expression.
+	const tail = st.source
+		.slice(node.arguments.at(-1)?.end ?? node.start, node.end - 1)
+		.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, '')
+		.trimEnd();
+	return tail.endsWith(',') ? ' ' : ', ';
+}
+
+function emitInferredDependencies(dependencies, st) {
+	return dependencies
+		.map((dependency) =>
+			dependency.method
+				? `${requireParallelHelper(st, METHOD_DEP_IMPORT)}(${dependency.method.root.name}, ${JSON.stringify(dependency.method.name)})`
+				: st.source.slice(dependency.node.start, dependency.node.end),
+		)
+		.join(', ');
+}
+
+function emitStrongMemo(node, owner, st) {
+	if (node.type !== 'VariableDeclarator') return;
+	const memo = st.strongMemos?.get(node.start);
+	if (!memo) return;
+	const slot = allocHookSymbol(st, owner, node.id.name, memo.hook, node.init);
+	const helper = requireParallelHelper(
+		st,
+		st.nativeReads && memo.hook === 'useMemo' ? 'nativePuMemo' : memo.hook,
+	);
+	const dependencyText = emitInferredDependencies(memo.dependencies, st);
+	st.edits.push({
+		pos: node.init.start,
+		text: `${helper}(${memo.hook === 'useMemo' ? '() => ' : ''}(`,
+	});
+	st.edits.push({ pos: node.init.end, text: `), [${dependencyText}], ${slot})` });
+}
+
 function walk(node, owner, st) {
 	if (!node || typeof node !== 'object') return;
 	if (Array.isArray(node)) {
@@ -1116,6 +1155,8 @@ function walk(node, owner, st) {
 		return;
 	}
 
+	emitStrongMemo(node, owner, st);
+
 	// A `const x = (…) => …` / `function …` gives the enclosing name used in the
 	// (debug-only) slot key. For a named declaration the id is on the node; for an
 	// arrow/expr assigned to a `const`, take the declarator name.
@@ -1195,17 +1236,17 @@ function walk(node, owner, st) {
 				// dependencies are the one synthesized form: the helper call's root is
 				// a bare identifier and its name a JSON string, so no arbitrary TS
 				// syntax needs reprinting there either.
-				const deps = inferred.dependencies
-					.map((dependency) =>
-						dependency.method
-							? `${requireParallelHelper(st, METHOD_DEP_IMPORT)}(${dependency.method.root.name}, ${JSON.stringify(dependency.method.name)})`
-							: st.source.slice(dependency.node.start, dependency.node.end),
-					)
-					.join(', ');
-				st.edits.push({
-					pos: node.arguments[node.arguments.length - 1].end,
-					text: `, [${deps}], ${sym}`,
-				});
+				const deps = emitInferredDependencies(inferred.dependencies, st);
+				if (inferred.replaceDependency) {
+					const argument = node.arguments[inferred.depsIndex];
+					st.edits.push({ pos: argument.start, end: argument.end, text: `[${deps}]` });
+					st.edits.push({ pos: node.end - 1, text: `${strongCallSeparator(node, st)}${sym}` });
+				} else {
+					st.edits.push({
+						pos: st.strong ? node.end - 1 : node.arguments[node.arguments.length - 1].end,
+						text: `${st.strong ? strongCallSeparator(node, st) : ', '}[${deps}], ${sym}`,
+					});
+				}
 			} else if (node.arguments.length === 0) {
 				// State/ref initializers may themselves be Symbols. Reserve their
 				// authored position even when empty; other hooks keep their ABI.
@@ -1217,8 +1258,8 @@ function walk(node, owner, st) {
 				// `useState(0)` → `useState(0, _h$N)` — insert AFTER the last arg's end so
 				// trailing commas / whitespace before `)` stay valid.
 				st.edits.push({
-					pos: node.arguments[node.arguments.length - 1].end,
-					text: ', ' + sym,
+					pos: st.strong ? node.end - 1 : node.arguments[node.arguments.length - 1].end,
+					text: (st.strong ? strongCallSeparator(node, st) : ', ') + sym,
 				});
 			}
 		}
@@ -1297,7 +1338,7 @@ function parseHookSource(source, id) {
  *   `inlineHookMemo: true` enables the production-client whole-AST memo path;
  *   the default remains surgical. `manualSlots: true` permits memo and observed
  *   getter rewrites without injecting or changing the authored slot policy.
- * @returns {{ code: string, map: any } | null}
+ * @returns {{ code: string, map: any, streamedSignals?: true, diagnostics?: any[] } | null}
  */
 export function slotHooks(source, id, options) {
 	const environment = options?.environment ?? 'client';
@@ -1314,15 +1355,34 @@ export function slotHooks(source, id, options) {
 		return null; // let the normal pipeline surface the parse error
 	}
 	options = nativeReadOptions(ast, options);
-	assertStrongMode(ast, source, id, options);
+	const strongAnalysis = assertStrongMode(ast, source, id, { ...options, onlyImported: true });
+	const strongHints = strongAnalysis?.diagnostics.length
+		? { diagnostics: strongAnalysis.diagnostics }
+		: {};
 	assertNativeReadDiagnostics(ast, source, id, options);
+	const strongHookAnalysis = strongAnalysis?.strongHookAnalysis ?? null;
+	const strongPlan = strongHookAnalysis
+		? analyzeStrongMemoCandidates(ast, { ...options, onlyImported: true, strongHookAnalysis })
+		: null;
+	if (strongPlan?.candidates.size && options?.manualSlots)
+		throw unsupportedStrongAutomaticMemo(
+			ast.body[0],
+			id,
+			'Strong declaration caching cannot add cache slots to a manually slotted module.',
+		);
 	const importInfo = octaneHookLocals(
 		ast,
 		options?.nativeReads === true,
-		findLeadingJsxImportSourcePragma(source) === 'octane',
+		// The bundler claims both pragmas for Octane (see pragmaOwnedModules).
+		['octane', 'octane/strong'].includes(findLeadingJsxImportSourcePragma(source)),
 	);
+	if (strongHookAnalysis?.callNames.size)
+		importInfo.importsHook ||= [...strongHookAnalysis.callNames.values()].some((name) =>
+			HOOK_NAMES.has(name),
+		);
 	const manualProviders = options?.manualSlots ? findManualHookProviders(ast) : new Map();
 	const nativeReadActivation = options?.nativeReads === true && importsNativeRenderer(ast);
+	const signalLowering = signalDeclarationSourceEdits(ast, id, source);
 	const canSpecializeRoot =
 		!options?.manualSlots &&
 		!options?.hmr &&
@@ -1333,9 +1393,10 @@ export function slotHooks(source, id, options) {
 		!importInfo.importsHook &&
 		!canSpecializeRoot &&
 		!nativeReadActivation &&
+		!signalLowering.usesSignals &&
 		!manualProviders.size
 	) {
-		return null;
+		return strongAnalysis?.diagnostics.length ? { code: source, map: null, ...strongHints } : null;
 	}
 	// The parsed tree is never mutated: annotateHookCalls returns a COW-rebuilt
 	// module whose hook calls carry their `_octane*` props (start/end offsets are
@@ -1346,6 +1407,7 @@ export function slotHooks(source, id, options) {
 		const annotated = annotateHookCalls(ast, {
 			filename: id,
 			onlyImported: true,
+			...(strongHookAnalysis ? { strongHookAnalysis } : {}),
 			nativeReads: options?.nativeReads === true,
 			...(options?.nativeReads === true
 				? { hookRuntimeModules: ['octane/signals/client', 'octane/signals/server'] }
@@ -1357,6 +1419,9 @@ export function slotHooks(source, id, options) {
 	}
 	const getterCalls = importInfo.importsHook ? collectStateGetterCalls(ast) : new WeakSet();
 	if (
+		!strongAnalysis?.enabled &&
+		// The whole-AST memo path does not apply declaration identity edits.
+		!signalLowering.usesSignals &&
 		canPrint &&
 		options?.inlineHookMemo === true &&
 		environment === 'client' &&
@@ -1380,9 +1445,16 @@ export function slotHooks(source, id, options) {
 			getterCalls,
 			stateGetterHelpers: STATE_GETTER_HELPERS,
 		});
-		if (inlined !== null) return inlined;
+		if (inlined !== null) return { ...inlined, ...strongHints };
 	}
 	const st = {
+		strong: strongAnalysis?.enabled === true,
+		strongMemos: new Map(
+			[...(strongPlan?.candidates ?? [])].map(([node, hook]) => [
+				node.start,
+				{ hook, dependencies: strongPlan.candidateDependencies.get(node) },
+			]),
+		),
 		manualSlots: options?.manualSlots === true,
 		nativeReads: options?.nativeReads === true,
 		locals: importInfo.locals,
@@ -1398,7 +1470,7 @@ export function slotHooks(source, id, options) {
 		hash: hookSlotHash(id),
 		nextId: 0,
 		nextPuId: 0,
-		edits: [],
+		edits: [...signalLowering.edits],
 		decls: [],
 		parallelHelpers: new Map(),
 		provenContextBindings: collectProvenContextBindings(ast),
@@ -1418,7 +1490,8 @@ export function slotHooks(source, id, options) {
 	if (canSpecializeRoot) {
 		collectVoidRootEdits(ast, st, options.isVoidComponentImport);
 	}
-	if (st.edits.length === 0 && !nativeReadActivation) return null;
+	if (st.edits.length === 0 && !nativeReadActivation && !signalLowering.usesSignals)
+		return strongAnalysis?.diagnostics.length ? { code: source, map: null, ...strongHints } : null;
 	const activation = nativeReadActivation
 		? requireParallelHelper(st, 'enableNativeReadCollection')
 		: null;
@@ -1458,6 +1531,35 @@ export function slotHooks(source, id, options) {
 	const otherHelperImports = [...otherHelpers]
 		.map(([request, specifiers]) => `import { ${specifiers.join(', ')} } from '${request}';\n`)
 		.join('');
+	const signalHelperImports = new Map();
+	for (const helper of signalLowering.imports) {
+		let specifiers = signalHelperImports.get(helper.source);
+		if (specifiers === undefined) signalHelperImports.set(helper.source, (specifiers = []));
+		specifiers.push(`${helper.imported} as ${helper.local}`);
+	}
+	let signalActivation = '';
+	if (signalLowering.usesSignals) {
+		const request =
+			environment === 'server'
+				? 'octane/internal/server'
+				: nativeReadActivation
+					? 'octane/internal/client'
+					: 'octane/signals';
+		const imported =
+			environment === 'server'
+				? 'enableServerSignalBindings'
+				: nativeReadActivation
+					? 'enableSignalBindings'
+					: '__enableSignalDocument';
+		const local = allocSlotName(st, `_$${imported}`);
+		let specifiers = signalHelperImports.get(request);
+		if (specifiers === undefined) signalHelperImports.set(request, (specifiers = []));
+		specifiers.push(`${imported} as ${local}`);
+		signalActivation = `${local}(1);\n`;
+	}
+	const signalImports = [...signalHelperImports]
+		.map(([request, specifiers]) => `import { ${specifiers.join(', ')} } from '${request}';\n`)
+		.join('');
 	const profileImport =
 		st.profile && !st.manualSlots
 			? "import { __profileHook as _$__profileHook } from 'octane/profiling';\n"
@@ -1467,26 +1569,58 @@ export function slotHooks(source, id, options) {
 			? `const ${st.slotBaseName} = /* @__PURE__ */ ${st.hookSlotsName}(${st.nextId});\n`
 			: '';
 	const block =
-		helperImport + otherHelperImports + profileImport + slotBase + st.decls.join('\n') + '\n';
-	if (activation !== null) {
-		// Native plain modules can render a local function during evaluation.
-		// Its slots and invocation collector must already exist at that call.
+		helperImport +
+		otherHelperImports +
+		signalImports +
+		profileImport +
+		slotBase +
+		st.decls.join('\n') +
+		'\n' +
+		signalActivation;
+	if (activation !== null || signalLowering.usesSignals) {
+		// Plain modules may read global signals or render during evaluation.
+		// Their document capability and any render slots must already exist.
 		// No newline is inserted, retaining the surgical pass's line mapping.
 		const index = nativeReadActivationIndex(ast.body);
 		st.edits.push({
 			pos: ast.body[index]?.start ?? source.length,
-			text: `;${block.replace(/\n/g, ' ')}${activation}(1); `,
+			text: `;${block.replace(/\n/g, ' ')}${activation === null ? '' : `${activation}(1); `}`,
 		});
 	}
-	// Apply insertions right-to-left so earlier offsets stay valid.
+	// Assemble disjoint edits once instead of copying the growing module for
+	// every insertion. Descending, stable order retains the existing rule that
+	// later insertions at the same offset appear before earlier insertions.
 	st.edits.sort((a, b) => b.pos - a.pos);
-	let code = source;
+	const chunks = [];
+	let cursor = source.length;
+	let overlaps = false;
 	for (const edit of st.edits) {
-		code =
-			code.slice(0, edit.pos) +
-			edit.text +
-			code.slice(edit.end === undefined ? edit.pos : edit.end);
+		const end = edit.end ?? edit.pos;
+		if (end > cursor) {
+			overlaps = true;
+			break;
+		}
+		chunks.push(source.slice(end, cursor), edit.text);
+		cursor = edit.pos;
 	}
-	if (activation === null) code = code.endsWith('\n') ? code + block : code + '\n' + block;
-	return { code, map: null };
+	let code;
+	if (overlaps) {
+		// Overlapping replacements refer to the already edited text. Preserve
+		// that sequential behavior, including insertion/replacement ties.
+		code = source;
+		for (const edit of st.edits) {
+			code = code.slice(0, edit.pos) + edit.text + code.slice(edit.end ?? edit.pos);
+		}
+	} else {
+		chunks.push(source.slice(0, cursor));
+		code = chunks.reverse().join('');
+	}
+	if (activation === null && !signalLowering.usesSignals)
+		code = code.endsWith('\n') ? code + block : code + '\n' + block;
+	return {
+		code,
+		map: null,
+		...(signalLowering.usesSignals || nativeReadActivation ? { streamedSignals: true } : null),
+		...strongHints,
+	};
 }

package/dist/compiler/strong-auto-memo.js

@@ -0,0 +1,90 @@
+import { builders as b } from '@tsrx/core';
+import { inheritHookMemoOrigin as origin } from './inline-hook-memo.js';
+import { analyzeStrongMemoCandidates, STRONG_AUTOMATIC_MEMO_UNSUPPORTED } from './hook-deps.js';
+
+const SKIP_KEYS = new Set(['loc', 'start', 'end', 'range', 'metadata', 'parent']);
+
+export function unsupportedStrongAutomaticMemo(node, filename, message) {
+	const line = node?.loc?.start?.line ?? 1;
+	const column = node?.loc?.start?.column ?? 0;
+	const error = new SyntaxError(
+		`${filename ?? '<anonymous>'}:${line}:${column + 1}: [${STRONG_AUTOMATIC_MEMO_UNSUPPORTED}] ${message}`,
+	);
+	Object.assign(error, {
+		code: STRONG_AUTOMATIC_MEMO_UNSUPPORTED,
+		filename,
+		loc: { line, column },
+		pos: node?.start ?? 0,
+		end: node?.end ?? 0,
+	});
+	return error;
+}
+
+/**
+ * Cache eligible Strong declarations before dependency inference. These hooks
+ * retain effect/subscription identity in development as well as production;
+ * later production passes may inline the same runtime cache semantics.
+ * The caller invokes this only after validating authored Strong source.
+ */
+export function applyStrongAutomaticMemo(ast, options = {}) {
+	const { candidates, names, hookCalls, omittedDependencies } = analyzeStrongMemoCandidates(
+		ast,
+		options,
+	);
+	if (candidates.size === 0 && hookCalls.size === 0 && omittedDependencies.size === 0) return ast;
+	const aliases = new Map();
+	for (const hook of new Set([...candidates.values(), ...hookCalls.values()])) {
+		let alias = `_$strong${hook}`;
+		while (names.has(alias)) alias += '_';
+		names.add(alias);
+		aliases.set(hook, alias);
+	}
+	function rebuild(node) {
+		if (!node || typeof node !== 'object') return node;
+		if (Array.isArray(node)) {
+			const children = node.map(rebuild);
+			return children.some((child, index) => child !== node[index]) ? children : node;
+		}
+		const importedHook = hookCalls.get(node);
+		const omittedDependency = omittedDependencies.has(node);
+		if (importedHook || omittedDependency) {
+			// Built-in exports are immutable and defined: normalize proven aliases
+			// and optional calls so existing dependency/slot passes see their ABI.
+			return {
+				...node,
+				callee: importedHook ? b.id(aliases.get(importedHook), node.callee) : rebuild(node.callee),
+				optional: false,
+				arguments: rebuild(node.arguments),
+				// Replace the proven placeholder during inference, keeping later slot
+				// arguments at their authored positions. Never rewrite an array.
+				...(omittedDependency ? { _octaneStrongOmittedDependency: true } : {}),
+			};
+		}
+		const hook = candidates.get(node);
+		if (hook) {
+			const initial = rebuild(node.init);
+			const callback = hook === 'useCallback' ? initial : origin(b.arrow([], initial), node.init);
+			return { ...node, init: origin(b.call(b.id(aliases.get(hook)), callback), node.init) };
+		}
+		let output = node;
+		for (const key in node) {
+			if (SKIP_KEYS.has(key)) continue;
+			const value = rebuild(node[key]);
+			if (value !== node[key]) {
+				if (output === node) output = { ...node };
+				output[key] = value;
+			}
+		}
+		return output;
+	}
+	const result = rebuild(ast);
+	if (aliases.size === 0) return result;
+	const imports = origin(
+		b.imports(
+			[...aliases].map(([hook, alias]) => [hook, alias]),
+			'octane',
+		),
+		ast.body.find((node) => node.loc) ?? ast,
+	);
+	return { ...result, body: [...result.body, imports] };
+}

package/dist/compiler/strong-html.js

@@ -0,0 +1,143 @@
+import { createRendererRegionResolver } from './renderer-boundaries.js';
+
+export const STRONG_UNTRUSTED_HTML = 'OCTANE_STRONG_UNTRUSTED_HTML';
+export const STRONG_HTML_MESSAGE =
+	'Strong mode requires a TrustedHTML value for dangerouslySetInnerHTML. Use trustHTML() only for trusted or already sanitized HTML; trustHTML() does not sanitize its input.';
+const SKIP_KEYS = new Set(['type', 'loc', 'start', 'end', 'range', 'metadata', 'parent']);
+const TRANSPARENT = new Set([
+	'ParenthesizedExpression',
+	'TSAsExpression',
+	'TSSatisfiesExpression',
+	'TSTypeAssertion',
+	'TSNonNullExpression',
+	'TSInstantiationExpression',
+]);
+
+// Identifier escapes use Unicode; quoted property names also admit hex and
+// escaped letters. Ordinary escapes such as a newline cannot spell this key.
+export function mayHaveStrongHTML(source) {
+	return (
+		source.includes('dangerouslySetInnerHTML') ||
+		/\\(?:u|x|[dageoslySIHTML]|[\r\n\u2028\u2029])/.test(source)
+	);
+}
+
+function unwrap(node) {
+	while (node && TRANSPARENT.has(node.type)) node = node.expression;
+	return node;
+}
+
+function propertyName(node) {
+	return node?.type === 'Identifier' || node?.type === 'JSXIdentifier' ? node.name : node?.value;
+}
+
+export function checkStrongHTMLValue(expression, report) {
+	const node = unwrap(expression);
+	if (!node) return;
+	switch (node.type) {
+		case 'ObjectExpression':
+			// A spread of an existing branded value retains its type. The type
+			// checker verifies that value rather than rejecting all object syntax.
+			if (!node.properties.some((property) => property.type === 'SpreadElement')) report(node);
+			return;
+		case 'Literal':
+			if (node.value !== null) report(node);
+			return;
+		case 'TemplateLiteral':
+		case 'ArrayExpression':
+		case 'ArrowFunctionExpression':
+		case 'FunctionExpression':
+			report(node);
+			return;
+		case 'ConditionalExpression':
+			checkStrongHTMLValue(node.consequent, report);
+			checkStrongHTMLValue(node.alternate, report);
+			return;
+		case 'LogicalExpression':
+			checkStrongHTMLValue(node.left, report);
+			checkStrongHTMLValue(node.right, report);
+			return;
+		case 'SequenceExpression':
+			checkStrongHTMLValue(node.expressions.at(-1), report);
+	}
+}
+// Resolve only a statically visible final writer. An unknown later spread
+// may replace an earlier raw value, so its actual type belongs to TypeScript.
+export function strongHTMLSpreadWriter(expression) {
+	const node = unwrap(expression);
+	if (node?.type !== 'ObjectExpression') return undefined;
+	for (let index = node.properties.length - 1; index >= 0; index--) {
+		const property = node.properties[index];
+		if (property.type === 'SpreadElement') {
+			const writer = strongHTMLSpreadWriter(property.argument);
+			if (writer !== null) return writer;
+		} else if (property.type === 'Property') {
+			if (property.computed && property.key.type !== 'Literal') return undefined;
+			if (propertyName(property.key) === 'dangerouslySetInnerHTML')
+				return property.kind === 'init' ? property.value : undefined;
+		}
+	}
+	return null;
+}
+
+/**
+ * A syntax-only compiler can reject visibly unbranded values. Imported values,
+ * props, aliases and function results are checked by Strong's nominal JSX types
+ * in Volar/tsrx-tsc; guessing their types here would reject valid trust boundaries.
+ */
+export function analyzeStrongHTML(ast, source, filename, options = {}) {
+	if (!mayHaveStrongHTML(source)) return [];
+	const diagnostics = [];
+	const reported = new WeakSet();
+	const isDOM =
+		options.rendererRegionResolver ?? createRendererRegionResolver(ast, source, filename, options);
+	function report(node) {
+		if (reported.has(node)) return;
+		reported.add(node);
+		const position = (edge) => ({
+			offset: node[edge] ?? 0,
+			line: node.loc?.[edge]?.line ?? 1,
+			column: node.loc?.[edge]?.column ?? 0,
+		});
+		diagnostics.push({
+			code: STRONG_UNTRUSTED_HTML,
+			severity: 'error',
+			filename,
+			start: position('start'),
+			end: position('end'),
+			message: STRONG_HTML_MESSAGE,
+			suggestions: [],
+		});
+	}
+	function visit(node) {
+		if (!node || typeof node !== 'object') return;
+		if (Array.isArray(node)) {
+			for (const item of node) visit(item);
+			return;
+		}
+		if (
+			node.type === 'JSXOpeningElement' &&
+			node.name?.type === 'JSXIdentifier' &&
+			/^[a-z]/.test(node.name.name) &&
+			isDOM(node)
+		) {
+			for (let index = node.attributes.length - 1; index >= 0; index--) {
+				const attribute = node.attributes[index];
+				if (attribute.type === 'JSXSpreadAttribute') {
+					const writer = strongHTMLSpreadWriter(attribute.argument);
+					if (writer === null) continue;
+					checkStrongHTMLValue(writer, report);
+					break;
+				} else if (propertyName(attribute.name) === 'dangerouslySetInnerHTML') {
+					if (attribute.value?.type === 'JSXExpressionContainer')
+						checkStrongHTMLValue(attribute.value.expression, report);
+					else report(attribute.value ?? attribute);
+					break;
+				}
+			}
+		}
+		for (const key of Object.keys(node)) if (!SKIP_KEYS.has(key)) visit(node[key]);
+	}
+	visit(ast);
+	return diagnostics;
+}