@tsrx/core 0.1.20 → 0.1.24

package/package.json

@@ -3,7 +3,7 @@
   "description": "Core compiler infrastructure for TSRX syntax",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.1.20",
+  "version": "0.1.24",
   "type": "module",
   "repository": {
     "type": "git",
@@ -60,10 +60,10 @@
   "dependencies": {
     "@jridgewell/sourcemap-codec": "^1.5.5",
     "@noble/hashes": "^2.2.0",
-    "@sveltejs/acorn-typescript": "^1.0.9",
+    "@sveltejs/acorn-typescript": "^1.0.10",
     "@types/estree-jsx": "^1.0.5",
     "@types/estree": "^1.0.8",
-    "acorn": "^8.15.0",
+    "acorn": "^8.16.0",
     "esrap": "^2.2.8",
     "is-reference": "^3.0.3",
     "magic-string": "^0.30.18",

package/src/analyze/prune.js

@@ -19,30 +19,72 @@ let style_identifier_classes;
 /** @type {TopScopedClasses} */
 let top_scoped_classes;
 
+/**
+ * @param {any} node
+ * @returns {boolean}
+ */
+function is_native_jsx_element(node) {
+	return node?.type === 'JSXElement' && node.metadata?.native_tsrx;
+}
+
+/**
+ * @param {any} node
+ * @returns {any}
+ */
+function get_element_name(node) {
+	return node.openingElement?.name ?? node.id;
+}
+
+/**
+ * @param {any} node
+ * @returns {any[]}
+ */
+function get_element_attributes(node) {
+	return node.openingElement?.attributes ?? node.attributes ?? [];
+}
+
+/**
+ * @param {any} attribute
+ * @returns {string | null}
+ */
+function get_attribute_name(attribute) {
+	const name = attribute.name;
+	if (name?.type === 'JSXIdentifier' || name?.type === 'Identifier') return name.name;
+	return null;
+}
+
+/**
+ * @param {any} attribute
+ * @returns {any}
+ */
+function get_attribute_value(attribute) {
+	const value = attribute.value;
+	return value?.type === 'JSXExpressionContainer' ? value.expression : value;
+}
+
+/**
+ * @param {AST.Node} node
+ * @returns {boolean}
+ */
+function is_runtime_dynamic_element(node) {
+	return node?.metadata?.runtime_dynamic_element === true;
+}
+
 /**
  * Returns true if node is a DOM element (not a component).
  * @param {AST.Node} node
  * @returns {boolean}
  */
 function is_element_dom_element(node) {
-	const id = /** @type {AST.Element} */ (node).id;
+	const id = get_element_name(node);
 	return (
-		id.type === 'Identifier' &&
+		(id.type === 'Identifier' || id.type === 'JSXIdentifier') &&
 		id.name[0].toLowerCase() === id.name[0] &&
 		id.name !== 'children' &&
 		!id.tracked
 	);
 }
 
-/**
- * Returns true if element is dynamic.
- * @param {AST.Element} node
- * @returns {boolean}
- */
-function is_element_dynamic(node) {
-	return node.id.type === 'Identifier' ? !!node.id.tracked : false;
-}
-
 // CSS selector constants
 /**
  * @param {number} start
@@ -220,7 +262,7 @@ function truncate(node) {
 /**
  * @param {AST.CSS.RelativeSelector[]} relative_selectors
  * @param {AST.CSS.Rule} rule
- * @param {AST.Element} element
+ * @param {any} element
  * @param {Direction} direction
  * @returns {boolean}
  */
@@ -271,12 +313,12 @@ function apply_selector(relative_selectors, rule, element, direction) {
 }
 
 /**
- * @param {AST.Element} node
+ * @param {any} node
  * @param {boolean} adjacent_only
- * @returns {AST.Element[]}
+ * @returns {any[]}
  */
 function get_ancestor_elements(node, adjacent_only) {
-	/** @type {AST.Element[]} */
+	/** @type {any[]} */
 	const ancestors = [];
 
 	const path = node.metadata.path;
@@ -285,7 +327,7 @@ function get_ancestor_elements(node, adjacent_only) {
 	while (i--) {
 		const parent = path[i];
 
-		if (parent.type === 'Element') {
+		if (is_native_jsx_element(parent)) {
 			ancestors.push(parent);
 			if (adjacent_only) {
 				break;
@@ -297,12 +339,12 @@ function get_ancestor_elements(node, adjacent_only) {
 }
 
 /**
- * @param {AST.Element} node
+ * @param {any} node
  * @param {boolean} adjacent_only
- * @returns {AST.Element[]}
+ * @returns {any[]}
  */
 function get_descendant_elements(node, adjacent_only) {
-	/** @type {AST.Element[]} */
+	/** @type {any[]} */
 	const descendants = [];
 
 	/**
@@ -311,26 +353,23 @@ function get_descendant_elements(node, adjacent_only) {
 	 * @returns {void}
 	 */
 	function visit(current_node, depth = 0) {
-		if (current_node.type === 'Element' && current_node !== node) {
+		if (is_native_jsx_element(current_node) && current_node !== node) {
 			descendants.push(current_node);
 			if (adjacent_only) return; // Only direct children for '>' combinator
 		}
 
-		// Visit children based on TSRX's template AST structure
-		if (/** @type {AST.Element} */ (current_node).children) {
-			for (const child of /** @type {AST.Element} */ (current_node).children) {
+		if (Array.isArray(/** @type {any} */ (current_node).children)) {
+			for (const child of /** @type {any} */ (current_node).children) {
 				visit(child, depth + 1);
 			}
 		}
 
-		// For template nodes and interpolation expressions
 		if (
-			(current_node.type === 'TSRXExpression' || current_node.type === 'Text') &&
-			/** @type {AST.TSRXExpression | AST.TextNode} */ (current_node).expression &&
-			typeof (/** @type {AST.TSRXExpression | AST.TextNode} */ (current_node).expression) ===
-				'object'
+			current_node.type === 'JSXExpressionContainer' &&
+			current_node.expression &&
+			typeof current_node.expression === 'object'
 		) {
-			visit(/** @type {AST.TSRXExpression | AST.TextNode} */ (current_node).expression, depth + 1);
+			visit(current_node.expression, depth + 1);
 		}
 	}
 
@@ -351,24 +390,23 @@ function get_descendant_elements(node, adjacent_only) {
  * @returns {boolean}
  */
 function can_render_dynamic_content(element, check_classes = false) {
-	if (!is_element_dom_element(element)) {
+	if (is_runtime_dynamic_element(element)) {
 		return true;
 	}
 
-	// Either a dynamic element or component (only can tell at runtime)
-	// But dynamic elements should return false ideally
-	if (is_element_dynamic(/** @type {AST.Element} */ (element))) {
+	if (!is_element_dom_element(element)) {
 		return true;
 	}
 
 	// Check for dynamic class attributes if requested (for class-based selectors)
-	if (check_classes && /** @type {AST.Element} */ (element).attributes) {
-		for (const attr of /** @type {AST.Element} */ (element).attributes) {
-			if (attr.type === 'Attribute' && attr.name.name === 'class') {
+	if (check_classes) {
+		for (const attr of get_element_attributes(element)) {
+			if (attr.type === 'JSXAttribute' && get_attribute_name(attr) === 'class') {
+				const value = get_attribute_value(attr);
 				// Check if class value is an expression (not a static string)
-				if (attr.value && typeof attr.value === 'object') {
+				if (value && typeof value === 'object') {
 					// If it's a CallExpression or other dynamic value, it's dynamic
-					if (attr.value.type !== 'Literal' && attr.value.type !== 'Text') {
+					if (value.type !== 'Literal') {
 						return true;
 					}
 				}
@@ -383,7 +421,7 @@ function can_render_dynamic_content(element, check_classes = false) {
  * @param {AST.Node} node
  * @param {Direction} direction
  * @param {boolean} adjacent_only
- * @returns {Map<AST.Element, boolean>}
+ * @returns {Map<any, boolean>}
  */
 function get_possible_element_siblings(node, direction, adjacent_only) {
 	const siblings = new Map();
@@ -415,7 +453,7 @@ function get_possible_element_siblings(node, direction, adjacent_only) {
 	for (let i = start; i !== end; i += step) {
 		const sibling = container[i];
 
-		if (sibling.type === 'Element') {
+		if (is_native_jsx_element(sibling)) {
 			siblings.set(sibling, true);
 			// Don't break for dynamic elements (children and dynamic components)
 			// as they can render dynamic content or might render nothing
@@ -425,13 +463,7 @@ function get_possible_element_siblings(node, direction, adjacent_only) {
 			}
 		}
 		// Stop at non-whitespace text nodes for adjacent selectors
-		else if (
-			adjacent_only &&
-			(sibling.type === 'TSRXExpression' || sibling.type === 'Text') &&
-			sibling.expression.type === 'Literal' &&
-			typeof sibling.expression.value === 'string' &&
-			sibling.expression.value.trim()
-		) {
+		else if (adjacent_only && sibling.type === 'JSXText' && sibling.value.trim()) {
 			break;
 		}
 	}
@@ -443,7 +475,7 @@ function get_possible_element_siblings(node, direction, adjacent_only) {
  * @param {AST.CSS.RelativeSelector} relative_selector
  * @param {AST.CSS.RelativeSelector[]} rest_selectors
  * @param {AST.CSS.Rule} rule
- * @param {AST.Element} node
+ * @param {any} node
  * @param {Direction} direction
  * @returns {boolean}
  */
@@ -515,7 +547,7 @@ function apply_combinator(relative_selector, rest_selectors, rule, node, directi
 
 									for (let i = search_start; i < search_end; i++) {
 										const subsequent = container[i];
-										if (subsequent.type === 'Element') {
+										if (is_native_jsx_element(subsequent)) {
 											if (apply_selector(remaining, rule, subsequent, direction)) {
 												sibling_matched = true;
 												break;
@@ -529,7 +561,7 @@ function apply_combinator(relative_selector, rest_selectors, rule, node, directi
 					}
 					// Don't apply_selector for dynamic elements - they won't match regular element selectors
 				} else if (
-					possible_sibling.type === 'Element' &&
+					is_native_jsx_element(possible_sibling) &&
 					apply_selector(rest_selectors, rule, possible_sibling, direction)
 				) {
 					sibling_matched = true;
@@ -551,7 +583,7 @@ function apply_combinator(relative_selector, rest_selectors, rule, node, directi
 }
 /**
  * @param {AST.Node} node
- * @returns {AST.Element | null}
+ * @returns {any | null}
  */
 function get_element_parent(node) {
 	// Check if metadata and path exist
@@ -565,7 +597,7 @@ function get_element_parent(node) {
 	while (i--) {
 		const parent = path[i];
 
-		if (parent.type === 'Element') {
+		if (is_native_jsx_element(parent)) {
 			return parent;
 		}
 	}
@@ -664,11 +696,12 @@ function is_global(selector, rule) {
 }
 
 /**
- * @param {AST.Attribute} attribute
- * @returns {attribute is AST.Attribute & { value: AST.Literal & { value: string } }}
+ * @param {any} attribute
+ * @returns {boolean}
  */
 function is_text_attribute(attribute) {
-	return attribute.value?.type === 'Literal' && typeof attribute.value.value === 'string';
+	const value = get_attribute_value(attribute);
+	return value?.type === 'Literal' && typeof value.value === 'string';
 }
 
 /**
@@ -702,7 +735,7 @@ function test_attribute(operator, expected_value, case_insensitive, value) {
 }
 
 /**
- * @param {AST.Element} node
+ * @param {any} node
  * @param {string} name
  * @param {string | null} expected_value
  * @param {string | null} operator
@@ -710,18 +743,29 @@ function test_attribute(operator, expected_value, case_insensitive, value) {
  * @returns {boolean}
  */
 function attribute_matches(node, name, expected_value, operator, case_insensitive) {
-	for (const attribute of node.attributes) {
-		if (attribute.type === 'SpreadAttribute') return true;
+	for (const attribute of get_element_attributes(node)) {
+		if (attribute.type === 'JSXSpreadAttribute') return true;
 
-		if (attribute.type !== 'Attribute') continue;
+		if (attribute.type !== 'JSXAttribute') continue;
 
 		const lowerCaseName = name.toLowerCase();
-		if (![lowerCaseName, `$${lowerCaseName}`].includes(attribute.name.name.toLowerCase())) continue;
+		const attributeName = get_attribute_name(attribute);
+		if (
+			!attributeName ||
+			![lowerCaseName, `$${lowerCaseName}`].includes(attributeName.toLowerCase())
+		) {
+			continue;
+		}
 
 		if (expected_value === null) return true;
 
 		if (is_text_attribute(attribute)) {
-			return test_attribute(operator, expected_value, case_insensitive, attribute.value.value);
+			return test_attribute(
+				operator,
+				expected_value,
+				case_insensitive,
+				get_attribute_value(attribute).value,
+			);
 		} else {
 			return true;
 		}
@@ -754,7 +798,7 @@ function is_outer_global(relative_selector) {
 /**
  * @param {AST.CSS.RelativeSelector} relative_selector
  * @param {AST.CSS.Rule} rule
- * @param {AST.Element} element
+ * @param {any} element
  * @param {Direction} direction
  * @return {boolean}
  */
@@ -879,7 +923,7 @@ function relative_selector_might_apply_to_node(relative_selector, rule, element,
 								selector.metadata.scoped = true;
 							}
 
-							/** @type {AST.Element | null} */
+							/** @type {any | null} */
 							let el = element;
 							while (el) {
 								el.metadata.scoped = true;
@@ -929,9 +973,11 @@ function relative_selector_might_apply_to_node(relative_selector, rule, element,
 			}
 
 			case 'AttributeSelector': {
-				const whitelisted = whitelist_attribute_selector.get(
-					/** @type {AST.Identifier} */ (element.id).name.toLowerCase(),
-				);
+				const element_name = get_element_name(element);
+				const whitelisted =
+					element_name?.type === 'Identifier' || element_name?.type === 'JSXIdentifier'
+						? whitelist_attribute_selector.get(element_name.name.toLowerCase())
+						: undefined;
 				if (
 					!whitelisted?.includes(selector.name.toLowerCase()) &&
 					!attribute_matches(
@@ -968,13 +1014,14 @@ function relative_selector_might_apply_to_node(relative_selector, rule, element,
 			}
 
 			case 'TypeSelector': {
-				if (is_element_dynamic(/** @type {AST.Element} */ (element))) {
+				if (is_runtime_dynamic_element(element)) {
 					break;
 				}
 
+				const element_name = get_element_name(element);
 				if (
-					element.id.type === 'Identifier' &&
-					element.id.name.toLowerCase() !== name.toLowerCase() &&
+					(element_name?.type === 'Identifier' || element_name?.type === 'JSXIdentifier') &&
+					element_name.name.toLowerCase() !== name.toLowerCase() &&
 					name !== '*'
 				) {
 					return false;
@@ -1063,7 +1110,7 @@ function rule_has_animation(rule) {
 
 /**
  * @param {AST.CSS.StyleSheet} css
- * @param {AST.Element} element
+ * @param {any} element
  * @param {StyleClasses} styleClasses
  * @param {TopScopedClasses} topScopedClasses
  * @return {void}

package/src/analyze/validation.js

@@ -9,9 +9,17 @@ import { DIAGNOSTIC_CODES } from '../diagnostics.js';
 export const TSRX_RETURN_STATEMENT_ERROR =
 	'Return statements are not allowed inside TSRX templates. Move the return before the TSRX return value, or use conditional rendering instead.';
 export const TSRX_LOOP_RETURN_ERROR =
-	'Return statements are not allowed inside TSRX template for...of loops. Use continue instead.';
+	'Return statements are not allowed inside TSRX template for...of loops. Filter the iterable before rendering or use an @empty fallback for empty lists.';
 export const TSRX_LOOP_BREAK_ERROR =
 	'Break statements are not allowed inside TSRX template for...of loops.';
+export const TSRX_LOOP_CONTINUE_ERROR =
+	'Continue statements are not allowed inside TSRX template for...of loops. Filter the iterable before rendering.';
+export const TSRX_IF_RETURN_ERROR =
+	'Return statements are not allowed inside TSRX template @if blocks. Move the return before the template output or render conditionally instead.';
+export const TSRX_IF_BREAK_ERROR =
+	'Break statements are not allowed inside TSRX template @if blocks.';
+export const TSRX_IF_CONTINUE_ERROR =
+	'Continue statements are not allowed inside TSRX template @if blocks. Filter before rendering or use conditional output instead.';
 export const TSRX_FOR_STATEMENT_ERROR =
 	'For loops are not supported in TSRX templates. Use for...of instead.';
 export const TSRX_FOR_IN_STATEMENT_ERROR =
@@ -134,11 +142,12 @@ const invalid_nestings = {
 };
 
 /**
- * @param {AST.Element} element
+ * @param {any} element
  * @returns {string | null}
  */
 function get_element_tag(element) {
-	return element.id.type === 'Identifier' ? element.id.name : null;
+	const name = element.openingElement?.name ?? element.id;
+	return name?.type === 'JSXIdentifier' || name?.type === 'Identifier' ? name.name : null;
 }
 
 /**
@@ -218,6 +227,64 @@ export function validate_tsrx_loop_break_statement(node, filename, errors, comme
 	);
 }
 
+/**
+ * @param {AST.ContinueStatement} node
+ * @param {string | null | undefined} filename
+ * @param {CompileError[]} [errors]
+ * @param {AST.CommentWithLocation[]} [comments]
+ */
+export function validate_tsrx_loop_continue_statement(node, filename, errors, comments) {
+	error(
+		TSRX_LOOP_CONTINUE_ERROR,
+		filename ?? null,
+		get_statement_keyword_node(node, 'continue'),
+		errors,
+		comments,
+	);
+}
+
+/**
+ * @param {AST.ReturnStatement} node
+ * @param {string | null | undefined} filename
+ * @param {CompileError[]} [errors]
+ * @param {AST.CommentWithLocation[]} [comments]
+ */
+export function validate_tsrx_if_return_statement(node, filename, errors, comments) {
+	error(TSRX_IF_RETURN_ERROR, filename ?? null, get_return_keyword_node(node), errors, comments);
+}
+
+/**
+ * @param {AST.BreakStatement} node
+ * @param {string | null | undefined} filename
+ * @param {CompileError[]} [errors]
+ * @param {AST.CommentWithLocation[]} [comments]
+ */
+export function validate_tsrx_if_break_statement(node, filename, errors, comments) {
+	error(
+		TSRX_IF_BREAK_ERROR,
+		filename ?? null,
+		get_statement_keyword_node(node, 'break'),
+		errors,
+		comments,
+	);
+}
+
+/**
+ * @param {AST.ContinueStatement} node
+ * @param {string | null | undefined} filename
+ * @param {CompileError[]} [errors]
+ * @param {AST.CommentWithLocation[]} [comments]
+ */
+export function validate_tsrx_if_continue_statement(node, filename, errors, comments) {
+	error(
+		TSRX_IF_CONTINUE_ERROR,
+		filename ?? null,
+		get_statement_keyword_node(node, 'continue'),
+		errors,
+		comments,
+	);
+}
+
 /**
  * @param {AST.ForStatement | AST.ForInStatement | AST.WhileStatement | AST.DoWhileStatement} node
  * @param {string | null | undefined} filename
@@ -240,7 +307,57 @@ export function validate_tsrx_unsupported_loop_statement(node, filename, errors,
 }
 
 /**
- * @param {AST.Element} element
+ * Returns `true` when `child` occupies a value slot of `parent` — i.e. it is
+ * being captured as a value (assigned to a binding, pushed into an array,
+ * passed as an argument, used as an operand, …) rather than rendered as a
+ * statement-position template child.
+ *
+ * Target analyzers use this to tell apart direct template output from a TSRX
+ * element that merely happens to be a value, so that a value-position element
+ * nested inside plain JavaScript control flow does not get mistaken for direct
+ * output that would require a `@for`/`@if`/`@switch`/`@try` directive.
+ * @param {AST.Node} parent
+ * @param {AST.Node} child
+ * @returns {boolean}
+ */
+export function is_template_value_position(parent, child) {
+	switch (parent.type) {
+		case 'VariableDeclarator':
+			return parent.init === child;
+		case 'AssignmentExpression':
+			return parent.right === child;
+		case 'Property':
+		case 'PropertyDefinition':
+			return parent.value === child;
+		case 'ArrayExpression':
+			return /** @type {any[]} */ (parent.elements).includes(child);
+		case 'CallExpression':
+		case 'NewExpression':
+			return parent.callee === child || /** @type {any[]} */ (parent.arguments).includes(child);
+		case 'ConditionalExpression':
+			return parent.test === child || parent.consequent === child || parent.alternate === child;
+		case 'LogicalExpression':
+		case 'BinaryExpression':
+			return parent.left === child || parent.right === child;
+		case 'UnaryExpression':
+		case 'AwaitExpression':
+		case 'SpreadElement':
+		case 'YieldExpression':
+			return parent.argument === child;
+		case 'TemplateLiteral':
+		case 'SequenceExpression':
+			return /** @type {any[]} */ (parent.expressions).includes(child);
+		case 'TSAsExpression':
+		case 'TSNonNullExpression':
+		case 'TSSatisfiesExpression':
+			return parent.expression === child;
+		default:
+			return false;
+	}
+}
+
+/**
+ * @param {any} element
  * @param {AnalysisContext} context
  * @param {CompileError[]} [errors]
  */
@@ -253,7 +370,7 @@ export function validate_nesting(element, context, errors) {
 
 	for (let i = context.path.length - 1; i >= 0; i--) {
 		const parent = context.path[i];
-		if (parent.type === 'Element') {
+		if (parent.type === 'JSXElement' || parent.type === 'JSXStyleElement') {
 			const parent_tag = get_element_tag(parent);
 			if (parent_tag === null) {
 				continue;

package/src/diagnostics.js

@@ -4,4 +4,5 @@ export const DIAGNOSTIC_CODES = {
 	MISMATCHED_CLOSING_TAG: 'tsrx-mismatched-closing-tag',
 	TEMPLATE_EXPRESSION_TRAILING_SEMICOLON: 'tsrx-template-expression-trailing-semicolon',
 	TEMPLATE_RETURN_STATEMENT: 'tsrx-template-return-statement',
+	FORGOTTEN_STATEMENT_CONTAINER: 'tsrx-forgotten-statement-container',
 };

package/src/index.js

@@ -9,7 +9,6 @@
 export { parse_module as parseModule } from './parse/parse-module.js';
 export {
 	get_comment_handlers as getCommentHandlers,
-	convert_from_jsx as convertFromJsx,
 	skipWhitespace,
 	isWhitespaceTextNode,
 	BINDING_TYPES,
@@ -181,13 +180,11 @@ export {
 	create_compile_error,
 	create_generated_identifier,
 	create_null_literal,
-	expand_switch_cases_for_fallthrough,
 	flatten_switch_consequent,
 	get_for_of_iteration_params,
 	identifier_to_jsx_name,
 	is_bare_render_expression,
 	is_component_jsx_name,
-	is_dynamic_element_id,
 	is_jsx_child,
 	set_loc,
 	to_text_expression,
@@ -199,7 +196,7 @@ export {
 export {
 	prepare_stylesheet_for_render as prepareStylesheetForRender,
 	is_style_element as isStyleElement,
-	is_composite_element as isCompositeElement,
+	is_composite_jsx_element as isCompositeElement,
 	annotate_with_hash as annotateWithHash,
 	annotate_component_with_hash as annotateComponentWithHash,
 	add_hash_class as addHashClass,
@@ -241,15 +238,24 @@ export {
 	TSRX_DO_WHILE_STATEMENT_ERROR,
 	TSRX_FOR_IN_STATEMENT_ERROR,
 	TSRX_FOR_STATEMENT_ERROR,
+	TSRX_IF_BREAK_ERROR,
+	TSRX_IF_CONTINUE_ERROR,
+	TSRX_IF_RETURN_ERROR,
 	TSRX_LOOP_BREAK_ERROR,
+	TSRX_LOOP_CONTINUE_ERROR,
 	TSRX_LOOP_RETURN_ERROR,
 	TSRX_RETURN_STATEMENT_ERROR,
 	TSRX_WHILE_STATEMENT_ERROR,
 	get_return_keyword_node as getReturnKeywordNode,
 	get_statement_keyword_node as getStatementKeywordNode,
+	validate_tsrx_if_break_statement as validateTsrxIfBreakStatement,
+	validate_tsrx_if_continue_statement as validateTsrxIfContinueStatement,
+	validate_tsrx_if_return_statement as validateTsrxIfReturnStatement,
 	validate_tsrx_loop_break_statement as validateTsrxLoopBreakStatement,
+	validate_tsrx_loop_continue_statement as validateTsrxLoopContinueStatement,
 	validate_tsrx_loop_return_statement as validateTsrxLoopReturnStatement,
 	validate_tsrx_return_statement as validateTsrxReturnStatement,
 	validate_tsrx_unsupported_loop_statement as validateTsrxUnsupportedLoopStatement,
 	validate_nesting as validateNesting,
+	is_template_value_position as isTemplateValuePosition,
 } from './analyze/validation.js';