@tsrx/core 0.1.46 → 0.1.48

package/src/transform/jsx/ast-builders.js

@@ -1,7 +1,8 @@
 /** @import * as AST from 'estree' */
 /** @import * as ESTreeJSX from 'estree-jsx' */
 
-import { set_location } from '../../utils/builders.js';
+import * as b from '../../utils/builders.js';
+import { has_location } from '../../utils/ast.js';
 
 /**
  * AST-building utilities shared across every JSX target (React, Preact,
@@ -13,15 +14,15 @@ import { set_location } from '../../utils/builders.js';
  * Attach `source_node`'s `loc` to `node` (deep), defaulting `node.metadata`
  * so downstream walks / serializers don't trip on it being undefined.
  *
- * @template T
+ * @template {AST.Node} T
  * @param {T} node
- * @param {any} source_node
+ * @param {AST.Node | AST.NodeWithLocation | undefined} source_node
  * @returns {T}
  */
 export function set_loc(node, source_node) {
-	/** @type {any} */ (node).metadata ??= { path: [] };
-	if (source_node?.loc) {
-		return /** @type {T} */ (set_location(/** @type {any} */ (node), source_node, true));
+	node.metadata ??= { path: [] };
+	if (has_location(source_node)) {
+		return b.set_location(node, source_node, true);
 	}
 	return node;
 }
@@ -35,97 +36,110 @@ export function set_loc(node, source_node) {
  * @returns {AST.Identifier}
  */
 export function clone_identifier(identifier) {
-	return set_loc(
-		/** @type {any} */ ({
-			type: 'Identifier',
-			name: identifier.name,
-			metadata: { path: [] },
-		}),
-		identifier,
-	);
+	return set_loc(b.id(identifier.name), identifier);
 }
 
 /**
  * Clone a JSX element name (handles `JSXIdentifier`, `JSXMemberExpression`,
  * and plain `Identifier`).
  *
- * @param {any} name
- * @param {any} [source_node]
- * @returns {any}
+ * @param {ESTreeJSX.TSRXJSXOpeningElement['name']} name
+ * @param {AST.Node} [source_node]
+ * @returns {ESTreeJSX.TSRXJSXOpeningElement['name']}
  */
 export function clone_jsx_name(name, source_node = name) {
-	if (!name) return name;
 	if (name.type === 'JSXIdentifier') {
-		return set_loc(
-			/** @type {any} */ ({
-				type: 'JSXIdentifier',
-				name: name.name,
-				metadata: name.metadata || { path: [] },
-			}),
-			source_node,
-		);
+		return clone_jsx_identifier(name, source_node);
 	}
 	if (name.type === 'JSXMemberExpression') {
-		return set_loc(
-			/** @type {any} */ ({
-				type: 'JSXMemberExpression',
-				object: clone_jsx_name(name.object, source_node.object || name.object),
-				property: clone_jsx_name(name.property, source_node.property || name.property),
-				metadata: name.metadata || { path: [] },
-			}),
-			source_node,
-		);
+		return clone_jsx_member_expression(name, source_node);
 	}
 	if (name.type === 'Identifier') {
-		return set_loc(
-			/** @type {any} */ ({
-				type: 'JSXIdentifier',
-				name: name.name,
-				metadata: name.metadata || { path: [] },
-			}),
-			source_node,
-		);
+		const clone = b.jsx_id(name.name);
+		clone.metadata = name.metadata || { path: [] };
+		return set_loc(clone, source_node);
 	}
 	return name;
 }
 
+/**
+ * @param {ESTreeJSX.JSXIdentifier} name
+ * @param {AST.Node} source_node
+ * @returns {ESTreeJSX.JSXIdentifier}
+ */
+function clone_jsx_identifier(name, source_node) {
+	const clone = b.jsx_id(name.name);
+	clone.metadata = name.metadata || { path: [] };
+	return set_loc(clone, source_node);
+}
+
+/**
+ * @param {ESTreeJSX.JSXMemberExpression} name
+ * @param {AST.Node} source_node
+ * @returns {ESTreeJSX.JSXMemberExpression}
+ */
+function clone_jsx_member_expression(name, source_node) {
+	const member_source = source_node.type === 'JSXMemberExpression' ? source_node : name;
+	const object =
+		name.object.type === 'JSXIdentifier'
+			? clone_jsx_identifier(
+					name.object,
+					member_source.object.type === 'JSXIdentifier' ? member_source.object : name.object,
+				)
+			: clone_jsx_member_expression(
+					name.object,
+					member_source.object.type === 'JSXMemberExpression' ? member_source.object : name.object,
+				);
+	const property = clone_jsx_identifier(name.property, member_source.property);
+	const clone = b.jsx_member(object, property);
+	clone.metadata = name.metadata || { path: [] };
+	return set_loc(clone, source_node);
+}
+
 /**
  * Record extra source positions on a generated expression so one generated
  * range can map back to several source ranges. Used for dynamic tags, where
  * the generated `is={expr}` value stands in for both `<{expr}` and `</{expr}>`;
  * segments.js turns each recorded node into an additional mapping token.
- * @param {any} generated
- * @param {any} source
+ * @param {AST.Node} generated
+ * @param {AST.Node | null | undefined} source
  * @returns {void}
  */
 export function add_extra_source_mappings_from_matching_expression(generated, source) {
 	if (!generated || !source || generated.type !== source.type) return;
 
 	if (generated.type === 'Identifier' || generated.type === 'PrivateIdentifier') {
-		if (!source.loc) return;
+		if (!has_location(source)) return;
 		generated.metadata ??= { path: [] };
 		generated.metadata.extra_source_mappings ??= [];
 		generated.metadata.extra_source_mappings.push(source);
 		return;
 	}
 
+	const generated_node = /** @type {AST.TraversableAstNode} */ (generated);
+	const source_node = /** @type {AST.TraversableAstNode} */ (source);
 	for (const key of ['expression', 'object', 'property']) {
-		if (generated[key] && source[key]) {
-			add_extra_source_mappings_from_matching_expression(generated[key], source[key]);
+		const generated_child = generated_node[key];
+		const source_child = source_node[key];
+		if (is_ast_node(generated_child) && is_ast_node(source_child)) {
+			add_extra_source_mappings_from_matching_expression(generated_child, source_child);
 		}
 	}
 }
 
+/**
+ * @param {unknown} value
+ * @returns {value is AST.Node}
+ */
+function is_ast_node(value) {
+	return !!value && typeof value === 'object' && 'type' in value;
+}
+
 /**
  * @returns {AST.Literal}
  */
 export function create_null_literal() {
-	return /** @type {any} */ ({
-		type: 'Literal',
-		value: null,
-		raw: 'null',
-		metadata: { path: [] },
-	});
+	return b.literal(null, 'null');
 }
 
 /**
@@ -133,15 +147,11 @@ export function create_null_literal() {
  * @returns {AST.Identifier}
  */
 export function create_generated_identifier(name) {
-	return /** @type {any} */ ({
-		type: 'Identifier',
-		name,
-		metadata: { path: [] },
-	});
+	return b.id(name);
 }
 
 /**
- * @param {any} node
+ * @param {AST.BaseNode} node
  * @param {string} message
  * @returns {Error & { pos: number, end: number }}
  */
@@ -160,33 +170,35 @@ export function create_compile_error(node, message) {
  * component hover label — without that flag those source-map adjustments
  * and editor hover features silently drop for any composite element.
  *
- * @param {any} id
- * @returns {any}
+ * @param {AST.Identifier | AST.MemberExpression} id
+ * @returns {ESTreeJSX.JSXIdentifier | ESTreeJSX.JSXMemberExpression}
  */
 export function identifier_to_jsx_name(id) {
-	if (!id) return id;
 	if (id.type === 'Identifier') {
-		return set_loc(
-			/** @type {any} */ ({
-				type: 'JSXIdentifier',
-				name: id.name,
-				metadata: { ...(id.metadata || {}), path: [], is_component: /^[A-Z]/.test(id.name) },
-			}),
-			id,
-		);
-	}
-	if (id.type === 'MemberExpression') {
-		return set_loc(
-			/** @type {any} */ ({
-				type: 'JSXMemberExpression',
-				object: identifier_to_jsx_name(id.object),
-				property: identifier_to_jsx_name(id.property),
-				metadata: id.metadata || { path: [] },
-			}),
-			id,
-		);
+		return identifier_to_jsx_identifier(id);
 	}
-	return id;
+	const object =
+		id.object.type === 'Identifier'
+			? identifier_to_jsx_name(id.object)
+			: identifier_to_jsx_name(/** @type {AST.MemberExpression} */ (id.object));
+	const property = identifier_to_jsx_identifier(/** @type {AST.Identifier} */ (id.property));
+	const name = b.jsx_member(object, property);
+	name.metadata = id.metadata || { path: [] };
+	return set_loc(name, id);
+}
+
+/**
+ * @param {AST.Identifier} id
+ * @returns {ESTreeJSX.JSXIdentifier}
+ */
+export function identifier_to_jsx_identifier(id) {
+	const name = b.jsx_id(id.name);
+	name.metadata = {
+		...(id.metadata || {}),
+		path: [],
+		is_component: /^[A-Z]/.test(id.name),
+	};
+	return set_loc(name, id);
 }
 
 /**
@@ -199,7 +211,7 @@ export function identifier_to_jsx_name(id) {
  * Used by platforms that veto static-hoisting of component JSX (Vue, Solid)
  * and by core's narrower bare-component-invocation predicate.
  *
- * @param {any} name
+ * @param {ESTreeJSX.TSRXJSXOpeningElement['name'] | AST.Identifier} name
  * @returns {boolean}
  */
 export function is_component_jsx_name(name) {
@@ -227,26 +239,25 @@ export function is_component_jsx_name(name) {
  * component instance to module identity, which doesn't help either framework
  * the way it helps React, so it's wasted output.
  *
- * @param {any} node
+ * @param {AST.Node | AST.Node[]} node
  * @returns {boolean}
  */
 export function contains_component_jsx(node) {
 	if (!node || typeof node !== 'object') {
 		return false;
 	}
-
-	if (node.type === 'JSXElement') {
+	if ('type' in node && node.type === 'JSXElement') {
 		if (is_component_jsx_name(node.openingElement?.name)) {
 			return true;
 		}
 		return node.children?.some(contains_component_jsx) ?? false;
 	}
 
-	if (node.type === 'JSXFragment') {
+	if ('type' in node && node.type === 'JSXFragment') {
 		return node.children?.some(contains_component_jsx) ?? false;
 	}
 
-	if (node.type === 'JSXExpressionContainer') {
+	if ('type' in node && node.type === 'JSXExpressionContainer') {
 		return contains_component_jsx(node.expression);
 	}
 
@@ -258,7 +269,7 @@ export function contains_component_jsx(node) {
 }
 
 /**
- * @param {any} node
+ * @param {AST.Node | null | undefined} node
  * @returns {boolean}
  */
 export function is_jsx_child(node) {
@@ -287,8 +298,8 @@ export function is_jsx_child(node) {
  * the unwrapped expression is still render output rather than an executable
  * statement.
  *
- * @param {any} node
- * @returns {boolean}
+ * @param {AST.Node | null | undefined} node
+ * @returns {node is AST.Expression}
  */
 export function is_bare_render_expression(node) {
 	if (!node || typeof node !== 'object') {
@@ -335,17 +346,17 @@ export function is_bare_render_expression(node) {
  * Gather the params a `for (x of y; index i)` loop should expose to its body
  * JSX (value first, optional index second).
  *
- * @param {any} left
- * @param {any} [index]
- * @returns {any[]}
+ * @param {AST.ForOfStatement['left']} left
+ * @param {AST.Identifier | null} [index]
+ * @returns {AST.Pattern[]}
  */
 export function get_for_of_iteration_params(left, index) {
-	/** @type {any[]} */
+	/** @type {AST.Pattern[]} */
 	const params = [];
 	if (left?.type === 'VariableDeclaration' && left.declarations?.[0]) {
 		params.push(left.declarations[0].id);
 	} else {
-		params.push(left);
+		params.push(/** @type {AST.Pattern} */ (left));
 	}
 	if (index) {
 		params.push(index);
@@ -359,8 +370,8 @@ export function get_for_of_iteration_params(left, index) {
  * under the case. This lets `case` arms use `{ ... }` for readability
  * without the block becoming a fresh scope at the JSX level.
  *
- * @param {any[]} consequent
- * @returns {any[]}
+ * @param {AST.Statement[]} consequent
+ * @returns {AST.Statement[]}
  */
 export function flatten_switch_consequent(consequent) {
 	const result = [];
@@ -404,12 +415,12 @@ function is_static_string_expression(expression) {
  * get the ternary because the AST alone can't prove they're non-null strings.
  *
  * @param {AST.Expression} expression
- * @param {any} [source_node]
+ * @param {AST.Node | AST.NodeWithLocation} [source_node]
  * @returns {AST.Expression}
  */
 export function to_text_expression(expression, source_node = expression) {
 	if (is_static_string_expression(expression)) {
-		return set_loc(clone_expression_node(expression), source_node);
+		return set_loc(clone_ast_node(expression), source_node);
 	}
 	return set_loc(
 		/** @type {AST.Expression} */ ({
@@ -417,7 +428,7 @@ export function to_text_expression(expression, source_node = expression) {
 			test: {
 				type: 'BinaryExpression',
 				operator: '==',
-				left: clone_expression_node(expression),
+				left: clone_ast_node(expression),
 				right: create_null_literal(),
 				metadata: { path: [] },
 			},
@@ -430,7 +441,7 @@ export function to_text_expression(expression, source_node = expression) {
 			alternate: {
 				type: 'BinaryExpression',
 				operator: '+',
-				left: clone_expression_node(expression),
+				left: clone_ast_node(expression),
 				right: {
 					type: 'Literal',
 					value: '',
@@ -448,24 +459,34 @@ export function to_text_expression(expression, source_node = expression) {
 /**
  * Deep-clone an AST subtree.
  *
- * @param {any} node
+ * @template T
+ * @param {T} node
  * @param {boolean} with_locations
- * @returns {any}
+ * @returns {T}
  */
-export function clone_expression_node(node, with_locations = true) {
+export function clone_ast_node(node, with_locations = true) {
 	if (!node || typeof node !== 'object') return node;
-	if (Array.isArray(node)) return node.map((child) => clone_expression_node(child, with_locations));
-	const clone = /** @type {Record<string, any>} */ ({});
+	if (Array.isArray(node)) {
+		return /** @type {T} */ (node.map((child) => clone_ast_node(child, with_locations)));
+	}
+	const clone = { ...node };
+	const clone_record = /** @type {Record<string, unknown>} */ (clone);
 
 	for (const key of Object.keys(node)) {
 		if (!with_locations && (key === 'loc' || key === 'start' || key === 'end')) {
+			delete clone_record[key];
 			continue;
 		}
 		if (key === 'metadata') {
-			clone.metadata = node.metadata ? { ...node.metadata } : { path: [] };
+			const metadata = /** @type {Record<string, unknown>} */ (node).metadata;
+			clone_record.metadata =
+				metadata && typeof metadata === 'object' ? { ...metadata } : { path: [] };
 			continue;
 		}
-		clone[key] = clone_expression_node(node[key], with_locations);
+		clone_record[key] = clone_ast_node(
+			/** @type {Record<string, unknown>} */ (node)[key],
+			with_locations,
+		);
 	}
 	return clone;
 }

package/src/transform/jsx/helpers.js

@@ -1,8 +1,9 @@
 /** @import * as AST from 'estree' */
-/** @import { Visitors } from 'zimmerframe' */
+/** @import * as ESRap from 'esrap' */
 
 import tsx from 'esrap/languages/tsx';
 import { should_preserve_comment, format_comment } from '../../comment-utils.js';
+import { with_deferred_imports } from '../imports.js';
 
 /**
  * Zimmerframe provides `path` as the ancestor chain. A native template node in
@@ -12,7 +13,7 @@ import { should_preserve_comment, format_comment } from '../../comment-utils.js'
  * transform built around render children — either way a bare expression in a
  * child slot would print as JSX text.
  *
- * @param {any[]} path
+ * @param {AST.Node[]} path
  * @returns {boolean}
  */
 export function in_jsx_child_context(path) {
@@ -21,15 +22,14 @@ export function in_jsx_child_context(path) {
 }
 
 /**
- * @param {any} node
+ * @param {AST.Node | null | undefined} node
  * @returns {boolean}
  */
 export function is_empty_jsx_fragment(node) {
 	return (
 		node?.type === 'JSXFragment' &&
 		!(node.children || []).some(
-			(/** @type {any} */ child) =>
-				child && (child.type !== 'JSXText' || child.value.trim() !== ''),
+			(child) => child && (child.type !== 'JSXText' || child.value.trim() !== ''),
 		)
 	);
 }
@@ -39,8 +39,8 @@ export function is_empty_jsx_fragment(node) {
  * carries its current ancestor path for downstream CSS pruning and mapping
  * helpers.
  *
- * @param {any} node
- * @param {any[]} path
+ * @param {AST.Node} node
+ * @param {AST.Node[]} path
  * @returns {void}
  */
 export function set_node_path_metadata(node, path) {
@@ -62,7 +62,7 @@ export function set_node_path_metadata(node, path) {
  *
  * Shared across all JSX-producing targets (React, Preact, Solid).
  *
- * @returns {any}
+ * @returns {ESRap.Visitors<AST.Node>}
  */
 /**
  * @param {boolean} [boundary_tokens] Enable esrap's `boundaryTokens` anchors
@@ -76,16 +76,17 @@ export function set_node_path_metadata(node, path) {
  * TS input — dropping a leading pragma changes how the whole file checks.
  */
 export function tsx_with_ts_locations(boundary_tokens = false, comments = undefined) {
-	const base = /** @type {any} */ (tsx({ boundaryTokens: boundary_tokens }));
+	const base = with_deferred_imports(tsx({ boundaryTokens: boundary_tokens }));
+	const { _: base_visitor, ...base_visitors } = base;
 
-	const leading_preserved = (/** @type {any} */ program) => {
+	const leading_preserved = (/** @type {AST.Program} */ program) => {
 		if (!comments?.length) return [];
 		// Injected statements (dynamic-import/try-import prepends) carry no
 		// loc; anchor "leading" on the first statement that maps to source,
 		// else every preserved comment in the file would hoist to the top.
-		const first = program.body?.find((/** @type {any} */ node) => node.loc);
+		const first = program.body.find((node) => node.loc);
 		return comments.filter(
-			(/** @type {any} */ comment) =>
+			(comment) =>
 				should_preserve_comment(comment) &&
 				(first?.loc == null ||
 					(comment.loc &&
@@ -95,22 +96,7 @@ export function tsx_with_ts_locations(boundary_tokens = false, comments = undefi
 		);
 	};
 
-	/**
-	 * @param {any} node
-	 * @param {any} context
-	 * @param {any} visitor
-	 */
-	const wrap_with_locations = (node, context, visitor) => {
-		if (!node.loc) {
-			visitor(node, context);
-			return;
-		}
-		context.location(node.loc.start.line, node.loc.start.column);
-		visitor(node, context);
-		context.location(node.loc.end.line, node.loc.end.column);
-	};
-
-	/** @type {Record<string, (node: any, context: any) => void>} */
+	/** @type {ESRap.Visitors<AST.Node>} */
 	const wrappers = {
 		Program: (node, context) => {
 			for (const comment of leading_preserved(node)) {
@@ -119,10 +105,10 @@ export function tsx_with_ts_locations(boundary_tokens = false, comments = undefi
 				if (comment.loc) context.location(comment.loc.end.line, comment.loc.end.column);
 				context.newline();
 			}
-			base.Program(node, context);
+			/** @type {NonNullable<typeof base.Program>} */ (base.Program)(node, context);
 		},
 		ArrayPattern: (node, context) => {
-			base.ArrayPattern(node, context);
+			/** @type {NonNullable<typeof base.ArrayPattern>} */ (base.ArrayPattern)(node, context);
 			if (node.typeAnnotation) {
 				context.visit(node.typeAnnotation);
 			}
@@ -143,7 +129,7 @@ export function tsx_with_ts_locations(boundary_tokens = false, comments = undefi
 		// must fall through to base.Property to preserve their printed form.
 		Property: (node, context) => {
 			if (!node.method || node.value.type !== 'FunctionExpression') {
-				base.Property(node, context);
+				/** @type {NonNullable<typeof base.Property>} */ (base.Property)(node, context);
 				return;
 			}
 			const value = node.value;
@@ -204,58 +190,68 @@ export function tsx_with_ts_locations(boundary_tokens = false, comments = undefi
 			context.visit(node.id);
 			context.visit(node.body);
 		},
+		_(node, context, visit) {
+			const visit_with_locations = () => {
+				if (!LOCATION_WRAPPED_NODE_TYPES.has(node.type) || !node.loc) {
+					visit(node);
+					return;
+				}
+				context.location(node.loc.start.line, node.loc.start.column);
+				visit(node);
+				context.location(node.loc.end.line, node.loc.end.column);
+			};
+			if (base_visitor) {
+				base_visitor(node, context, visit_with_locations);
+			} else {
+				visit_with_locations();
+			}
+		},
 	};
 
-	// Be careful when duplicating visitors that are already defined
-	// above in the `wrappers`
-	// if there is already a visitor but you still need a mapping
-	// on the whole node, only then duplicate it here
-	// e.g. JSXOpeningElement is such a case
-	for (const type of [
-		// JS nodes with boundary positions esrap still cannot map. Keyword
-		// writes (if/new/return/for/switch/await) and `boundaryTokens`
-		// anchors (brackets, braces, parens, computed/call closers) cover
-		// many STARTS, but statement ENDS land on unanchored characters
-		// (`;`, a block's `}`), `class` is not a keyword-write, template
-		// literals' backticks carry no location, and an arrow's span can
-		// start at a bare `(` — so these node-level markers remain the
-		// source of both boundaries until esrap can anchor them.
-		'ClassDeclaration',
-		'ClassExpression',
-		'IfStatement',
-		'NewExpression',
-		'MemberExpression',
-		'ObjectExpression',
-		'ReturnStatement',
-		'ForStatement',
-		'ForInStatement',
-		'ForOfStatement',
-		'TemplateLiteral',
-		'AwaitExpression',
-		'SwitchStatement',
-		'TaggedTemplateExpression',
-		'ArrowFunctionExpression',
-		// JSX wrapper nodes: esrap writes `<`, `>`, `</`, `{`, `}` without
-		// locations, so the opening/closing element's and expression
-		// container's start and end don't resolve.
-		'JSXOpeningElement',
-		'JSXClosingElement',
-		'JSXExpressionContainer',
-		// TS wrapper nodes with the same issue.
-		'TSTypeParameterInstantiation',
-		'TSTypeParameterDeclaration',
-		'TSTypeParameter',
-	]) {
-		const visitor = wrappers[type];
-
-		wrappers[type] = (node, context) => wrap_with_locations(node, context, visitor ?? base[type]);
-	}
-
-	return { ...base, ...wrappers };
+	return { ...base_visitors, ...wrappers };
 }
 
+// Be careful when adding visitors that are already defined in `wrappers`.
+// JSXOpeningElement is intentionally in both places: its custom printer still
+// needs a location marker around the whole node.
+const LOCATION_WRAPPED_NODE_TYPES = new Set([
+	// JS nodes with boundary positions esrap still cannot map. Keyword
+	// writes (if/new/return/for/switch/await) and `boundaryTokens`
+	// anchors (brackets, braces, parens, computed/call closers) cover
+	// many STARTS, but statement ENDS land on unanchored characters
+	// (`;`, a block's `}`), `class` is not a keyword-write, template
+	// literals' backticks carry no location, and an arrow's span can
+	// start at a bare `(` — so these node-level markers remain the
+	// source of both boundaries until esrap can anchor them.
+	'ClassDeclaration',
+	'ClassExpression',
+	'IfStatement',
+	'NewExpression',
+	'MemberExpression',
+	'ObjectExpression',
+	'ReturnStatement',
+	'ForStatement',
+	'ForInStatement',
+	'ForOfStatement',
+	'TemplateLiteral',
+	'AwaitExpression',
+	'SwitchStatement',
+	'TaggedTemplateExpression',
+	'ArrowFunctionExpression',
+	// JSX wrapper nodes: esrap writes `<`, `>`, `</`, `{`, `}` without
+	// locations, so the opening/closing element's and expression
+	// container's start and end don't resolve.
+	'JSXOpeningElement',
+	'JSXClosingElement',
+	'JSXExpressionContainer',
+	// TS wrapper nodes with the same issue.
+	'TSTypeParameterInstantiation',
+	'TSTypeParameterDeclaration',
+	'TSTypeParameter',
+]);
+
 /**
- * @param {any} node
+ * @param {AST.Node | null | undefined} node
  * @returns {boolean}
  */
 export function is_template_if_node(node) {
@@ -266,7 +262,7 @@ export function is_template_if_node(node) {
 }
 
 /**
- * @param {any} node
+ * @param {AST.Node | null | undefined} node
  * @returns {boolean}
  */
 export function is_template_for_of_node(node) {
@@ -277,7 +273,7 @@ export function is_template_for_of_node(node) {
 }
 
 /**
- * @param {any} node
+ * @param {AST.Node | null | undefined} node
  * @returns {boolean}
  */
 export function is_template_switch_node(node) {
@@ -288,7 +284,7 @@ export function is_template_switch_node(node) {
 }
 
 /**
- * @param {any} node
+ * @param {AST.Node | null | undefined} node
  * @returns {boolean}
  */
 export function is_template_try_node(node) {