@ripple-ts/language-server 0.3.61 → 0.3.62

package/dist/{server-BNcMp4pJ.js → server-CPmlKSwW.js}

@@ -50,6 +50,7 @@ fs = __toESM(fs, 1);
 let typescript = require("typescript");
 typescript = __toESM(typescript, 1);
 let module$1 = require("module");
+let _tsrx_core = require("@tsrx/core");
 let node_module = require("node:module");
 let volar_service_css = require("volar-service-css");
 
@@ -19995,14 +19996,14 @@ var import_node = require_node();
 * @import {TextDocument} from 'vscode-languageserver-textdocument';
 * @import {TSRXVirtualCodeInstance} from '@tsrx/typescript-plugin/src/language.js';
 */
-/** @import {TSRXCompileError} from '@tsrx/ripple'; */
+/** @import {CompileError} from '@tsrx/core/types'; */
 var import_language_server = require_language_server();
-const { log: log$8 } = createLogging("[Ripple Compile Error Diagnostic Plugin]");
+const { log: log$9 } = createLogging("[Ripple Compile Error Diagnostic Plugin]");
 /**
 * @returns {LanguageServicePlugin}
 */
 function createCompileErrorDiagnosticPlugin() {
-	log$8("Creating Ripple diagnostic plugin...");
+	log$9("Creating Ripple diagnostic plugin...");
 	return {
 		name: "ripple-diagnostics",
 		capabilities: { diagnosticProvider: {
@@ -20011,7 +20012,7 @@ function createCompileErrorDiagnosticPlugin() {
 		} },
 		create(context) {
 			return { provideDiagnostics(document, _token) {
-				log$8("Providing Ripple diagnostics for:", document.uri);
+				log$9("Providing Ripple diagnostics for:", document.uri);
 				/** @type {Diagnostic[]} */
 				const diagnostics = [];
 				const { virtualCode, sourceMap } = getVirtualCode(document, context);
@@ -20021,14 +20022,14 @@ function createCompileErrorDiagnosticPlugin() {
 					const diagnostic = parseCompilationErrorWithDocument(error, virtualCode, sourceMap, document);
 					diagnostics.push(diagnostic);
 				}
-				log$8("Generated", diagnostics.length, "diagnostics");
+				log$9("Generated", diagnostics.length, "diagnostics");
 				return diagnostics;
 			} };
 		}
 	};
 }
 /**
-* @param {TSRXCompileError} error
+* @param {CompileError} error
 * @param {TSRXVirtualCodeInstance} virtualCode
 * @param {Mapper | undefined} sourceMap
 * @param {TextDocument} document
@@ -20084,7 +20085,7 @@ function parseCompilationErrorWithDocument(error, virtualCode, sourceMap, docume
 	};
 }
 /**
-* @param {TSRXCompileError} error
+* @param {CompileError} error
 * @param {TextDocument} document
 * @returns {Range}
 */
@@ -20096,7 +20097,7 @@ function get_error_range_from_source(error, document) {
 	};
 }
 /**
-* @param {TSRXCompileError} error
+* @param {CompileError} error
 * @param {number} [start_offset]
 * @returns {number}
 */
