ripple 0.2.183 → 0.2.184

package/package.json

@@ -3,7 +3,7 @@
   "description": "Ripple is an elegant TypeScript UI framework",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.2.183",
+  "version": "0.2.184",
   "type": "module",
   "module": "src/runtime/index-client.js",
   "main": "src/runtime/index-client.js",
@@ -86,6 +86,6 @@
     "vscode-languageserver-types": "^3.17.5"
   },
   "peerDependencies": {
-    "ripple": "0.2.183"
+    "ripple": "0.2.184"
   }
 }

package/src/compiler/phases/2-analyze/index.js

@@ -728,9 +728,9 @@ const visitors = {
 			}
 			if (state.inside_head) {
 				if (node.id.name === 'title') {
-					const chiildren = normalize_children(node.children, context);
+					const children = normalize_children(node.children, context);
 
-					if (chiildren.length !== 1 || chiildren[0].type !== 'Text') {
+					if (children.length !== 1 || children[0].type !== 'Text') {
 						error(
 							'<title> must have only contain text nodes',
 							state.analysis.module.filename,

package/src/compiler/phases/3-transform/segments.js

@@ -1,13 +1,13 @@
-/** @import { CustomMappingData, PluginActionOverrides } from 'ripple/compiler'; */
-/** @import { DocumentHighlightKind } from 'vscode-languageserver-types'; */
+/**
+@import { CustomMappingData, PluginActionOverrides } from 'ripple/compiler';
+@import { DocumentHighlightKind } from 'vscode-languageserver-types';
+@import * as AST from 'estree';
+@import * as ESTreeJSX from 'estree-jsx';
+@import {MappingData, CodeMapping, VolarMappingsResult} from 'ripple/compiler';
+@import {CodeMapping as VolarCodeMapping} from '@volar/language-core';
+*/
 
 /**
- * @typedef {import('estree').Position} Position
- * @typedef {{start: Position, end: Position}} Location
- * @typedef {import('@volar/language-core').CodeMapping} VolarCodeMapping
- * @typedef {import('ripple/compiler').MappingData} MappingData
- * @typedef {import('ripple/compiler').CodeMapping} CodeMapping
- * @typedef {import('ripple/compiler').VolarMappingsResult} VolarMappingsResult
  * @typedef {{
  *	start: number,
  *	end: number,
@@ -61,7 +61,7 @@ function loc_to_offset(line, column, line_offsets) {
 
 /**
  * Extract CSS source regions from style elements in the AST
- * @param {any} ast - The parsed AST
+ * @param {AST.Node} ast - The parsed AST
  * @param {string} source - Original source code
  * @param {number[]} source_line_offsets
  * @returns {CssSourceRegion[]}
@@ -74,10 +74,14 @@ function extractCssSourceRegions(ast, source, source_line_offsets) {
 		Element(node) {
 			// Check if this is a style element with CSS content
 			if (node.id?.name === 'style' && node.css) {
-				const openLoc = node.openingElement.loc;
+				const openLoc = /** @type {ESTreeJSX.JSXOpeningElement & AST.NodeWithLocation} */ (
+					node.openingElement
+				).loc;
 				const cssStart = loc_to_offset(openLoc.end.line, openLoc.end.column, source_line_offsets);
 
-				const closeLoc = node.closingElement.loc;
+				const closeLoc = /** @type {ESTreeJSX.JSXClosingElement & AST.NodeWithLocation} */ (
+					node.closingElement
+				).loc;
 				const cssEnd = loc_to_offset(
 					closeLoc.start.line,
 					closeLoc.start.column,
@@ -102,8 +106,8 @@ function extractCssSourceRegions(ast, source, source_line_offsets) {
 
 /**
  * Create Volar mappings by walking the transformed AST
- * @param {any} ast - The transformed AST
- * @param {any} ast_from_source - The original AST from source
+ * @param {AST.Node} ast - The transformed AST
+ * @param {AST.Node} ast_from_source - The original AST from source
  * @param {string} source - Original source code
  * @param {string} generated_code - Generated code (returned in output, not used for searching)
  * @param {object} esrap_source_map - Esrap source map for accurate position lookup
@@ -147,17 +151,18 @@ export function convert_source_map_to_mappings(
 	// All tokens must have source/generated text and loc property for accurate positioning
 	/**
 	 * @type {Array<{
-	 *		source: string,
+	 *		source: string | null | undefined,
 	 *		generated: string,
 	 *		is_full_import_statement?: boolean,
-	 *		loc: Location,
-	 *		end_loc?: Location,
+	 *		loc: AST.SourceLocation,
+	 *		end_loc?: AST.SourceLocation,
 	 *		metadata?: PluginActionOverrides
 	 * }>}
 	 */
 	const tokens = [];
 
 	// We have to visit everything in generated order to maintain correct indices
+
 	walk(ast, null, {
 		_(node, { visit }) {
 			// Collect key node types: Identifiers, Literals, and JSX Elements
@@ -231,7 +236,11 @@ export function convert_source_map_to_mappings(
 			} else if (node.type === 'ImportSpecifier') {
 				// If local and imported are the same, only visit local to avoid duplicates
 				// Otherwise visit both in order
-				if (node.imported && node.local && node.imported.name !== node.local.name) {
+				if (
+					node.imported &&
+					node.local &&
+					/** @type {AST.Identifier} */ (node.imported).name !== node.local.name
+				) {
 					visit(node.imported);
 					visit(node.local);
 				} else if (node.local) {
@@ -250,7 +259,12 @@ export function convert_source_map_to_mappings(
 			} else if (node.type === 'ExportSpecifier') {
 				// If local and exported are the same, only visit local to avoid duplicates
 				// Otherwise visit both in order
-				if (node.local && node.exported && node.local.name !== node.exported.name) {
+				if (
+					node.local &&
+					node.exported &&
+					/** @type {AST.Identifier} */ (node.local).name !==
+						/** @type {AST.Identifier} */ (node.exported).name
+				) {
 					visit(node.local);
 					visit(node.exported);
 				} else if (node.local) {
@@ -271,7 +285,7 @@ export function convert_source_map_to_mappings(
 			} else if (node.type === 'ExportDefaultDeclaration') {
 				// Visit the declaration
 				if (node.declaration) {
-					visit(node.declaration);
+					visit(/** @type {AST.Node} */ (node.declaration));
 				}
 				return;
 			} else if (node.type === 'ExportAllDeclaration') {
@@ -357,7 +371,7 @@ export function convert_source_map_to_mappings(
 				// 2. Visit children in order
 				if (node.children) {
 					for (const child of node.children) {
-						visit(child);
+						visit(/** @type {AST.Node} */ (child));
 					}
 				}
 
@@ -366,7 +380,9 @@ export function convert_source_map_to_mappings(
 					!node.openingElement?.selfClosing &&
 					node.closingElement?.name?.type === 'JSXIdentifier'
 				) {
-					const closingNameNode = node.closingElement.name;
+					const closingNameNode = /** @type {ESTreeJSX.JSXIdentifier & AST.NodeWithLocation} */ (
+						node.closingElement.name
+					);
 					if (closingNameNode.metadata?.is_capitalized) {
 						tokens.push({
 							source: closingNameNode.metadata.original_name,
@@ -390,24 +406,25 @@ export function convert_source_map_to_mappings(
 			) {
 				// Add function/component keyword token
 				if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression') {
+					const node_fn = /** @type (typeof node) & AST.NodeWithLocation */ (node);
 					const source_keyword = node.metadata?.was_component ? 'component' : 'function';
 					// Add token for the keyword - esrap already mapped it via context.write('function', node)
 					tokens.push({
 						source: source_keyword,
 						generated: 'function',
 						loc: {
-							start: { line: node.loc.start.line, column: node.loc.start.column },
+							start: { line: node_fn.loc.start.line, column: node_fn.loc.start.column },
 							end: {
-								line: node.loc.start.line,
-								column: node.loc.start.column + source_keyword.length,
+								line: node_fn.loc.start.line,
+								column: node_fn.loc.start.column + source_keyword.length,
 							},
 						},
 					});
 				}
 
 				// Visit in source order: id, params, body
-				if (node.id) {
-					visit(node.id);
+				if (/** @type {AST.FunctionDeclaration | AST.FunctionExpression} */ (node).id) {
+					visit(/** @type {AST.FunctionDeclaration | AST.FunctionExpression} */ (node).id);
 				}
 				if (node.params) {
 					for (const param of node.params) {
@@ -478,8 +495,8 @@ export function convert_source_map_to_mappings(
 					visit(node.right);
 				}
 				// Ripple-specific: index variable
-				if (node.index) {
-					visit(node.index);
+				if (/** @type {AST.ForOfStatement} */ (node).index) {
+					visit(/** @type {AST.ForOfStatement} */ (node).index);
 				}
 				if (node.body) {
 					visit(node.body);
@@ -511,14 +528,17 @@ export function convert_source_map_to_mappings(
 				if (node.pending) {
 					// Add a special token for the 'pending' keyword with customData
 					// to suppress TypeScript diagnostics and provide custom hover/definition
+					const pending = /** @type {(typeof node.pending) & AST.NodeWithLocation} */ (
+						node.pending
+					);
 					const pendingKeywordLoc = {
 						start: {
-							line: node.pending.loc.start.line,
-							column: node.pending.loc.start.column - 'pending '.length,
+							line: pending.loc.start.line,
+							column: pending.loc.start.column - 'pending '.length,
 						},
 						end: {
-							line: node.pending.loc.start.line,
-							column: node.pending.loc.start.column - 1,
+							line: pending.loc.start.line,
+							column: pending.loc.start.column - 1,
 						},
 					};
 					tokens.push({
@@ -764,8 +784,8 @@ export function convert_source_map_to_mappings(
 				if (node.argument) {
 					visit(node.argument);
 					// Visit type annotation if present (for RestElement)
-					if (node.argument.typeAnnotation) {
-						visit(node.argument.typeAnnotation);
+					if (/** @type {AST.Pattern} */ (node.argument).typeAnnotation) {
+						visit(/** @type {AST.Pattern} */ (node.argument).typeAnnotation);
 					}
 				}
 				// RestElement itself can have typeAnnotation
@@ -828,7 +848,7 @@ export function convert_source_map_to_mappings(
 				// Visit children in order
 				if (node.children) {
 					for (const child of node.children) {
-						visit(child);
+						visit(/** @type {AST.Node} */ (child));
 					}
 				}
 				return;
@@ -956,10 +976,11 @@ export function convert_source_map_to_mappings(
 				if (node.typeName) {
 					visit(node.typeName);
 				}
-				// Check both typeParameters and typeArguments (different parsers use different names)
-				if (node.typeParameters) {
-					visit(node.typeParameters);
-				}
+
+				// typeParameters and typeArguments (different parsers use different names)
+				// tsTypeParameters is a bug in the estree-typescript
+				// but we fixed in the analyzer to typeArguments.
+
 				if (node.typeArguments) {
 					visit(node.typeArguments);
 				}
@@ -1004,8 +1025,13 @@ export function convert_source_map_to_mappings(
 					for (const param of node.parameters) {
 						visit(param);
 						// Visit type annotation on the parameter
-						if (param.typeAnnotation) {
-							visit(param.typeAnnotation);
+						if (
+							/** @type {Exclude<AST.Parameter, AST.TSParameterProperty>} */ (param).typeAnnotation
+						) {
+							visit(
+								/** @type {Exclude<AST.Parameter, AST.TSParameterProperty>} */ (param)
+									.typeAnnotation,
+							);
 						}
 					}
 				}
@@ -1042,8 +1068,13 @@ export function convert_source_map_to_mappings(
 					for (const param of node.parameters) {
 						visit(param);
 						// Visit type annotation on the parameter
-						if (param.typeAnnotation) {
-							visit(param.typeAnnotation);
+						if (
+							/** @type {Exclude<AST.Parameter, AST.TSParameterProperty>} */ (param).typeAnnotation
+						) {
+							visit(
+								/** @type {Exclude<AST.Parameter, AST.TSParameterProperty>} */ (param)
+									.typeAnnotation,
+							);
 						}
 					}
 				}
@@ -1057,8 +1088,13 @@ export function convert_source_map_to_mappings(
 					for (const param of node.parameters) {
 						visit(param);
 						// Visit type annotation on the parameter
-						if (param.typeAnnotation) {
-							visit(param.typeAnnotation);
+						if (
+							/** @type {Exclude<AST.Parameter, AST.TSParameterProperty>} */ (param).typeAnnotation
+						) {
+							visit(
+								/** @type {Exclude<AST.Parameter, AST.TSParameterProperty>} */ (param)
+									.typeAnnotation,
+							);
 						}
 					}
 				}
@@ -1078,8 +1114,13 @@ export function convert_source_map_to_mappings(
 					for (const param of node.parameters) {
 						visit(param);
 						// Visit type annotation on the parameter
-						if (param.typeAnnotation) {
-							visit(param.typeAnnotation);
+						if (
+							/** @type {Exclude<AST.Parameter, AST.TSParameterProperty>} */ (param).typeAnnotation
+						) {
+							visit(
+								/** @type {Exclude<AST.Parameter, AST.TSParameterProperty>} */ (param)
+									.typeAnnotation,
+							);
 						}
 					}
 				}
@@ -1170,6 +1211,9 @@ export function convert_source_map_to_mappings(
 				if (node.exprName) {
 					visit(node.exprName);
 				}
+				if (node.typeArguments) {
+					visit(node.typeArguments);
+				}
 				return;
 			} else if (node.type === 'TSInterfaceDeclaration') {
 				// Interface declaration
@@ -1327,7 +1371,7 @@ export function convert_source_map_to_mappings(
 	});
 
 	for (const token of tokens) {
-		const source_text = token.source;
+		const source_text = token.source ?? '';
 		const gen_text = token.generated;
 
 		const source_start = loc_to_offset(
@@ -1344,7 +1388,7 @@ export function convert_source_map_to_mappings(
 		let gen_start;
 
 		if (token.is_full_import_statement) {
-			const end_loc = /** @type {Location} */ (token.end_loc).end;
+			const end_loc = /** @type {AST.SourceLocation} */ (token.end_loc).end;
 			const source_end = loc_to_offset(end_loc.line, end_loc.column, source_line_offsets);
 
 			// Look up where import keyword and source literal map to in generated code

package/src/compiler/scope.js

@@ -1,5 +1,12 @@
-/** @import { Binding, ScopeInterface, ScopeRoot as ScopeRootInterface } from '#compiler' */
-/** @import * as AST from 'estree' */
+/**
+@import {
+	Binding,
+	ScopeInterface,
+	ScopeRoot as ScopeRootInterface,
+	Context
+} from '#compiler';
+ @import * as AST from 'estree';
+ */
 
 import is_reference from 'is-reference';
 import { extract_identifiers, object, unwrap_pattern } from '../utils/ast.js';
@@ -45,7 +52,7 @@ export function create_scopes(ast, root, parent) {
 	/**
 	 * Create a block scope
 	 * @param {AST.Node} node - AST node
-	 * @param {{ state: any, next: Function }} context - Visitor context
+	 * @param {Context<AST.Node, State>} context - Visitor context
 	 */
 	const create_block_scope = (node, { state, next }) => {
 		const scope = state.scope.child(true);
@@ -60,7 +67,7 @@ export function create_scopes(ast, root, parent) {
 		next({ scope });
 	};
 
-	walk(/** @type {AST.Node} */ (ast), state, {
+	walk(ast, state, {
 		// references
 		Identifier(node, { path, state }) {
 			const parent = path.at(-1);
@@ -95,12 +102,6 @@ export function create_scopes(ast, root, parent) {
 			}
 		},
 
-		/**
-		 * @param {AST.Component} node
-		 * @param {Object} context
-		 * @param {any} context.state
-		 * @param {Function} context.next
-		 */
 		Component(node, { state, next }) {
 			const scope = state.scope.child();
 			scopes.set(node, scope);
@@ -114,12 +115,6 @@ export function create_scopes(ast, root, parent) {
 			next({ scope });
 		},
 
-		/**
-		 * @param {AST.Element} node
-		 * @param {Object} context
-		 * @param {any} context.state
-		 * @param {Function} context.next
-		 */
 		Element(node, { state, next }) {
 			const scope = state.scope.child();
 			scopes.set(node, scope);

package/src/compiler/types/index.d.ts

@@ -86,7 +86,7 @@ declare module 'estree' {
 		Attribute: Attribute;
 		RefAttribute: RefAttribute;
 		SpreadAttribute: SpreadAttribute;
-		// Stylesheet: AST.CSS.StyleSheet;
+		ParenthesizedExpression: ParenthesizedExpression;
 	}
 
 	interface ExpressionMap {
@@ -98,6 +98,12 @@ declare module 'estree' {
 		Text: TextNode;
 	}
 
+	// Missing estree type
+	interface ParenthesizedExpression extends BaseNode {
+		type: 'ParenthesizedExpression';
+		expression: Expression;
+	}
+
 	interface Comment {
 		context?: Parse.CommentMetaData | null;
 	}
@@ -512,7 +518,9 @@ declare module 'estree-jsx' {
 }
 
 declare module 'estree' {
-	interface NodeMap {
+	// Helper map for creating our own TypeNode
+	// and to be used to extend estree's NodeMap
+	interface TSNodeMap {
 		// TypeScript nodes
 		TSAnyKeyword: TSAnyKeyword;
 		TSArrayType: TSArrayType;
@@ -577,49 +585,188 @@ declare module 'estree' {
 		TSUnknownKeyword: TSUnknownKeyword;
 		TSVoidKeyword: TSVoidKeyword;
 		TSParenthesizedType: TSParenthesizedType;
+		TSExpressionWithTypeArguments: TSExpressionWithTypeArguments;
 	}
 
+	// Extend NodeMap to include TypeScript nodes
+	interface NodeMap extends TSNodeMap {}
+
+	// Create our version of TypeNode with modified types to be used in replacements
+	type TypeNode = TSNodeMap[keyof TSNodeMap];
+	type EntityName = AST.Identifier | AST.ThisExpression | TSQualifiedName;
+	type Parameter =
+		| ArrayPattern
+		| AssignmentPattern
+		| Identifier
+		| ObjectPattern
+		| RestElement
+		| TSParameterProperty;
+	type TypeElement =
+		| TSCallSignatureDeclaration
+		| TSConstructSignatureDeclaration
+		| TSIndexSignature
+		| TSMethodSignature
+		| TSPropertySignature;
+	type TSPropertySignature = TSPropertySignatureComputedName | TSPropertySignatureNonComputedName;
+	type PropertyNameComputed = Expression;
+	type PropertyNameNonComputed = Identifier | NumberLiteral | StringLiteral;
+
 	// TypeScript AST node interfaces from @sveltejs/acorn-typescript
 	// Based on TSESTree types but adapted for acorn's output format
 	interface TSAnyKeyword extends AcornTSNode<TSESTree.TSAnyKeyword> {}
-	interface TSArrayType extends AcornTSNode<TSESTree.TSArrayType> {}
+	interface TSArrayType extends Omit<AcornTSNode<TSESTree.TSArrayType>, 'elementType'> {
+		elementType: TypeNode;
+	}
 	interface TSAsExpression extends AcornTSNode<TSESTree.TSAsExpression> {
 		// Have to override it to use our Expression for required properties like metadata
 		expression: AST.Expression;
 	}
 	interface TSBigIntKeyword extends AcornTSNode<TSESTree.TSBigIntKeyword> {}
 	interface TSBooleanKeyword extends AcornTSNode<TSESTree.TSBooleanKeyword> {}
-	interface TSCallSignatureDeclaration extends AcornTSNode<TSESTree.TSCallSignatureDeclaration> {}
-	interface TSConditionalType extends AcornTSNode<TSESTree.TSConditionalType> {}
-	interface TSConstructorType extends AcornTSNode<TSESTree.TSConstructorType> {}
+	interface TSCallSignatureDeclaration
+		extends Omit<
+			AcornTSNode<TSESTree.TSCallSignatureDeclaration>,
+			'typeParameters' | 'typeAnnotation'
+		> {
+		parameters: Parameter[];
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSConditionalType
+		extends Omit<
+			AcornTSNode<TSESTree.TSConditionalType>,
+			'checkType' | 'extendsType' | 'falseType' | 'trueType'
+		> {
+		checkType: TypeNode;
+		extendsType: TypeNode;
+		falseType: TypeNode;
+		trueType: TypeNode;
+	}
+	interface TSConstructorType
+		extends Omit<AcornTSNode<TSESTree.TSConstructorType>, 'typeParameters' | 'params'> {
+		typeAnnotation: TSTypeAnnotation | undefined;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		parameters: Parameter[];
+	}
 	interface TSConstructSignatureDeclaration
-		extends AcornTSNode<TSESTree.TSConstructSignatureDeclaration> {}
-	interface TSDeclareFunction extends AcornTSNode<TSESTree.TSDeclareFunction> {}
-	interface TSEnumDeclaration extends AcornTSNode<TSESTree.TSEnumDeclaration> {}
-	interface TSEnumMember extends AcornTSNode<TSESTree.TSEnumMember> {}
-	interface TSExportAssignment extends AcornTSNode<TSESTree.TSExportAssignment> {}
-	interface TSExternalModuleReference extends AcornTSNode<TSESTree.TSExternalModuleReference> {}
-	interface TSFunctionType extends AcornTSNode<TSESTree.TSFunctionType> {}
+		extends Omit<
+			AcornTSNode<TSESTree.TSConstructSignatureDeclaration>,
+			'typeParameters' | 'typeAnnotation'
+		> {
+		parameters: Parameter[];
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSDeclareFunction
+		extends Omit<
+			AcornTSNode<TSESTree.TSDeclareFunction>,
+			'id' | 'params' | 'typeParameters' | 'returnType'
+		> {
+		id: AST.Identifier;
+		params: Parameter[];
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		returnType: TSTypeAnnotation | undefined;
+	}
+	interface TSEnumDeclaration
+		extends Omit<AcornTSNode<TSESTree.TSEnumDeclaration>, 'id' | 'members'> {
+		id: AST.Identifier;
+		members: TSEnumMember[];
+	}
+	interface TSEnumMember extends Omit<AcornTSNode<TSESTree.TSEnumMember>, 'id' | 'initializer'> {
+		id: AST.Identifier | StringLiteral;
+		initializer: AST.Expression | undefined;
+	}
+	interface TSExportAssignment
+		extends Omit<AcornTSNode<TSESTree.TSExportAssignment>, 'expression'> {
+		expression: AST.Expression;
+	}
+	interface TSExternalModuleReference
+		extends Omit<AcornTSNode<TSESTree.TSExternalModuleReference>, 'expression'> {
+		expression: StringLiteral;
+	}
+	interface TSFunctionType
+		extends Omit<AcornTSNode<TSESTree.TSFunctionType>, 'typeParameters' | 'params'> {
+		typeAnnotation: TSTypeAnnotation | undefined;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		parameters: Parameter[];
+	}
 	interface TSImportEqualsDeclaration extends AcornTSNode<TSESTree.TSImportEqualsDeclaration> {}
-	interface TSImportType extends AcornTSNode<TSESTree.TSImportType> {}
-	interface TSIndexedAccessType extends AcornTSNode<TSESTree.TSIndexedAccessType> {}
-	interface TSIndexSignature extends AcornTSNode<TSESTree.TSIndexSignature> {}
-	interface TSInferType extends AcornTSNode<TSESTree.TSInferType> {}
+	interface TSImportType
+		extends Omit<AcornTSNode<TSESTree.TSImportType>, 'argument' | 'qualifier' | 'typeParameters'> {
+		argument: TypeNode;
+		qualifier: EntityName | null;
+		// looks like acorn-typescript has typeParameters
+		typeParameters: TSTypeParameterDeclaration | undefined | undefined;
+	}
+	interface TSIndexedAccessType
+		extends Omit<AcornTSNode<TSESTree.TSIndexedAccessType>, 'indexType' | 'objectType'> {
+		indexType: TypeNode;
+		objectType: TypeNode;
+	}
+	interface TSIndexSignature
+		extends Omit<AcornTSNode<TSESTree.TSIndexSignature>, 'parameters' | 'typeAnnotation'> {
+		parameters: Parameter[];
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSInferType extends Omit<AcornTSNode<TSESTree.TSInferType>, 'typeParameter'> {
+		typeParameter: TSTypeParameter;
+	}
 	interface TSInstantiationExpression extends AcornTSNode<TSESTree.TSInstantiationExpression> {
 		expression: AST.Expression;
 	}
-	interface TSInterfaceBody extends AcornTSNode<TSESTree.TSInterfaceBody> {}
-	interface TSInterfaceDeclaration extends AcornTSNode<TSESTree.TSInterfaceDeclaration> {}
-	interface TSIntersectionType extends AcornTSNode<TSESTree.TSIntersectionType> {}
+	interface TSInterfaceBody extends Omit<AcornTSNode<TSESTree.TSInterfaceBody>, 'body'> {
+		body: TypeElement[];
+	}
+	interface TSInterfaceDeclaration
+		extends Omit<
+			AcornTSNode<TSESTree.TSInterfaceDeclaration>,
+			'id' | 'typeParameters' | 'body' | 'extends'
+		> {
+		id: AST.Identifier;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		body: TSInterfaceBody;
+		extends: TSExpressionWithTypeArguments[];
+	}
+	interface TSIntersectionType extends Omit<AcornTSNode<TSESTree.TSIntersectionType>, 'types'> {
+		types: TypeNode[];
+	}
 	interface TSIntrinsicKeyword extends AcornTSNode<TSESTree.TSIntrinsicKeyword> {}
-	interface TSLiteralType extends AcornTSNode<TSESTree.TSLiteralType> {}
-	interface TSMappedType extends AcornTSNode<TSESTree.TSMappedType> {}
-	interface TSMethodSignature extends AcornTSNode<TSESTree.TSMethodSignature> {}
-	interface TSModuleBlock extends AcornTSNode<TSESTree.TSModuleBlock> {}
-	interface TSModuleDeclaration extends AcornTSNode<TSESTree.TSModuleDeclaration> {}
-	interface TSNamedTupleMember extends AcornTSNode<TSESTree.TSNamedTupleMember> {}
+	interface TSLiteralType extends Omit<AcornTSNode<TSESTree.TSLiteralType>, 'literal'> {
+		literal: AST.Literal | AST.TemplateLiteral;
+	}
+	interface TSMappedType
+		extends Omit<AcornTSNode<TSESTree.TSMappedType>, 'typeParameter' | 'typeAnnotation'> {
+		typeAnnotation: TypeNode | undefined;
+		typeParameter: TSTypeParameter;
+	}
+	interface TSMethodSignature
+		extends Omit<
+			AcornTSNode<TSESTree.TSMethodSignature>,
+			'key' | 'typeParameters' | 'params' | 'typeAnnotation'
+		> {
+		key: PropertyNameComputed | PropertyNameNonComputed;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		parameters: Parameter[];
+		// doesn't actually exist in the spec but acorn-typescript adds it
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSModuleBlock extends Omit<AcornTSNode<TSESTree.TSModuleBlock>, 'body'> {
+		body: AST.Statement[];
+	}
+	interface TSModuleDeclaration
+		extends Omit<AcornTSNode<TSESTree.TSModuleDeclaration>, 'body' | 'id'> {
+		body: TSModuleBlock;
+		id: AST.Identifier;
+	}
+	interface TSNamedTupleMember
+		extends Omit<AcornTSNode<TSESTree.TSNamedTupleMember>, 'elementType' | 'label'> {
+		elementType: TypeNode;
+		label: AST.Identifier;
+	}
 	interface TSNamespaceExportDeclaration
-		extends AcornTSNode<TSESTree.TSNamespaceExportDeclaration> {}
+		extends Omit<AcornTSNode<TSESTree.TSNamespaceExportDeclaration>, 'id'> {
+		id: AST.Identifier;
+	}
 	interface TSNeverKeyword extends AcornTSNode<TSESTree.TSNeverKeyword> {}
 	interface TSNonNullExpression extends AcornTSNode<TSESTree.TSNonNullExpression> {
 		expression: AST.Expression;
@@ -627,36 +774,106 @@ declare module 'estree' {
 	interface TSNullKeyword extends AcornTSNode<TSESTree.TSNullKeyword> {}
 	interface TSNumberKeyword extends AcornTSNode<TSESTree.TSNumberKeyword> {}
 	interface TSObjectKeyword extends AcornTSNode<TSESTree.TSObjectKeyword> {}
-	interface TSOptionalType extends AcornTSNode<TSESTree.TSOptionalType> {}
+	interface TSOptionalType extends Omit<AcornTSNode<TSESTree.TSOptionalType>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode;
+	}
 	interface TSParameterProperty extends AcornTSNode<TSESTree.TSParameterProperty> {}
-	interface TSPropertySignature extends AcornTSNode<TSESTree.TSPropertySignature> {}
-	interface TSQualifiedName extends AcornTSNode<TSESTree.TSQualifiedName> {}
-	interface TSRestType extends AcornTSNode<TSESTree.TSRestType> {}
+	interface TSPropertySignatureComputedName
+		extends Omit<AcornTSNode<TSESTree.TSPropertySignatureComputedName>, 'key' | 'typeAnnotation'> {
+		key: PropertyNameComputed;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSPropertySignatureNonComputedName
+		extends Omit<
+			AcornTSNode<TSESTree.TSPropertySignatureNonComputedName>,
+			'key' | 'typeAnnotation'
+		> {
+		key: PropertyNameNonComputed;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSQualifiedName extends Omit<AcornTSNode<TSESTree.TSQualifiedName>, 'left' | 'right'> {
+		left: EntityName;
+		right: AST.Identifier;
+	}
+	interface TSRestType extends Omit<AcornTSNode<TSESTree.TSRestType>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode;
+	}
 	interface TSSatisfiesExpression extends AcornTSNode<TSESTree.TSSatisfiesExpression> {
 		expression: AST.Expression;
 	}
 	interface TSStringKeyword extends AcornTSNode<TSESTree.TSStringKeyword> {}
 	interface TSSymbolKeyword extends AcornTSNode<TSESTree.TSSymbolKeyword> {}
 	interface TSThisType extends AcornTSNode<TSESTree.TSThisType> {}
-	interface TSTupleType extends AcornTSNode<TSESTree.TSTupleType> {}
-	interface TSTypeAliasDeclaration extends AcornTSNode<TSESTree.TSTypeAliasDeclaration> {}
-	interface TSTypeAnnotation extends AcornTSNode<TSESTree.TSTypeAnnotation> {}
+	interface TSTupleType extends Omit<AcornTSNode<TSESTree.TSTupleType>, 'elementTypes'> {
+		elementTypes: TypeNode[];
+	}
+	interface TSTypeAliasDeclaration
+		extends Omit<
+			AcornTSNode<TSESTree.TSTypeAliasDeclaration>,
+			'id' | 'typeParameters' | 'typeAnnotation'
+		> {
+		id: AST.Identifier;
+		typeAnnotation: TypeNode;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+	}
+	interface TSTypeAnnotation
+		extends Omit<AcornTSNode<TSESTree.TSTypeAnnotation>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode;
+	}
 	interface TSTypeAssertion extends AcornTSNode<TSESTree.TSTypeAssertion> {
 		expression: AST.Expression;
 	}
-	interface TSTypeLiteral extends AcornTSNode<TSESTree.TSTypeLiteral> {}
-	interface TSTypeOperator extends AcornTSNode<TSESTree.TSTypeOperator> {}
-	interface TSTypeParameter extends AcornTSNode<TSESTree.TSTypeParameter> {}
-	interface TSTypeParameterDeclaration extends AcornTSNode<TSESTree.TSTypeParameterDeclaration> {}
+	interface TSTypeLiteral extends Omit<AcornTSNode<TSESTree.TSTypeLiteral>, 'members'> {
+		members: TypeElement[];
+	}
+	interface TSTypeOperator extends Omit<AcornTSNode<TSESTree.TSTypeOperator>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode | undefined;
+	}
+	interface TSTypeParameter
+		extends Omit<AcornTSNode<TSESTree.TSTypeParameter>, 'name' | 'constraint' | 'default'> {
+		constraint: TypeNode | undefined;
+		default: TypeNode | undefined;
+		name: AST.Identifier;
+	}
+	interface TSTypeParameterDeclaration
+		extends Omit<AcornTSNode<TSESTree.TSTypeParameterDeclaration>, 'params'> {
+		params: TypeNode[];
+	}
 	interface TSTypeParameterInstantiation
-		extends AcornTSNode<TSESTree.TSTypeParameterInstantiation> {}
+		extends Omit<AcornTSNode<TSESTree.TSTypeParameterInstantiation>, 'params'> {
+		params: TypeNode[];
+	}
 	interface TSTypePredicate extends AcornTSNode<TSESTree.TSTypePredicate> {}
-	interface TSTypeQuery extends AcornTSNode<TSESTree.TSTypeQuery> {}
-	interface TSTypeReference extends AcornTSNode<TSESTree.TSTypeReference> {}
+	interface TSTypeQuery
+		extends Omit<AcornTSNode<TSESTree.TSTypeQuery>, 'exprName' | 'typeArguments'> {
+		exprName: EntityName | TSImportType;
+		typeArguments: TSTypeParameterInstantiation | undefined;
+	}
+	interface TSTypeReference
+		extends Omit<AcornTSNode<TSESTree.TSTypeReference>, 'typeName' | 'typeArguments'> {
+		typeArguments: TSTypeParameterInstantiation | undefined;
+		typeName: EntityName;
+	}
 	interface TSUndefinedKeyword extends AcornTSNode<TSESTree.TSUndefinedKeyword> {}
-	interface TSUnionType extends AcornTSNode<TSESTree.TSUnionType> {}
+	interface TSUnionType extends Omit<AcornTSNode<TSESTree.TSUnionType>, 'types'> {
+		types: TypeNode[];
+	}
+	// TSInterfaceHeritage doesn't exist in acorn-typescript which uses TSExpressionWithTypeArguments
+	interface TSInterfaceHeritage
+		extends Omit<AcornTSNode<TSESTree.TSInterfaceHeritage>, 'expression' | 'typeParameters'> {
+		expression: AST.Expression;
+		// acorn-typescript uses typeParameters instead of typeArguments
+		typeParameters: TSTypeParameterInstantiation | undefined;
+	}
+	// Extends TSInterfaceHeritage as it's the semantically the same as used by acorn-typescript
+	interface TSExpressionWithTypeArguments extends Omit<TSInterfaceHeritage, 'type'> {
+		type: 'TSExpressionWithTypeArguments';
+	}
+
 	interface TSUnknownKeyword extends AcornTSNode<TSESTree.TSUnknownKeyword> {}
 	interface TSVoidKeyword extends AcornTSNode<TSESTree.TSVoidKeyword> {}
+	interface NumberLiteral extends AcornTSNode<TSESTree.NumberLiteral> {}
+	interface StringLiteral extends AcornTSNode<TSESTree.StringLiteral> {}
 
 	// acorn-typescript specific nodes (not in @typescript-eslint/types)
 	interface TSParenthesizedType extends AST.BaseNode {
@@ -674,7 +891,7 @@ declare module 'estree' {
 }
 
 import type { Comment, Position } from 'acorn';
-import type { M } from 'vitest/dist/chunks/environment.d.cL3nLXbE.js';
+import type { A, M } from 'vitest/dist/chunks/environment.d.cL3nLXbE.js';
 
 /**
  * Parse error information

package/src/compiler/types/parse.d.ts

@@ -65,6 +65,85 @@ export namespace Parse {
 		BIND_OUTSIDE: 5;
 	}
 
+	/**
+	 * Branch ID for tracking disjunction structure in regular expressions
+	 * Used to determine whether a duplicate capture group name is allowed
+	 * because it is in a separate branch.
+	 */
+	export interface BranchID {
+		/** Parent disjunction branch */
+		parent: BranchID | null;
+		/** Identifies this set of sibling branches */
+		base: BranchID;
+		/** Check if this branch is separated from another branch */
+		separatedFrom(alt: BranchID): boolean;
+		/** Create a sibling branch */
+		sibling(): BranchID;
+	}
+
+	/**
+	 * Regular expression validation state
+	 * Used by the parser to validate regular expression literals
+	 * See: https://github.com/acornjs/acorn/blob/main/acorn/src/regexp.js
+	 */
+	export interface RegExpValidationState {
+		/** Reference to the parser instance */
+		parser: Parser;
+		/** Valid flags for the current ECMAScript version */
+		validFlags: string;
+		/** Unicode properties data for the current ECMAScript version */
+		unicodeProperties: any;
+		/** Source pattern string of the regular expression */
+		source: string;
+		/** Flags string of the regular expression */
+		flags: string;
+		/** Start position of the regular expression in the source */
+		start: number;
+		/** Whether unicode flag (u) is enabled */
+		switchU: boolean;
+		/** Whether unicode sets flag (v) is enabled (ES2024+) */
+		switchV: boolean;
+		/** Whether named capture groups are enabled */
+		switchN: boolean;
+		/** Current position in the pattern */
+		pos: number;
+		/** Last integer value parsed */
+		lastIntValue: number;
+		/** Last string value parsed */
+		lastStringValue: string;
+		/** Whether the last assertion can be quantified */
+		lastAssertionIsQuantifiable: boolean;
+		/** Number of capturing parentheses */
+		numCapturingParens: number;
+		/** Maximum back reference number */
+		maxBackReference: number;
+		/** Map of group names to their information */
+		groupNames: Record<string, BranchID[]>;
+		/** Array of back reference names */
+		backReferenceNames: string[];
+		/** Current branch ID for tracking disjunction structure */
+		branchID: BranchID | null;
+
+		/** Reset state for a new pattern */
+		reset(start: number, pattern: string, flags: string): void;
+		/** Raise a validation error */
+		raise(message: string): void;
+		/** Get code point at position i (handles surrogate pairs if unicode mode) */
+		at(i: number, forceU?: boolean): number;
+		/** Get next index after position i (handles surrogate pairs if unicode mode) */
+		nextIndex(i: number, forceU?: boolean): number;
+		/** Get code point at current position */
+		current(forceU?: boolean): number;
+		/** Get code point at next position */
+		lookahead(forceU?: boolean): number;
+		/** Advance position to next character */
+		advance(forceU?: boolean): void;
+		/** Try to eat a specific character */
+		eat(ch: number, forceU?: boolean): boolean;
+		/** Try to eat a sequence of characters */
+		eatChars(chs: number[], forceU?: boolean): boolean;
+	}
+
 	export interface Options extends Omit<acorn.Options, 'onComment' | 'ecmaVersion'> {
 		rippleOptions: {
 			loose: boolean;
@@ -297,6 +376,15 @@ export namespace Parse {
 		tokContexts: AcornTypeScriptTokContexts;
 	}
 
+	interface Scope {
+		flags: number;
+		var: string[];
+		lexical: string[];
+		functions: string[];
+	}
+
+	type Exports = Record<string, boolean>;
+
 	/**
 	 * Extended Parser instance with internal properties
 	 *
@@ -360,7 +448,7 @@ export namespace Parse {
 		/** Current scope flags stack */
 		scopeStack: Array<{ flags: number; var: string[]; lexical: string[]; functions: string[] }>;
 		/** Regular expression validation state */
-		regexpState?: any;
+		regexpState: RegExpValidationState | null;
 		/** Whether we can use await keyword */
 		canAwait: boolean;
 		/** Position of await keyword (0 if not in async context) */
@@ -376,7 +464,7 @@ export namespace Parse {
 		/** Potential arrow in for-await position */
 		potentialArrowInForAwait: boolean;
 		/** Private name stack for class private fields validation */
-		privateNameStack: Array<{ declared: Record<string, any>; used: Array<AST.Node> }>;
+		privateNameStack: Array<{ declared: Record<string, string>; used: Array<AST.Node> }>;
 		/** Undefined exports for module validation */
 		undefinedExports: Record<string, AST.Node>;
 
@@ -646,16 +734,16 @@ export namespace Parse {
 		declareName(name: string, bindingType: BindingType[keyof BindingType], pos: number): void;
 
 		/** Get current scope */
-		currentScope(): { flags: number; var: string[]; lexical: string[]; functions: string[] };
+		currentScope(): Scope;
 
 		/** Get current variable scope (for var declarations) */
-		currentVarScope(): { flags: number; var: string[]; lexical: string[]; functions: string[] };
+		currentVarScope(): Scope;
 
 		/** Get current "this" scope */
-		currentThisScope(): { flags: number; var: string[]; lexical: string[]; functions: string[] };
+		currentThisScope(): Scope;
 
 		/** Check if treating functions as var in current scope */
-		treatFunctionsAsVarInScope(scope: any): boolean;
+		treatFunctionsAsVarInScope(scope: Scope): boolean;
 
 		// ============================================================
 		// Context Management
@@ -1262,7 +1350,7 @@ export namespace Parse {
 		parseClassSuper(node: AST.Node): void;
 
 		/** Enter class body scope */
-		enterClassBody(): Record<string, any>;
+		enterClassBody(): Record<string, string>;
 
 		/** Exit class body scope */
 		exitClassBody(): void;
@@ -1325,11 +1413,11 @@ export namespace Parse {
 		/** Parse export declaration */
 		parseExport(
 			node: AST.Node,
-			exports?: any,
+			exports?: Exports,
 		): AST.ExportNamedDeclaration | AST.ExportDefaultDeclaration | AST.ExportAllDeclaration;
 
 		/** Parse export specifiers */
-		parseExportSpecifiers(exports?: any): AST.ExportSpecifier[];
+		parseExportSpecifiers(exports?: Exports): AST.ExportSpecifier[];
 
 		/** Parse export default declaration */
 		parseExportDefaultDeclaration(): AST.Declaration | AST.Expression | AST.Component;