@tsrx/core 0.1.65 → 0.1.67

package/src/analyze/style-analyze.js

@@ -0,0 +1,467 @@
+/**
+ * Module-level analysis of `<style>` blocks: which blocks are standalone
+ * (scoped to the template scope they sit in) and which are assigned
+ * (`const theme = <style>…</style>`), what every `apply` attribute resolves to,
+ * and whether an assigned block is a theme (exported or applied, D5) or a
+ * class map. Results are stamped on the style nodes' `metadata` so the target
+ * transforms — which clone nodes but share metadata — read one shape, and are
+ * summarized on `program.metadata.styles` for consumer compilers.
+ *
+ * Declared-before-use (D13 layer 1) is enforced here by source position and
+ * lexical visibility: same-module CSS is emitted in lexical order, so a theme
+ * declared after its applier would win the cascade instead of losing it.
+ *
+ * @import * as AST from 'estree'
+ * @import * as ESTreeJSX from 'estree-jsx'
+ * @import { Binding, ScopeInterface, StyleApplyResolution, StyleAnalysis, TSRXAnalysisState, Visitors } from '../../types/index'
+ */
+
+import { walk } from 'zimmerframe';
+import { DIAGNOSTIC_CODES } from '../diagnostics.js';
+import { get_style_class_map_names, get_style_element_stylesheet } from '../transform/style-ref.js';
+import { is_function_node, is_template_directive } from '../utils/ast.js';
+import {
+	TSRX_STYLE_APPLY_DUPLICATE_ERROR,
+	TSRX_STYLE_APPLY_UNSUPPORTED_HOST_ERROR,
+	TSRX_STYLE_APPLY_VALUE_ERROR,
+	TSRX_STYLE_RESERVED_CLASS_KEY_ERROR,
+	TSRX_STYLE_STANDALONE_AT_MODULE_SCOPE_ERROR,
+	TSRX_STYLE_STANDALONE_NEEDS_FRAGMENT_ERROR,
+	TSRX_STYLE_STANDALONE_OUTSIDE_TEMPLATE_ERROR,
+	tsrx_style_apply_before_declaration_error,
+	tsrx_style_apply_target_error,
+	tsrx_style_unknown_attribute_error,
+	validate_style,
+} from './validation.js';
+
+/**
+ * `container_depth` counts the enclosing TSRX containers — `@{ … }` bodies
+ * and control-flow directives — where raw CSS in a standalone block is
+ * template syntax; native elements only bump `template_depth`.
+ *
+ * @typedef {{ function_depth: number, template_depth: number, container_depth: number }} StyleWalkState
+ */
+
+/**
+ * `apply` sites resolve against ordinary JavaScript scoping, so the analyzer
+ * looks the target up from the nearest enclosing scope of the style block.
+ *
+ * @param {AST.Node[]} path
+ * @param {Map<AST.Node, ScopeInterface>} scopes
+ * @returns {ScopeInterface | null}
+ */
+function nearest_scope(path, scopes) {
+	for (let i = path.length - 1; i >= 0; i -= 1) {
+		const scope = scopes.get(path[i]);
+		if (scope) return scope;
+	}
+	return null;
+}
+
+/**
+ * Names exported through `export { a, b as c }` and `export default a`.
+ *
+ * @param {AST.Program} ast
+ * @returns {Set<string>}
+ */
+function collect_exported_names(ast) {
+	/** @type {Set<string>} */
+	const names = new Set();
+	for (const statement of ast.body) {
+		if (statement.type === 'ExportNamedDeclaration' && !statement.declaration) {
+			for (const specifier of statement.specifiers) {
+				if (specifier.local.type === 'Identifier') names.add(specifier.local.name);
+			}
+		} else if (
+			statement.type === 'ExportDefaultDeclaration' &&
+			statement.declaration.type === 'Identifier'
+		) {
+			names.add(statement.declaration.name);
+		}
+	}
+	return names;
+}
+
+/**
+ * A style block is standalone when it is template content rather than a value:
+ * a child of a native element/fragment, the render output of a `@{ … }` body
+ * or a control-flow body, or a bare statement. Only the first placement is
+ * valid; the others are reported (5.1).
+ *
+ * @param {AST.Node[]} path
+ * @returns {boolean}
+ */
+export function is_standalone_style_position(path) {
+	const parent = path.at(-1);
+	if (!parent) return true;
+	switch (parent.type) {
+		case 'JSXElement':
+		case 'JSXFragment':
+			return !!parent.metadata?.native_tsrx;
+		case 'JSXCodeBlock':
+		case 'BlockStatement':
+		case 'SwitchCase':
+		case 'Program':
+		case 'ExpressionStatement':
+			return true;
+		default:
+			return false;
+	}
+}
+
+/**
+ * @param {ESTreeJSX.JSXAttributeNode} attr
+ * @param {string} name
+ * @returns {boolean}
+ */
+function is_named_attribute(attr, name) {
+	return (
+		attr.type === 'JSXAttribute' && attr.name.type === 'JSXIdentifier' && attr.name.name === name
+	);
+}
+
+/**
+ * @param {ESTreeJSX.JSXAttribute} attr
+ * @returns {AST.Expression | null}
+ */
+function attribute_expression(attr) {
+	const value = attr.value;
+	if (!value || value.type !== 'JSXExpressionContainer') return null;
+	return value.expression.type === 'JSXEmptyExpression' ? null : value.expression;
+}
+
+/**
+ * @param {AST.Expression} expression
+ * @returns {string}
+ */
+function describe_target(expression) {
+	if (expression.type === 'Identifier') return expression.name;
+	if (
+		expression.type === 'MemberExpression' &&
+		!expression.computed &&
+		expression.property.type === 'Identifier'
+	) {
+		return `${describe_target(/** @type {AST.Expression} */ (expression.object))}.${expression.property.name}`;
+	}
+	return 'apply target';
+}
+
+/**
+ * @param {AST.Expression} expression
+ * @returns {AST.Identifier | null}
+ */
+function member_root(expression) {
+	let current = expression;
+	while (current.type === 'MemberExpression' && !current.computed) {
+		current = /** @type {AST.Expression} */ (current.object);
+	}
+	return current.type === 'Identifier' ? current : null;
+}
+
+/**
+ * @param {Binding} binding
+ * @param {AST.Expression} expression the `apply` entry for the member chain
+ * @returns {AST.JSXStyleElement | null | undefined} `undefined` when the
+ *   member does not name a style block of a module-local object
+ */
+function resolve_local_member(binding, expression) {
+	if (expression.type !== 'MemberExpression' || expression.computed) return undefined;
+	if (expression.object.type !== 'Identifier' || expression.property.type !== 'Identifier') {
+		return undefined;
+	}
+	const object = binding.initial;
+	if (object?.type !== 'ObjectExpression') return undefined;
+	const name = expression.property.name;
+	for (const property of object.properties) {
+		if (
+			property.type === 'Property' &&
+			!property.computed &&
+			((property.key.type === 'Identifier' && property.key.name === name) ||
+				(property.key.type === 'Literal' && property.key.value === name)) &&
+			property.value.type === 'JSXStyleElement'
+		) {
+			return property.value;
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Whether any reference to the binding reads its `$class` property.
+ *
+ * @param {Binding | null} binding
+ * @returns {boolean}
+ */
+function is_class_read(binding) {
+	if (!binding) return false;
+	return binding.references.some(({ node, path }) => {
+		const parent = path.at(-1);
+		if (parent?.type !== 'MemberExpression' || parent.object !== node) return false;
+		if (parent.computed) {
+			return parent.property.type === 'Literal' && parent.property.value === '$class';
+		}
+		return parent.property.type === 'Identifier' && parent.property.name === '$class';
+	});
+}
+
+/**
+ * Run the module-level style analysis. `scopes` comes from `create_scopes`
+ * over the same program so target resolution uses real bindings.
+ *
+ * @param {AST.Program} ast
+ * @param {Map<AST.Node, ScopeInterface>} scopes
+ * @param {TSRXAnalysisState} state
+ * @returns {StyleAnalysis}
+ */
+export function analyze_styles(ast, scopes, state) {
+	const exported_names = collect_exported_names(ast);
+	const errors = state.collect ? state.errors : undefined;
+	/** @type {AST.JSXStyleElement[]} */
+	const assigned = [];
+	/** @type {AST.JSXStyleElement[]} */
+	const standalone = [];
+
+	/**
+	 * @param {string} message
+	 * @param {string} code
+	 * @param {AST.Node} node
+	 */
+	const report = (message, code, node) => {
+		validate_style(message, code, node, state.filename, errors, state.comments);
+	};
+
+	/**
+	 * @param {AST.Expression} expression
+	 * @param {ScopeInterface | null} scope
+	 * @param {StyleApplyResolution[]} resolutions
+	 */
+	const resolve_apply_entry = (expression, scope, resolutions) => {
+		if (expression.type === 'ArrayExpression') {
+			for (const element of expression.elements) {
+				if (!element || element.type === 'SpreadElement') {
+					report(
+						tsrx_style_apply_target_error('apply entry'),
+						DIAGNOSTIC_CODES.STYLE_APPLY_TARGET,
+						element ?? expression,
+					);
+					continue;
+				}
+				resolve_apply_entry(element, scope, resolutions);
+			}
+			return;
+		}
+
+		const root = member_root(expression);
+		const name = describe_target(expression);
+		const binding = root && scope ? scope.get(root.name) : null;
+		if (!root || !binding) {
+			report(tsrx_style_apply_target_error(name), DIAGNOSTIC_CODES.STYLE_APPLY_TARGET, expression);
+			return;
+		}
+
+		if (binding.declaration_kind === 'import') {
+			resolutions.push({ expression, target: null, kind: 'import' });
+			return;
+		}
+
+		/** @type {AST.JSXStyleElement | null | undefined} */
+		let target;
+		if (expression.type === 'Identifier') {
+			target = binding.initial?.type === 'JSXStyleElement' ? binding.initial : undefined;
+		} else {
+			target = resolve_local_member(binding, expression);
+		}
+
+		if (!target) {
+			report(tsrx_style_apply_target_error(name), DIAGNOSTIC_CODES.STYLE_APPLY_TARGET, expression);
+			return;
+		}
+
+		if (/** @type {number} */ (binding.node.start) > /** @type {number} */ (root.start)) {
+			report(
+				tsrx_style_apply_before_declaration_error(name),
+				DIAGNOSTIC_CODES.STYLE_APPLY_BEFORE_DECLARATION,
+				root,
+			);
+			return;
+		}
+
+		target.metadata.styleApplied = true;
+		resolutions.push({ expression, target, kind: 'local' });
+	};
+
+	walk(
+		/** @type {AST.Node} */ (ast),
+		/** @type {StyleWalkState} */ ({ function_depth: 0, template_depth: 0, container_depth: 0 }),
+		/** @type {Visitors<AST.Node, StyleWalkState>} */ ({
+			_(node, { state: walk_state, next }) {
+				if (is_function_node(node)) {
+					next({ ...walk_state, function_depth: walk_state.function_depth + 1 });
+					return;
+				}
+				if (node.type === 'JSXCodeBlock' || is_template_directive(node)) {
+					// `@else if` chains and `@catch` clauses are children of the
+					// directive node, so one bump covers every branch body.
+					next({
+						...walk_state,
+						template_depth: walk_state.template_depth + 1,
+						container_depth: walk_state.container_depth + 1,
+					});
+					return;
+				}
+				if (
+					(node.type === 'JSXElement' || node.type === 'JSXFragment') &&
+					node.metadata?.native_tsrx
+				) {
+					next({ ...walk_state, template_depth: walk_state.template_depth + 1 });
+					return;
+				}
+				next();
+			},
+
+			JSXStyleElement(node, { path, state: walk_state, next }) {
+				const is_standalone = is_standalone_style_position(path);
+				const inside_head = path.some(
+					(ancestor) =>
+						ancestor.type === 'JSXElement' &&
+						ancestor.openingElement.name.type === 'JSXIdentifier' &&
+						ancestor.openingElement.name.name === 'head',
+				);
+				const attributes = node.openingElement.attributes;
+				const is_resource = attributes.some((attr) => is_named_attribute(attr, 'href'));
+
+				/** @type {ESTreeJSX.JSXAttribute | null} */
+				let apply_attr = null;
+				for (const attr of attributes) {
+					if (attr.type !== 'JSXAttribute') continue;
+					if (is_named_attribute(attr, 'apply')) {
+						if (apply_attr) {
+							report(
+								TSRX_STYLE_APPLY_DUPLICATE_ERROR,
+								DIAGNOSTIC_CODES.STYLE_APPLY_DUPLICATE,
+								attr,
+							);
+							continue;
+						}
+						apply_attr = attr;
+						continue;
+					}
+					if (is_named_attribute(attr, 'ref') || inside_head || is_resource) continue;
+					const attr_name =
+						attr.name.type === 'JSXIdentifier'
+							? attr.name.name
+							: `${attr.name.namespace.name}:${attr.name.name.name}`;
+					report(
+						tsrx_style_unknown_attribute_error(attr_name),
+						DIAGNOSTIC_CODES.STYLE_UNKNOWN_ATTRIBUTE,
+						attr,
+					);
+				}
+
+				/** @type {StyleApplyResolution[]} */
+				const resolutions = [];
+				if (apply_attr) {
+					const expression = attribute_expression(apply_attr);
+					if (!expression) {
+						report(TSRX_STYLE_APPLY_VALUE_ERROR, DIAGNOSTIC_CODES.STYLE_APPLY_VALUE, apply_attr);
+					} else if (inside_head || is_resource) {
+						report(
+							TSRX_STYLE_APPLY_UNSUPPORTED_HOST_ERROR,
+							DIAGNOSTIC_CODES.STYLE_APPLY_UNSUPPORTED_HOST,
+							apply_attr,
+						);
+					} else {
+						resolve_apply_entry(expression, nearest_scope(path, scopes), resolutions);
+					}
+				}
+				node.metadata.styleApplies = resolutions;
+
+				if (is_standalone) {
+					if (!inside_head && !is_resource) {
+						const parent = path.at(-1);
+						const in_children_list =
+							parent?.type === 'JSXElement' || parent?.type === 'JSXFragment';
+						if (walk_state.function_depth === 0 && walk_state.template_depth === 0) {
+							report(
+								TSRX_STYLE_STANDALONE_AT_MODULE_SCOPE_ERROR,
+								DIAGNOSTIC_CODES.STYLE_STANDALONE_AT_MODULE_SCOPE,
+								node,
+							);
+						} else if (!in_children_list) {
+							// A block is an output node: as the lone output of a `@{ … }` or
+							// control-flow body, or as a statement, it styles nothing. Beside
+							// another output it is already the parser's multiple-outputs error.
+							report(
+								TSRX_STYLE_STANDALONE_NEEDS_FRAGMENT_ERROR,
+								DIAGNOSTIC_CODES.STYLE_STANDALONE_NEEDS_FRAGMENT,
+								node,
+							);
+						} else if (walk_state.container_depth === 0 && !node.openingElement.selfClosing) {
+							// Raw CSS in `<style>` is TSRX template syntax: outside every
+							// `@{ … }` and control-flow body the file is plain TSX, where a
+							// `<style>` takes an expression child instead. A self-closing
+							// `<style apply={…} />` holds no CSS text and is ordinary JSX.
+							report(
+								TSRX_STYLE_STANDALONE_OUTSIDE_TEMPLATE_ERROR,
+								DIAGNOSTIC_CODES.STYLE_STANDALONE_OUTSIDE_TEMPLATE,
+								node,
+							);
+						}
+						standalone.push(node);
+					}
+				} else {
+					assigned.push(node);
+					const parent = path.at(-1);
+					const grandparent = path.at(-2);
+					/** @type {AST.VariableDeclarator | null} */
+					let declarator = null;
+					if (parent?.type === 'VariableDeclarator') {
+						declarator = parent;
+					} else if (parent?.type === 'Property' && grandparent?.type === 'ObjectExpression') {
+						const holder = path.at(-3);
+						if (holder?.type === 'VariableDeclarator') declarator = holder;
+					}
+					const declared_name = declarator?.id.type === 'Identifier' ? declarator.id.name : null;
+					const declaration_index = declarator ? path.indexOf(declarator) : -1;
+					const export_parent = declaration_index > 0 ? path[declaration_index - 2] : null;
+					node.metadata.styleExported =
+						parent?.type === 'ExportDefaultDeclaration' ||
+						export_parent?.type === 'ExportNamedDeclaration' ||
+						(declared_name !== null && exported_names.has(declared_name));
+					// Reading `theme.$class` opts an element (or a child component's
+					// element, through a prop) into the block's whole stylesheet, so
+					// such a block is a theme: every selector stays, like `apply`.
+					node.metadata.styleClassRead =
+						declared_name !== null &&
+						is_class_read(nearest_scope(path, scopes)?.get(declared_name) ?? null);
+
+					const stylesheet = get_style_element_stylesheet(node);
+					if (stylesheet && get_style_class_map_names(stylesheet).includes('$class')) {
+						report(
+							TSRX_STYLE_RESERVED_CLASS_KEY_ERROR,
+							DIAGNOSTIC_CODES.STYLE_RESERVED_CLASS_KEY,
+							node,
+						);
+					}
+				}
+
+				next();
+			},
+		}),
+	);
+
+	for (const node of assigned) {
+		node.metadata.styleKind =
+			node.metadata.styleExported || node.metadata.styleApplied || node.metadata.styleClassRead
+				? 'theme'
+				: 'class-map';
+	}
+
+	/** @type {StyleAnalysis} */
+	const styles = { assigned, standalone };
+	/** @type {{ metadata?: { styles?: StyleAnalysis } }} */ (ast).metadata = {
+		.../** @type {{ metadata?: object }} */ (ast).metadata,
+		styles,
+	};
+	return styles;
+}

package/src/analyze/validation.js

@@ -32,6 +32,48 @@ export const TSRX_FORGOTTEN_STATEMENT_CONTAINER_ERROR =
 	"This TSRX template output is unused. Return it, assign it to a value that is rendered, or make it part of the rendered output of a function '@{...}' body.";
 export const TSRX_UNSUPPORTED_LAZY_ASSIGNMENT_POSITION_ERROR =
 	'Lazy destructuring assignments require a directly lazy target as a standalone statement inside a program, block, TSRX code block, or switch case.';
+export const TSRX_STYLE_APPLY_VALUE_ERROR =
+	"The 'apply' attribute of a <style> block requires an expression value: apply={theme} or apply={[a, b]}.";
+export const TSRX_STYLE_APPLY_DUPLICATE_ERROR =
+	"A <style> block accepts a single 'apply' attribute; pass several themes as an array: apply={[a, b]}.";
+export const TSRX_STYLE_APPLY_UNSUPPORTED_HOST_ERROR =
+	"The 'apply' attribute is only supported on scoped <style> blocks, not on <head> styles or resource styles.";
+export const TSRX_STYLE_RESERVED_CLASS_KEY_ERROR =
+	"'$class' is reserved on assigned <style> blocks for the block's scope hash; rename the '.$class' selector.";
+export const TSRX_STYLE_STANDALONE_AT_MODULE_SCOPE_ERROR =
+	'A standalone <style> block is only allowed inside a template scope. At module scope assign it: const theme = <style>…</style>.';
+export const TSRX_STYLE_STANDALONE_NEEDS_FRAGMENT_ERROR =
+	'A standalone <style> block must be a child of an element or a fragment. Wrap it with the output it styles in a fragment: <><style>…</style><div>…</div></>.';
+export const TSRX_STYLE_STANDALONE_OUTSIDE_TEMPLATE_ERROR =
+	'A standalone <style> block with CSS text is TSRX template syntax and needs an enclosing @{ … } body or an @if/@for/@switch/@try body. In plain TSX give <style> an expression child instead: <style>{css}</style>. To declare a reusable block here, assign it: const theme = <style>…</style>.';
+export const TSRX_CSS_GLOBAL_NESTED_IN_PSEUDOCLASS_ERROR =
+	'A :global selector cannot be inside a pseudoclass.';
+export const TSRX_CSS_GLOBAL_MIDDLE_PLACEMENT_ERROR =
+	':global(...) can be at the start or end of a selector sequence, but not in the middle.';
+
+/**
+ * @param {string} name
+ * @returns {string}
+ */
+export function tsrx_style_apply_target_error(name) {
+	return `'${name}' is not a style block. An 'apply' target must be a variable, import, or member holding an assigned <style> block.`;
+}
+
+/**
+ * @param {string} name
+ * @returns {string}
+ */
+export function tsrx_style_apply_before_declaration_error(name) {
+	return `'${name}' is applied before its declaration. Declare the style block before the block that applies it.`;
+}
+
+/**
+ * @param {string} name
+ * @returns {string}
+ */
+export function tsrx_style_unknown_attribute_error(name) {
+	return `Unknown <style> attribute '${name}'. Scoped style blocks accept 'ref' and 'apply'.`;
+}
 
 const invalid_nestings = {
 	// <p> cannot contain block-level elements
@@ -434,3 +476,18 @@ export function validate_nesting(element, context, errors) {
 		}
 	}
 }
+
+/**
+ * Report a style diagnostic through the shared error channel so editors get
+ * positions and `@tsrx-ignore` applies.
+ *
+ * @param {string} message
+ * @param {string} code
+ * @param {AST.Node} node
+ * @param {string | null} filename
+ * @param {CompileError[] | undefined} errors
+ * @param {AST.CommentWithLocation[] | undefined} comments
+ */
+export function validate_style(message, code, node, filename, errors, comments) {
+	error(message, filename, node, errors, comments, code);
+}

package/src/diagnostics.js

@@ -6,4 +6,26 @@ export const DIAGNOSTIC_CODES = {
 	TEMPLATE_RETURN_STATEMENT: 'tsrx-template-return-statement',
 	FORGOTTEN_STATEMENT_CONTAINER: 'tsrx-forgotten-statement-container',
 	UNSUPPORTED_LAZY_ASSIGNMENT_POSITION: 'tsrx-unsupported-lazy-assignment-position',
+	/** `<style apply>` carries no expression value. */
+	STYLE_APPLY_VALUE: 'tsrx-style-apply-value',
+	/** An `apply` entry is not an identifier, member, or array of those, or does not resolve to a style block. */
+	STYLE_APPLY_TARGET: 'tsrx-style-apply-target',
+	/** An `apply` target is declared after the applying block in source order. */
+	STYLE_APPLY_BEFORE_DECLARATION: 'tsrx-style-apply-before-declaration',
+	/** Two `apply` attributes on one `<style>` block. */
+	STYLE_APPLY_DUPLICATE: 'tsrx-style-apply-duplicate',
+	/** `apply` on a `<head>` style or a resource (`href`) style. */
+	STYLE_APPLY_UNSUPPORTED_HOST: 'tsrx-style-apply-unsupported-host',
+	/** An assigned style block authors a `.$class` class selector. */
+	STYLE_RESERVED_CLASS_KEY: 'tsrx-style-reserved-class-key',
+	/** A standalone `<style>` block at module scope. */
+	STYLE_STANDALONE_AT_MODULE_SCOPE: 'tsrx-style-standalone-at-module-scope',
+	/** A standalone `<style>` block with CSS text outside any `@{ … }` or control-flow body. */
+	STYLE_STANDALONE_OUTSIDE_TEMPLATE: 'tsrx-style-standalone-outside-template',
+	/** A standalone `<style>` block in a statement slot: the lone output of a `@{ … }` or control-flow body, or a statement. */
+	STYLE_STANDALONE_NEEDS_FRAGMENT: 'tsrx-style-standalone-needs-fragment',
+	/** A `<style>` attribute other than `ref` and `apply`. */
+	STYLE_UNKNOWN_ATTRIBUTE: 'tsrx-style-unknown-attribute',
+	/** `:global` used where the scoping rules do not allow it. */
+	CSS_GLOBAL_PLACEMENT: 'tsrx-css-global-placement',
 };

package/src/index.js

@@ -186,6 +186,7 @@ export {
 	collect_style_ref_attributes as collectStyleRefAttributes,
 	create_style_class_map as createStyleClassMap,
 	create_style_class_map_from_stylesheet as createStyleClassMapFromStylesheet,
+	build_style_class_map as buildStyleClassMap,
 	create_style_ref_setup_statements as createStyleRefSetupStatements,
 	get_style_element_stylesheet as getStyleElementStylesheet,
 } from './transform/style-ref.js';
@@ -251,6 +252,7 @@ export {
 // Analyze
 export { analyze_css as analyzeCss } from './analyze/css-analyze.js';
 export { prune_css as pruneCss } from './analyze/prune.js';
+export { create_scope_root as createScopeRoot } from './transform/jsx/style-scopes.js';
 export {
 	TSRX_DO_WHILE_STATEMENT_ERROR,
 	TSRX_FORGOTTEN_STATEMENT_CONTAINER_ERROR,
@@ -279,4 +281,20 @@ export {
 	validate_forgotten_statement_container as validateForgottenStatementContainer,
 	validate_nesting as validateNesting,
 	is_template_value_position as isTemplateValuePosition,
+	TSRX_STYLE_APPLY_VALUE_ERROR,
+	TSRX_STYLE_APPLY_DUPLICATE_ERROR,
+	TSRX_STYLE_APPLY_UNSUPPORTED_HOST_ERROR,
+	TSRX_STYLE_RESERVED_CLASS_KEY_ERROR,
+	TSRX_STYLE_STANDALONE_AT_MODULE_SCOPE_ERROR,
+	TSRX_STYLE_STANDALONE_OUTSIDE_TEMPLATE_ERROR,
+	TSRX_STYLE_STANDALONE_NEEDS_FRAGMENT_ERROR,
+	TSRX_CSS_GLOBAL_NESTED_IN_PSEUDOCLASS_ERROR,
+	TSRX_CSS_GLOBAL_MIDDLE_PLACEMENT_ERROR,
+	tsrx_style_apply_target_error as tsrxStyleApplyTargetError,
+	tsrx_style_apply_before_declaration_error as tsrxStyleApplyBeforeDeclarationError,
+	tsrx_style_unknown_attribute_error as tsrxStyleUnknownAttributeError,
 } from './analyze/validation.js';
+export {
+	analyze_styles as analyzeStyles,
+	is_standalone_style_position as isStandaloneStylePosition,
+} from './analyze/style-analyze.js';