@@ -20105,7 +20106,7 @@ function get_end_offset_from_error(error, start_offset) {
 	return error.end ? error.end : error.raisedAt && (error.raisedAt ?? 0) > start_offset ? error.raisedAt : start_offset + 1;
 }
 /**
-* @param {TSRXCompileError} error
+* @param {CompileError} error
 * @returns {number}
 */
 function get_start_offset_from_error(error) {
@@ -20115,9 +20116,9 @@ function get_start_offset_from_error(error) {
 //#endregion
 //#region ../typescript-plugin/src/language.js
 init_main();
-/** @import { CodeMapping } from '@tsrx/ripple' */
-/** @import {TSRXCompileError, VolarMappingsResult} from '@tsrx/ripple' */
-/** @typedef {{ code?: string, errors?: TSRXCompileError[] }} TSRXCompileResult */
+/** @import * as AST from 'estree'; */
+/** @import {CompileError, VolarMappingsResult, CodeMapping} from '@tsrx/core/types' */
+/** @typedef {{ code?: string, errors?: CompileError[] }} TSRXCompileResult */
 /** @typedef {{ compile?: (source: string, filename: string, options?: { loose?: boolean }) => TSRXCompileResult, compile_to_volar_mappings(source: string, filename: string, options?: { loose?: boolean }): VolarMappingsResult }} TSRXCompilerModule */
 /** @typedef {Map<string, CodeMapping>} CachedMappings */
 /** @typedef {import('typescript').CompilerOptions} CompilerOptions */
@@ -20130,7 +20131,7 @@ init_main();
 var import_language_core = require_language_core();
 const require$2 = (0, module$1.createRequire)(require("url").pathToFileURL(__filename).href);
 const root_dirname = path.default.dirname((0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
-const { log: log$7, logWarning, logError: logError$3 } = createLogging("[Ripple Language]");
+const { log: log$8, logWarning, logError: logError$4 } = createLogging("[Ripple Language]");
 /** @type {Set<string>} */
 const loggedCompilationFailures = /* @__PURE__ */ new Set();
 const RIPPLE_EXTENSIONS = [".tsrx"];
@@ -20204,12 +20205,12 @@ function is_ripple_file(file_name) {
 * @returns {RippleLanguagePlugin}
 */
 function getRippleLanguagePlugin() {
-	log$7("Creating Ripple language plugin...");
+	log$8("Creating Ripple language plugin...");
 	return {
 		getLanguageId(fileNameOrUri) {
 			const file_name = typeof fileNameOrUri === "string" ? fileNameOrUri : fileNameOrUri.fsPath.replace(/\\/g, "/");
 			if (is_ripple_file(file_name)) {
-				log$7("Identified Ripple file:", file_name);
+				log$8("Identified Ripple file:", file_name);
 				return "ripple";
 			}
 		},
@@ -20218,21 +20219,21 @@ function getRippleLanguagePlugin() {
 				const file_name = normalizeFileNameOrUri(fileNameOrUri);
 				const ripple = get_tsrx_compiler(file_name);
 				if (!ripple) {
-					logError$3(`Ripple compiler not found for file: ${file_name}`);
+					logError$4(`Ripple compiler not found for file: ${file_name}`);
 					return;
 				}
-				log$7("Creating virtual code for:", file_name);
+				log$8("Creating virtual code for:", file_name);
 				try {
 					return new TSRXVirtualCode(file_name, snapshot, ripple);
 				} catch (err) {
-					logError$3("Failed to create virtual code for:", file_name, ":", err);
+					logError$4("Failed to create virtual code for:", file_name, ":", err);
 					throw err;
 				}
 			}
 		},
 		updateVirtualCode(fileNameOrUri, virtualCode, snapshot) {
 			if (virtualCode instanceof TSRXVirtualCode) {
-				log$7("Updating existing virtual code for:", virtualCode.fileName);
+				log$8("Updating existing virtual code for:", virtualCode.fileName);
 				virtualCode.update(snapshot);
 				return virtualCode;
 			}
@@ -20274,9 +20275,9 @@ var TSRXVirtualCode = class {
 	embeddedCodes = [];
 	/** @type {CodeMapping[]} */
 	mappings = [];
-	/** @type {TSRXCompileError[]} */
+	/** @type {CompileError[]} */
 	fatalErrors = [];
-	/** @type {TSRXCompileError[]} */
+	/** @type {CompileError[]} */
 	usageErrors = [];
 	/** @type {IScriptSnapshot} */
 	snapshot;
@@ -20284,6 +20285,10 @@ var TSRXVirtualCode = class {
 	sourceSnapshot;
 	/** @type {string} */
 	originalCode = "";
+	/** @type {AST.Program | null} */
+	sourceAst = null;
+	/** @type {boolean} */
+	isDotCompletionMode = false;
 	/** @type {unknown[]} */
 	diagnostics = [];
 	/** @type {CachedMappings | null} */
@@ -20296,14 +20301,14 @@ var TSRXVirtualCode = class {
 	* @param {TSRXCompilerModule} tsrx
 	*/
 	constructor(file_name, snapshot, tsrx) {
-		log$7("Initializing TSRXVirtualCode for:", file_name);
+		log$8("Initializing TSRXVirtualCode for:", file_name);
 		this.fileName = file_name;
 		this.tsrx = tsrx;
 		this.snapshot = snapshot;
 		this.sourceSnapshot = snapshot;
 		this.originalCode = snapshot.getText(0, snapshot.getLength());
 		if (!tsrx || typeof tsrx.compile_to_volar_mappings !== "function") {
-			logError$3("Invalid ripple compiler - missing compile_to_volar_mappings method");
+			logError$4("Invalid ripple compiler - missing compile_to_volar_mappings method");
 			throw new Error("Invalid ripple compiler");
 		}
 		this.update(snapshot);
@@ -20313,7 +20318,7 @@ var TSRXVirtualCode = class {
 	* @returns {void}
 	*/
 	update(snapshot) {
-		log$7("Updating virtual code for:", this.fileName);
+		log$8("Updating virtual code for:", this.fileName);
 		const newCode = snapshot.getText(0, snapshot.getLength());
 		const changeRange = snapshot.getChangeRange(this.sourceSnapshot);
 		this.sourceSnapshot = snapshot;
@@ -20321,50 +20326,53 @@ var TSRXVirtualCode = class {
 		this.#mappingSourceToGen = null;
 		this.fatalErrors = [];
 		this.usageErrors = [];
+		this.sourceAst = null;
+		this.isDotCompletionMode = false;
 		/** @type {VolarMappingsResult | undefined} */
 		let transpiled;
 		let isDotTyped = false;
 		let dotPosition = -1;
-		log$7("changeRange:", JSON.stringify(changeRange));
+		log$8("changeRange:", JSON.stringify(changeRange));
 		if (changeRange) {
 			const changeStart = changeRange.span.start;
 			const changeEnd = changeStart + changeRange.span.length;
 			const newEnd = changeStart + changeRange.newLength;
 			const oldText = this.originalCode.substring(changeStart, changeEnd);
 			const newText = newCode.substring(changeStart, newEnd);
-			log$7("Change details:");
-			log$7("  Position:", changeStart, "-", changeEnd, "(length:", changeRange.span.length, ")");
-			log$7("  Old text:", JSON.stringify(oldText));
-			log$7("  New text:", JSON.stringify(newText), "(length:", changeRange.newLength, ")");
+			log$8("Change details:");
+			log$8("  Position:", changeStart, "-", changeEnd, "(length:", changeRange.span.length, ")");
+			log$8("  Old text:", JSON.stringify(oldText));
+			log$8("  New text:", JSON.stringify(newText), "(length:", changeRange.newLength, ")");
 			if (newText.endsWith(".")) {
 				const charBeforeDot = newEnd > 1 ? newCode[newEnd - 2] : "";
-				log$7("  Char before dot:", JSON.stringify(charBeforeDot));
+				log$8("  Char before dot:", JSON.stringify(charBeforeDot));
 				if (/[$#_\u200C\u200D\p{ID_Continue}\)\]\}]/u.test(charBeforeDot)) {
 					isDotTyped = true;
 					dotPosition = newEnd - 1;
-					log$7("ChangeRange detected dot typed at position", dotPosition);
+					log$8("ChangeRange detected dot typed at position", dotPosition);
 				}
 			}
 		}
 		try {
 			if (isDotTyped && dotPosition >= 0) {
+				this.isDotCompletionMode = true;
 				const codeWithoutDot = newCode.substring(0, dotPosition) + newCode.substring(dotPosition + 1);
-				log$7("Compiling without typed dot at position", dotPosition);
+				log$8("Compiling without typed dot at position", dotPosition);
 				transpiled = this.tsrx.compile_to_volar_mappings(codeWithoutDot, this.fileName, { loose: true });
-				log$7("Compilation without dot successful");
+				log$8("Compilation without dot successful");
 				if (transpiled && transpiled.code && transpiled.mappings.length > 0) {
 					const insertedDotPosition = restore_typed_dot_in_transpiled_code(transpiled, dotPosition);
 					if (insertedDotPosition === null) logWarning("Failed to restore typed dot into transpiled output");
-					else log$7("Inserted typed dot at generated position", insertedDotPosition);
+					else log$8("Inserted typed dot at generated position", insertedDotPosition);
 				}
 			} else {
-				log$7("Compiling Ripple code...");
+				log$8("Compiling Ripple code...");
 				transpiled = this.tsrx.compile_to_volar_mappings(newCode, this.fileName, { loose: true });
-				log$7("Compilation successful, generated code length:", transpiled?.code?.length || 0);
+				log$8("Compilation successful, generated code length:", transpiled?.code?.length || 0);
 			}
 		} catch (e) {
 			const error = e;
-			logError$3("Ripple compilation failed for", this.fileName, ":", error);
+			logError$4("Ripple compilation failed for", this.fileName, ":", error);
 			if (process.env.TSRX_TSC === "true") logTSRXErrors(this.fileName, [error]);
 			error.type = "fatal";
 			this.fatalErrors.push(error);
@@ -20374,13 +20382,14 @@ var TSRXVirtualCode = class {
 			this.generatedCode = transpiled.code;
 			this.mappings = transpiled.mappings ?? [];
 			this.usageErrors = transpiled.errors;
+			this.sourceAst = transpiled.sourceAst;
 			if (process.env.TSRX_TSC === "true" && transpiled.errors.length > 0) logTSRXErrors(this.fileName, transpiled.errors);
 			const cssMappings = transpiled.cssMappings;
 			if (cssMappings.length > 0) {
-				log$7("Creating", cssMappings.length, "CSS embedded codes");
+				log$8("Creating", cssMappings.length, "CSS embedded codes");
 				this.embeddedCodes = cssMappings.map((mapping, index) => {
 					const cssContent = mapping.data?.customData?.content;
-					log$7(`CSS region ${index}: \
+					log$8(`CSS region ${index}: \
 						offset ${mapping.sourceOffsets[0]}-${mapping.sourceOffsets[0] + mapping.lengths[0]}, \
 						length ${mapping.lengths[0]}`);
 					return {
@@ -20397,17 +20406,17 @@ var TSRXVirtualCode = class {
 				});
 			} else this.embeddedCodes = [];
 			if (DEBUG) {
-				log$7("CSS embedded codes:", (this.embeddedCodes || []).length);
-				log$7("Using transpiled code, mapping count:", this.mappings.length);
-				log$7("Original code length:", newCode.length);
-				log$7("Generated code length:", this.generatedCode.length);
-				log$7("Last 100 chars of original:", JSON.stringify(newCode.slice(-100)));
-				log$7("Last 200 chars of generated:", JSON.stringify(this.generatedCode.slice(-200)));
-				log$7("Last few mappings:");
+				log$8("CSS embedded codes:", (this.embeddedCodes || []).length);
+				log$8("Using transpiled code, mapping count:", this.mappings.length);
+				log$8("Original code length:", newCode.length);
+				log$8("Generated code length:", this.generatedCode.length);
+				log$8("Last 100 chars of original:", JSON.stringify(newCode.slice(-100)));
+				log$8("Last 200 chars of generated:", JSON.stringify(this.generatedCode.slice(-200)));
+				log$8("Last few mappings:");
 				const startIdx = Math.max(0, this.mappings.length - 5);
 				for (let i = startIdx; i < this.mappings.length; i++) {
 					const m = this.mappings[i];
-					log$7(`  Mapping ${i}: source[${m.sourceOffsets[0]}:${m.sourceOffsets[0] + m.lengths[0]}] -> gen[${m.generatedOffsets[0]}:${m.generatedOffsets[0] + m.lengths[0]}], len=${m.lengths[0]}, completion=${m.data?.completion}`);
+					log$8(`  Mapping ${i}: source[${m.sourceOffsets[0]}:${m.sourceOffsets[0] + m.lengths[0]}] -> gen[${m.generatedOffsets[0]}:${m.generatedOffsets[0] + m.lengths[0]}], len=${m.lengths[0]}, completion=${m.data?.completion}`);
 				}
 			}
 			this.snapshot = {
@@ -20416,7 +20425,7 @@ var TSRXVirtualCode = class {
 				getChangeRange: () => void 0
 			};
 		} else {
-			log$7("Compilation failed, only display where the compilation error occurred.");
+			log$8("Compilation failed, only display where the compilation error occurred.");
 			this.originalCode = newCode;
 			this.generatedCode = newCode;
 			this.mappings = [{
@@ -20510,7 +20519,7 @@ function extractCssFromSource(code) {
 		const cssContent = match[1];
 		const cssStart = match.index + (fullMatch.indexOf(">") + 1);
 		const cssLength = cssContent.length;
-		log$7(`Extracted CSS region ${index}: offset ${cssStart}, length ${cssLength}`);
+		log$8(`Extracted CSS region ${index}: offset ${cssStart}, length ${cssLength}`);
 		/** @type {CodeMapping} */
 		const mapping = {
 			sourceOffsets: [cssStart],
@@ -20543,7 +20552,7 @@ function extractCssFromSource(code) {
 		});
 		index++;
 	}
-	if (embeddedCodes.length > 0) log$7(`Extracted ${embeddedCodes.length} CSS embedded codes from style tags`);
+	if (embeddedCodes.length > 0) log$8(`Extracted ${embeddedCodes.length} CSS embedded codes from style tags`);
 	return embeddedCodes;
 }
 /**
@@ -20724,7 +20733,7 @@ function find_workspace_compiler_entry_for_file(normalized_file_name, exists_syn
 			if (available_candidates.length > 0) {
 				const package_manifest = get_nearest_package_manifest(dir, exists_sync);
 				found_path = available_candidates.find(([compiler_name, , package_hints]) => package_manifest_matches_compiler(package_manifest, compiler_name, package_hints))?.[1] ?? available_candidates[0][1];
-				log$7("Found tsrx compiler at:", found_path, "for extension:", ext);
+				log$8("Found tsrx compiler at:", found_path, "for extension:", ext);
 			}
 			compiler_path_map.set(cache_key, found_path);
 		}
@@ -20777,7 +20786,7 @@ function getCachedTypeDefinitionFile(typesFilePath) {
 		logWarning(`Types file does not exist at path: ${typesFilePath}`);
 		return;
 	}
-	log$7(`Found ripple types at: ${typesFilePath}`);
+	log$8(`Found ripple types at: ${typesFilePath}`);
 	const fileContent = fs.default.readFileSync(typesFilePath, "utf8");
 	if (!fileContent) {
 		logWarning(`Failed to read content of types file at: ${typesFilePath}`);
@@ -20813,8 +20822,8 @@ function get_compiler_dir_for_file(normalized_file_name) {
 //#endregion
 //#region src/definitionPlugin.js
 /** @import { LanguageServicePlugin, LocationLink } from '@volar/language-server'; */
-/** @import { DefinitionLocation } from '@tsrx/ripple'; */
-const { log: log$6 } = createLogging("[Ripple Definition Plugin]");
+/** @import { DefinitionLocation } from '@tsrx/core/types'; */
+const { log: log$7 } = createLogging("[Ripple Definition Plugin]");
 /** @type {string | undefined} */
 let ripple_dir;
 /**
@@ -20835,21 +20844,21 @@ function createDefinitionPlugin() {
 				}
 				const { virtualCode, sourceUri } = getVirtualCode(document, context);
 				if (virtualCode.languageId !== "ripple") {
-					log$6(`Skipping definitions processing in the '${virtualCode.languageId}' context`);
+					log$7(`Skipping definitions processing in the '${virtualCode.languageId}' context`);
 					return tsDefinitions;
 				}
 				const offset = document.offsetAt(position);
 				const { word, start, end } = getWordFromPosition(document.getText(), offset);
 				const customMapping = virtualCode.findMappingByGeneratedRange(start, end);
-				log$6(`Cursor position in generated code for word '${word}':`, position);
-				log$6(`Cursor offset in generated code for word '${word}':`, offset);
+				log$7(`Cursor position in generated code for word '${word}':`, position);
+				log$7(`Cursor offset in generated code for word '${word}':`, offset);
 				if (customMapping?.data.customData.definition !== false && customMapping?.data.customData.definition?.typeReplace) {
 					const { name: typeName, path: typePath } = customMapping.data.customData.definition.typeReplace;
-					log$6(`Found replace definition for ${typeName}`);
+					log$7(`Found replace definition for ${typeName}`);
 					const filePath = sourceUri.fsPath || sourceUri.path;
 					ripple_dir = ripple_dir ?? get_compiler_dir_for_file(normalizeFileNameOrUri(filePath));
 					if (!ripple_dir) {
-						log$6(`Could not determine Ripple source directory for file: ${filePath}`);
+						log$7(`Could not determine Ripple source directory for file: ${filePath}`);
 						return;
 					}
 					const typesFilePath = path.default.join(ripple_dir, ...typePath.split("/"));
@@ -20897,7 +20906,7 @@ function createDefinitionPlugin() {
 								end: originEnd
 							}
 						};
-						log$6(`Created definition link to ${typesFilePath}:${line}:${character}`);
+						log$7(`Created definition link to ${typesFilePath}:${line}:${character}`);
 						return [locationLink];
 					}
 				}
@@ -20908,16 +20917,16 @@ function createDefinitionPlugin() {
 						const embedMapping = embeddedCode.mappings[0];
 						const sourceStartOffset = embedMapping.sourceOffsets[0] + loc.start;
 						const sourceEndOffset = embedMapping.sourceOffsets[0] + loc.end;
-						log$6("Source document offsets - start for matching css:", sourceStartOffset, "end:", sourceEndOffset);
+						log$7("Source document offsets - start for matching css:", sourceStartOffset, "end:", sourceEndOffset);
 						const sourceDocument = TextDocument.create(sourceUri.toString(), "ripple", 0, virtualCode.originalCode);
 						const targetStart = sourceDocument.positionAt(sourceStartOffset);
 						const targetEnd = sourceDocument.positionAt(sourceEndOffset);
-						log$6("Target positions in source - start:", targetStart, "end:", targetEnd);
+						log$7("Target positions in source - start:", targetStart, "end:", targetEnd);
 						const generatedStart = customMapping.generatedOffsets[0];
 						const generatedEnd = generatedStart + customMapping.generatedLengths[0];
 						const originStart = document.positionAt(generatedStart);
 						const originEnd = document.positionAt(generatedEnd);
-						log$6("Origin positions - start:", originStart, "end:", originEnd);
+						log$7("Origin positions - start:", originStart, "end:", originEnd);
 						/** @type {LocationLink} */
 						tsDefinitions.push({
 							targetUri: sourceUri.toString(),
@@ -20951,7 +20960,7 @@ LanguageServicePlugin,
 LanguageServicePluginInstance,
 MarkupContent,
 } from '@volar/language-server'; */
-const { log: log$5, logError: logError$2 } = createLogging("[Ripple Hover Plugin]");
+const { log: log$6, logError: logError$3 } = createLogging("[Ripple Hover Plugin]");
 /**
 * @returns {LanguageServicePlugin}
 */
@@ -20970,7 +20979,7 @@ function createHoverPlugin() {
 				instance.provideHover = void 0;
 				break;
 			}
-			if (!originalProvideHover) logError$2("'typescript-semantic plugin' was not found or has no 'provideHover'. 					This plugin must be loaded after Volar's typescript-semantic plugin.");
+			if (!originalProvideHover) logError$3("'typescript-semantic plugin' was not found or has no 'provideHover'. 					This plugin must be loaded after Volar's typescript-semantic plugin.");
 			return { async provideHover(document, position, token) {
 				let tsHover = null;
 				if (originalProvideHover) tsHover = await originalProvideHover.call(originalInstance, document, position, token);
@@ -20993,11 +21002,11 @@ function createHoverPlugin() {
 					const { word, start, end } = getWordFromPosition(document.getText(), offset);
 					starOffset = start;
 					endOffset = end;
-					log$5(`Cursor position in generated code for word '${word}':`, position);
-					log$5(`Cursor offset in generated code for word '${word}':`, offset);
+					log$6(`Cursor position in generated code for word '${word}':`, position);
+					log$6(`Cursor offset in generated code for word '${word}':`, offset);
 				}
 				if (virtualCode.languageId !== "ripple") {
-					log$5(`Skipping hover processing in the '${virtualCode.languageId}' context`);
+					log$6(`Skipping hover processing in the '${virtualCode.languageId}' context`);
 					return tsHover;
 				}
 				const mapping = virtualCode.findMappingByGeneratedRange(starOffset, endOffset);
@@ -21010,7 +21019,7 @@ function createHoverPlugin() {
 							/** @type {MarkupContent} **/
 							tsHover.contents.value
 						);
-						log$5("Modified hover contents using custom hover function");
+						log$6("Modified hover contents using custom hover function");
 					}
 					return tsHover;
 				} else if (typeof customHover === "string") {
@@ -21019,7 +21028,7 @@ function createHoverPlugin() {
 						tsHover.contents.value,
 						customHover
 					) : customHover;
-					log$5("Found custom hover data in mapping");
+					log$6("Found custom hover data in mapping");
 					return {
 						contents: {
 							kind: "markdown",
@@ -21031,10 +21040,10 @@ function createHoverPlugin() {
 						}
 					};
 				} else if (customHover === false) {
-					log$5(`Hover explicitly suppressed in mapping at range start: ${starOffset}, end: ${endOffset}`);
+					log$6(`Hover explicitly suppressed in mapping at range start: ${starOffset}, end: ${endOffset}`);
 					return null;
 				}
-				log$5("Found mapping for hover at range", "start: ", starOffset, "end: ", endOffset);
+				log$6("Found mapping for hover at range", "start: ", starOffset, "end: ", endOffset);
 				return tsHover;
 			} };
 		}
@@ -21044,7 +21053,7 @@ function createHoverPlugin() {
 //#endregion
 //#region src/completionPlugin.js
 /** @import { LanguageServicePlugin, TextEdit, CompletionItem } from '@volar/language-server'; */
-const { log: log$4 } = createLogging("[Ripple Completion Plugin]");
+const { log: log$5 } = createLogging("[Ripple Completion Plugin]");
 /**
 * Snippets that require auto-import from 'ripple'
 * @type {Array<{label: string, filterText: string, detail: string, documentation: string, insertText: string, importName: string | null}>}
@@ -21380,7 +21389,7 @@ function createCompletionPlugin() {
 					};
 					const { virtualCode } = getVirtualCode(document, context);
 					if (virtualCode && virtualCode.languageId !== "ripple") {
-						log$4(`Skipping Ripple completions in the '${virtualCode.languageId}' context`);
+						log$5(`Skipping Ripple completions in the '${virtualCode.languageId}' context`);
 						return {
 							items: [],
 							isIncomplete: false
@@ -21395,7 +21404,7 @@ function createCompletionPlugin() {
 					});
 					/** @type {CompletionItem[]} */
 					const items = [];
-					log$4("🔔 Completion triggered:", {
+					log$5("🔔 Completion triggered:", {
 						triggerKind: completionContext.triggerKind,
 						triggerKindName: completionContext.triggerKind === 1 ? "Invoked" : completionContext.triggerKind === 2 ? "TriggerCharacter" : completionContext.triggerKind === 3 ? "Incomplete" : "Unknown",
 						triggerCharacter: completionContext.triggerCharacter || "(none)",
@@ -21454,7 +21463,7 @@ function createCompletionPlugin() {
 					}
 					const wordMatch = line.match(/(\w+)$/);
 					const currentWord = wordMatch ? wordMatch[1] : "";
-					log$4("Current word:", currentWord, "length:", currentWord.length);
+					log$5("Current word:", currentWord, "length:", currentWord.length);
 					items.push(...RIPPLE_SNIPPETS);
 					return {
 						items,
@@ -21469,7 +21478,7 @@ function createCompletionPlugin() {
 //#endregion
 //#region src/autoInsertPlugin.js
 /** @import { LanguageServicePlugin } from '@volar/language-server' */
-const { log: log$3 } = createLogging("[Ripple Auto-Insert Plugin]");
+const { log: log$4 } = createLogging("[Ripple Auto-Insert Plugin]");
 /**
 * List of HTML void/self-closing elements that don't need closing tags
 * https://developer.mozilla.org/en-US/docs/Glossary/Void_element
@@ -21521,7 +21530,7 @@ async provideAutoInsertSnippet(document, position, lastChange, _token) {
 				if (!lastChange.text.endsWith(">")) return null;
 				const { virtualCode } = getVirtualCode(document, context);
 				if (virtualCode.languageId !== "ripple") {
-					log$3(`Skipping auto-insert processing in the '${virtualCode.languageId}' context`);
+					log$4(`Skipping auto-insert processing in the '${virtualCode.languageId}' context`);
 					return null;
 				}
 				const offset = document.offsetAt(position);
@@ -21544,11 +21553,11 @@ async provideAutoInsertSnippet(document, position, lastChange, _token) {
 					if (attempts === 3) break;
 				}
 				if (!found) {
-					log$3(`No opening tag position found from source position ${sourceOffset}`);
+					log$4(`No opening tag position found from source position ${sourceOffset}`);
 					return null;
 				}
 				const line = sourceCode.slice(i, sourceOffset + 1);
-				log$3("Auto-insert triggered at:", {
+				log$4("Auto-insert triggered at:", {
 					selection: `${position.line}:${position.character}`,
 					line,
 					change: lastChange,
@@ -21556,13 +21565,13 @@ async provideAutoInsertSnippet(document, position, lastChange, _token) {
 				});
 				const tagMatch = line.match(/<([@$\w][\w.-]*)[^>]*?(?<!\/)>$/);
 				if (!tagMatch) {
-					log$3("No tag match found");
+					log$4("No tag match found");
 					return null;
 				}
 				const tagName = tagMatch[1];
-				log$3("Tag matched:", tagName);
+				log$4("Tag matched:", tagName);
 				if (VOID_ELEMENTS.has(tagName.toLowerCase())) {
-					log$3("Void element, skipping auto-close:", tagName);
+					log$4("Void element, skipping auto-close:", tagName);
 					return null;
 				}
 				if (document.getText({
@@ -21572,11 +21581,11 @@ async provideAutoInsertSnippet(document, position, lastChange, _token) {
 						character: position.character + 100
 					}
 				}).startsWith(`</${tagName}>`)) {
-					log$3("Closing tag already exists, skipping");
+					log$4("Closing tag already exists, skipping");
 					return null;
 				}
 				const closingTag = `</${tagName}>`;
-				log$3("Inserting closing tag:", closingTag);
+				log$4("Inserting closing tag:", closingTag);
 				return `$0${closingTag}`;
 			} };
 		}
@@ -21594,7 +21603,7 @@ Diagnostic,
 } from '@volar/language-server';
 @import {TextDocument} from 'vscode-languageserver-textdocument';
 */
-const { log: log$2, logError: logError$1 } = createLogging("[Ripple TypeScript Diagnostic Plugin]");
+const { log: log$3, logError: logError$2 } = createLogging("[Ripple TypeScript Diagnostic Plugin]");
 /**
 * @param {Diagnostic} diagnostic
 * @param {Diagnostic[]} items
@@ -21612,7 +21621,7 @@ function process$1(diagnostic, items) {
 */
 function processDiagnostics(document, context, diagnostics) {
 	if (!diagnostics || diagnostics.length === 0) return diagnostics;
-	log$2(`Filtering ${diagnostics.length} TypeScript diagnostics for ${document.uri}`);
+	log$3(`Filtering ${diagnostics.length} TypeScript diagnostics for ${document.uri}`);
 	const { virtualCode } = getVirtualCode(document, context);
 	if (!virtualCode || virtualCode.languageId !== "ripple") return diagnostics;
 	/** @type {Diagnostic[]} */
@@ -21634,12 +21643,12 @@ function processDiagnostics(document, context, diagnostics) {
 		}
 		const diagnosticCode = typeof diagnostic.code === "number" ? diagnostic.code : typeof diagnostic.code === "string" ? parseInt(diagnostic.code) : null;
 		if (diagnosticCode && suppressedCodes.includes(diagnosticCode)) {
-			log$2(`Suppressing diagnostic ${diagnosticCode}: ${diagnostic.message}`);
+			log$3(`Suppressing diagnostic ${diagnosticCode}: ${diagnostic.message}`);
 			continue;
 		}
 		process$1(diagnostic, result);
 	}
-	log$2(`Filtered from ${diagnostics.length} to ${result.length} diagnostics`);
+	log$3(`Filtered from ${diagnostics.length} to ${result.length} diagnostics`);
 	return result;
 }
 /**
@@ -21650,7 +21659,7 @@ function processDiagnostics(document, context, diagnostics) {
 * @returns {LanguageServicePlugin}
 */
 function createTypeScriptDiagnosticFilterPlugin() {
-	log$2("Creating TypeScript diagnostic filter plugin...");
+	log$3("Creating TypeScript diagnostic filter plugin...");
 	return {
 		name: "ripple-typescript-diagnostic-filter",
 		capabilities: {},
@@ -21665,10 +21674,10 @@ function createTypeScriptDiagnosticFilterPlugin() {
 				instance.provideDiagnostics = async function(document, token) {
 					return processDiagnostics(document, context, await originalProvider?.call(originalInstance, document, token) ?? []);
 				};
-				log$2("Successfully wrapped typescript-semantic provideDiagnostics");
+				log$3("Successfully wrapped typescript-semantic provideDiagnostics");
 				break;
 			}
-			if (!originalProvider) logError$1("'typescript-semantic plugin' was not found or has no 'provideDiagnostics'. 					This plugin must be loaded after Volar's typescript-semantic plugin.");
+			if (!originalProvider) logError$2("'typescript-semantic plugin' was not found or has no 'provideDiagnostics'. 					This plugin must be loaded after Volar's typescript-semantic plugin.");
 			return {};
 		}
 	};
@@ -21678,7 +21687,7 @@ function createTypeScriptDiagnosticFilterPlugin() {
 //#region src/documentHighlightPlugin.js
 /** @import { LanguageServicePlugin } from '@volar/language-server' */
 /** @import { LanguageServicePluginInstance } from '@volar/language-server' */
-const { log: log$1 } = createLogging("[Ripple Document Highlight Plugin]");
+const { log: log$2 } = createLogging("[Ripple Document Highlight Plugin]");
 /**
 * Document Highlight plugin for Ripple
 * Provides word highlighting (grey background) for custom Ripple keywords like 'pending'
@@ -21699,14 +21708,14 @@ function createDocumentHighlightPlugin() {
 				instance.provideDocumentHighlights = void 0;
 				break;
 			}
-			if (!originalProvideDocumentHighlights) log$1("'typescript-semantic plugin' was not found or has no 'provideDocumentHighlights'. 					Document highlights will be limited to custom Ripple keywords only.");
+			if (!originalProvideDocumentHighlights) log$2("'typescript-semantic plugin' was not found or has no 'provideDocumentHighlights'. 					Document highlights will be limited to custom Ripple keywords only.");
 			return { async provideDocumentHighlights(document, position, token) {
 				if (!originalProvideDocumentHighlights) return null;
 				let tsHighlights = await originalProvideDocumentHighlights.call(originalInstance, document, position, token);
 				if (!tsHighlights || tsHighlights.length > 0) return tsHighlights;
 				const { virtualCode } = getVirtualCode(document, context);
 				if (virtualCode.languageId !== "ripple") {
-					log$1(`Skipping highlight processing in the '${virtualCode.languageId}' context`);
+					log$2(`Skipping highlight processing in the '${virtualCode.languageId}' context`);
 					return tsHighlights;
 				}
 				const offset = document.offsetAt(position);
@@ -21729,13 +21738,409 @@ function createDocumentHighlightPlugin() {
 						kind: mapping.data.customData.wordHighlight.kind
 					});
 				}
-				if (tsHighlights.length > 0) log$1(`Found ${tsHighlights.length} occurrences of '${word}'`);
+				if (tsHighlights.length > 0) log$2(`Found ${tsHighlights.length} occurrences of '${word}'`);
 				return [...tsHighlights];
 			} };
 		}
 	};
 }
 
+//#endregion
+//#region src/documentSymbolPlugin.js
+/** @import * as AST from 'estree' */
+/** @import { LanguageServicePlugin } from '@volar/language-server' */
+/** @import { DocumentSymbol, Mapper, Range, SymbolKind as SymbolKindType } from '@volar/language-server' */
+/** @import { CodeInformation } from '@volar/language-core'; */
+/** @import { TSRXVirtualCodeInstance } from '@tsrx/typescript-plugin/src/language.js'; */
+/** @import { CodeMapping } from '@tsrx/core/types'; */
+init_main();
+/**
+* @typedef {AST.Node & {
+* 	body?: AST.Node[] | { body?: AST.Node[] };
+* }} NodeWithBody;
+*/
+/**
+* @typedef {AST.Node & {
+* 	id?: AST.Identifier
+* }} NodeWithId;
+*/
+/**
+* @typedef {[
+* Omit<DocumentSymbol, 'children'> & { children: SymbolInfo[] }, {
+* 	rangeNode: AST.Node;
+* 	selectionNode: AST.Node;
+* }]} SymbolInfo;
+*/
+const { log: log$1, logError: logError$1 } = createLogging("[Ripple Document Symbol Plugin]");
+/** @type {Map<string, DocumentSymbol[]>} */
+const documentSymbolCache = /* @__PURE__ */ new Map();
+/**
+* @returns {LanguageServicePlugin}
+*/
+function createDocumentSymbolPlugin() {
+	return {
+		name: "ripple-document-symbol",
+		capabilities: { documentSymbolProvider: true },
+		create(context) {
+			return { async provideDocumentSymbols(document) {
+				if (!is_ripple_document(document.uri)) return [];
+				const { virtualCode, sourceMap, sourceUri } = getVirtualCode(document, context);
+				const { sourceAst, languageId, originalCode } = virtualCode || {};
+				if (languageId !== "ripple") {
+					log$1(`Skipping symbols in the '${languageId}' context`);
+					return [];
+				}
+				const cacheKey = sourceUri.toString();
+				const cachedSymbols = documentSymbolCache.get(cacheKey) ?? [];
+				if (virtualCode?.fatalErrors?.length || virtualCode?.isDotCompletionMode) return cachedSymbols;
+				if (!sourceMap || !sourceAst) return [];
+				const sourceDocument = TextDocument.create(sourceUri.toString(), "ripple", 0, originalCode);
+				const symbols = mapDocumentSymbolsToGenerated(collectDocumentSymbols(sourceAst, sourceDocument), virtualCode, sourceDocument, document, sourceMap);
+				documentSymbolCache.set(cacheKey, symbols);
+				return symbols;
+			} };
+		}
+	};
+}
+/**
+* @param {SymbolInfo[]} symbols
+* @param {TSRXVirtualCodeInstance} virtualCode
+* @param {TextDocument} sourceDocument
+* @param {TextDocument} generatedDocument
+* @param {Mapper} sourceMap
+* @returns {DocumentSymbol[]}
+*/
+function mapDocumentSymbolsToGenerated(symbols, virtualCode, sourceDocument, generatedDocument, sourceMap) {
+	/** @type {DocumentSymbol[]} */
+	const mapped = [];
+	/** @type {CodeMapping | null} */
+	let mapping = null;
+	for (const [symbol, { rangeNode, selectionNode }] of symbols) {
+		/** @type {Range | null} */
+		let generatedSelectionRange = null;
+		mapping = virtualCode.findMappingBySourceRange(
+			/** @type {AST.NodeWithLocation} */
+			selectionNode.start,
+			/** @type {AST.NodeWithLocation} */
+			selectionNode.end
+		);
+		if (mapping && isSymbolMapping(mapping.data)) generatedSelectionRange = {
+			start: generatedDocument.positionAt(mapping.generatedOffsets[0]),
+			end: generatedDocument.positionAt(mapping.generatedOffsets[0] + mapping.generatedLengths[0])
+		};
+		if (!generatedSelectionRange) generatedSelectionRange = sourceRangeToGeneratedRange(symbol.selectionRange, sourceDocument, generatedDocument, sourceMap);
+		if (!generatedSelectionRange) continue;
+		const children = symbol.children ? mapDocumentSymbolsToGenerated(symbol.children, virtualCode, sourceDocument, generatedDocument, sourceMap) : void 0;
+		/** @type {Range | null} */
+		let generatedRange = null;
+		mapping = virtualCode.findMappingBySourceRange(
+			/** @type {AST.NodeWithLocation} */
+			rangeNode.start,
+			/** @type {AST.NodeWithLocation} */
+			rangeNode.end
+		);
+		if (mapping && isSymbolMapping(mapping.data)) generatedRange = {
+			start: generatedDocument.positionAt(mapping.generatedOffsets[0]),
+			end: generatedDocument.positionAt(mapping.generatedOffsets[0] + mapping.generatedLengths[0])
+		};
+		if (!generatedRange) generatedRange = sourceRangeToGeneratedRange(symbol.range, sourceDocument, generatedDocument, sourceMap);
+		if (!generatedRange) {
+			generatedRange = generatedSelectionRange;
+			if (children?.length) generatedRange = ensureRangeContainsChildren(generatedRange, children);
+		}
+		mapped.push({
+			...symbol,
+			range: generatedRange,
+			selectionRange: generatedSelectionRange,
+			children
+		});
+	}
+	return mapped;
+}
+/**
+* Breadcrumb providers expect parent symbol ranges to contain child symbol
+* ranges. Full component/function bodies may not have one continuous source
+* mapping after TSRX transforms, so widen the selection-range fallback around
+* any mapped child declarations.
+*
+* @param {Range} range
+* @param {DocumentSymbol[]} children
+* @returns {Range}
+*/
+function ensureRangeContainsChildren(range, children) {
+	let start = range.start;
+	let end = range.end;
+	for (const child of children) {
+		if (comparePositions(child.range.start, start) < 0) start = child.range.start;
+		if (comparePositions(child.range.end, end) > 0) end = child.range.end;
+	}
+	return {
+		start,
+		end
+	};
+}
+/**
+* @param {Range['start']} a
+* @param {Range['start']} b
+* @returns {number}
+*/
+function comparePositions(a, b) {
+	return a.line === b.line ? a.character - b.character : a.line - b.line;
+}
+/**
+* @param {Range} range
+* @param {TextDocument} sourceDocument
+* @param {TextDocument} generatedDocument
+* @param {Mapper} sourceMap
+* @returns {Range | null}
+*/
+function sourceRangeToGeneratedRange(range, sourceDocument, generatedDocument, sourceMap) {
+	const start = sourceDocument.offsetAt(range.start);
+	const end = sourceDocument.offsetAt(range.end);
+	for (const [generatedStart, generatedEnd] of sourceMap.toGeneratedRange(start, end, true, isSymbolMapping)) return {
+		start: generatedDocument.positionAt(generatedStart),
+		end: generatedDocument.positionAt(generatedEnd)
+	};
+	return null;
+}
+/**
+* @param {CodeInformation} data
+* @returns {boolean}
+*/
+function isSymbolMapping(data) {
+	return !!data.structure;
+}
+/**
+* @param {AST.Program} ast
+* @param {TextDocument} document
+* @returns {SymbolInfo[]}
+*/
+function collectDocumentSymbols(ast, document) {
+	return collectSymbolsFromStatements(Array.isArray(ast.body) ? ast.body : [], document);
+}
+/**
+* @param {AST.Node[]} statements
+* @param {TextDocument} document
+* @returns {SymbolInfo[]}
+*/
+function collectSymbolsFromStatements(statements, document) {
+	/** @type {SymbolInfo[]} */
+	const symbols = [];
+	for (const statement of statements) {
+		if (!statement) continue;
+		if (statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration") {
+			if (statement.declaration) symbols.push(...createSymbolForDeclaration(statement.declaration, document, statement.type === "ExportDefaultDeclaration" ? "default" : void 0));
+			continue;
+		}
+		symbols.push(...createSymbolForDeclaration(statement, document));
+	}
+	return symbols;
+}
+/**
+* @param {AST.Node} node
+* @param {TextDocument} document
+* @param {string} [fallbackName]
+* @returns { SymbolInfo[]}
+*/
+function createSymbolForDeclaration(node, document, fallbackName) {
+	const type = node.type;
+	let id = node.id ?? null;
+	let name = id ? getIdentifierName(id) : null;
+	switch (type) {
+		case "Component":
+		case "FunctionDeclaration": {
+			const children = getChildSymbols(node, document);
+			if (!id || !name) if (fallbackName) {
+				name = fallbackName;
+				id = createFallbackIdentifierNode(node, type === "Component" ? "component" : "function");
+			} else return children;
+			return [createNamedNodeSymbol(name, import_language_server.SymbolKind.Function, node, id, document, children)];
+		}
+		case "ClassDeclaration": {
+			const children = getClassChildSymbols(node, document);
+			if (!id || !name) if (fallbackName) {
+				name = fallbackName;
+				id = createFallbackIdentifierNode(node, "class");
+			} else return children;
+			return [createNamedNodeSymbol(name, import_language_server.SymbolKind.Class, node, id, document, children)];
+		}
+		case "VariableDeclaration": return createVariableDeclarationSymbols(node, document);
+		case "TSInterfaceDeclaration":
+			if (!id || !name) return [];
+			return [createNamedNodeSymbol(name, import_language_server.SymbolKind.Interface, node, id, document)];
+		case "TSTypeAliasDeclaration":
+			if (!id || !name) return [];
+			return [createNamedNodeSymbol(name, import_language_server.SymbolKind.TypeParameter, node, id, document)];
+		default: return [];
+	}
+}
+/**
+* @param {AST.VariableDeclaration} node
+* @param {TextDocument} document
+* @returns {SymbolInfo[]}
+*/
+function createVariableDeclarationSymbols(node, document) {
+	const kind = node.kind === "const" ? import_language_server.SymbolKind.Constant : import_language_server.SymbolKind.Variable;
+	/** @type {SymbolInfo[]} */
+	const symbols = [];
+	for (const declaration of node.declarations) {
+		if (declaration.id.type === "Identifier") {
+			symbols.push(createNamedNodeSymbol(declaration.id.name, kind, declaration, declaration.id, document, declaration.init ? getInitializerChildSymbols(declaration.init, document) : []));
+			continue;
+		}
+		symbols.push(...createBindingPatternSymbols(declaration.id, kind, document));
+	}
+	return symbols;
+}
+/**
+* @param {AST.Pattern} pattern
+* @param {SymbolKindType} kind
+* @param {TextDocument} document
+* @param {AST.Node} [rangeNode]
+* @returns {SymbolInfo[]}
+*/
+function createBindingPatternSymbols(pattern, kind, document, rangeNode = pattern) {
+	switch (pattern.type) {
+		case "Identifier": return [createNamedNodeSymbol(pattern.name, kind, rangeNode, pattern, document)];
+		case "ObjectPattern": {
+			/** @type {SymbolInfo[]} */
+			const symbols = [];
+			for (const property of pattern.properties) if (property.type === "RestElement") symbols.push(...createBindingPatternSymbols(property.argument, kind, document, property));
+			else symbols.push(...createBindingPatternSymbols(property.value, kind, document, property));
+			return symbols;
+		}
+		case "ArrayPattern": {
+			/** @type {SymbolInfo[]} */
+			const symbols = [];
+			for (const element of pattern.elements) if (element) symbols.push(...createBindingPatternSymbols(element, kind, document, element));
+			return symbols;
+		}
+		case "RestElement": return createBindingPatternSymbols(pattern.argument, kind, document, pattern);
+		case "AssignmentPattern": return createBindingPatternSymbols(pattern.left, kind, document, pattern);
+		default: return [];
+	}
+}
+/**
+* @param {AST.Node} node
+* @param {TextDocument} document
+* @returns {SymbolInfo[]}
+*/
+function getInitializerChildSymbols(node, document) {
+	if (node.type === "Component" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return getChildSymbols(node, document);
+	return [];
+}
+/**
+* @param {AST.Node | NodeWithBody} node
+* @param {TextDocument} document
+* @returns {SymbolInfo[]}
+*/
+function getChildSymbols(node, document) {
+	const body = node.body;
+	if (Array.isArray(body)) return collectSymbolsFromStatements(body, document);
+	else if (Array.isArray(body?.body)) return collectSymbolsFromStatements(body.body, document);
+	return [];
+}
+/**
+* @param {AST.ClassDeclaration} node
+* @param {TextDocument} document
+* @returns {SymbolInfo[]}
+*/
+function getClassChildSymbols(node, document) {
+	const body = !Array.isArray(node.body) && node.body?.body ? node.body.body : [];
+	/** @type {SymbolInfo[]} */
+	const symbols = [];
+	for (const member of body) {
+		if (member.type !== "MethodDefinition" && member.type !== "PropertyDefinition") continue;
+		const name = getPropertyName(member.key);
+		if (!name) continue;
+		symbols.push(createNamedNodeSymbol(name, member.type === "PropertyDefinition" ? import_language_server.SymbolKind.Property : import_language_server.SymbolKind.Method, member, member.key || member, document));
+	}
+	return symbols;
+}
+/**
+* @param {AST.Node | undefined | null} node
+* @returns {string | null}
+*/
+function getPropertyName(node) {
+	if (!node) return null;
+	if (node.type === "Identifier") return node.name || null;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	return null;
+}
+/**
+* @param {AST.Identifier | null | undefined } node
+* @returns {string | null}
+*/
+function getIdentifierName(node) {
+	return node?.name || null;
+}
+/**
+* @param {AST.Node} node
+* @param {string} keyword
+* @returns {AST.Identifier}
+*/
+function createFallbackIdentifierNode(node, keyword) {
+	let { start, loc } = node;
+	loc = {
+		start: { ...loc.start },
+		end: {
+			line: loc.start.line,
+			column: loc.start.column + keyword.length
+		}
+	};
+	return _tsrx_core.builders.id(keyword, {
+		start,
+		end: start + keyword.length,
+		loc
+	});
+}
+/**
+* @param {string} name
+* @param {SymbolKindType} kind
+* @param {AST.Node} rangeNode
+* @param {AST.Node} selectionNode
+* @param {TextDocument} document
+* @param {SymbolInfo[]} [children]
+* @returns {SymbolInfo}
+*/
+function createNamedNodeSymbol(name, kind, rangeNode, selectionNode, document, children = []) {
+	const adjustedSelectionNode = adjustNodeEnd(selectionNode);
+	return [{
+		name,
+		kind,
+		range: createRange(rangeNode, document),
+		selectionRange: createRange(adjustedSelectionNode, document),
+		children
+	}, {
+		rangeNode,
+		selectionNode: adjustedSelectionNode
+	}];
+}
+/**
+* @param {AST.Node} node
+* @param {TextDocument} document
+* @returns {Range}
+*/
+function createRange(node, document) {
+	const start = node.start;
+	const end = node.type === "Identifier" && typeof node.name === "string" ? start + node.name.length : 	/** @type {AST.NodeWithLocation} */ node.end;
+	return {
+		start: document.positionAt(start),
+		end: document.positionAt(end)
+	};
+}
+/**
+* @param {AST.Node} node
+* @returns {AST.Node}
+*/
+function adjustNodeEnd(node) {
+	if (node.type === "Identifier" && typeof node.name === "string") return {
+		...node,
+		end: node.start + node.name.length
+	};
+	return node;
+}
+
 //#endregion
 //#region src/typescriptService.js
 /**
@@ -21828,6 +22233,7 @@ function createRippleLanguageServer() {
 				createCompletionPlugin(),
 				createCompileErrorDiagnosticPlugin(),
 				createDefinitionPlugin(),
+				createDocumentSymbolPlugin(),
 				(0, volar_service_css.create)(),
 				...createTypeScriptServices(ts),
 				createTypeScriptDiagnosticFilterPlugin(),
@@ -21888,4 +22294,4 @@ Object.defineProperty(exports, 'createRippleLanguageServer', {
     return createRippleLanguageServer;
   }
 });
-//# sourceMappingURL=server-BNcMp4pJ.js.map
+//# sourceMappingURL=server-CPmlKSwW.js.map