@herb-tools/language-server 0.8.10 → 0.9.1

package/dist/index.cjs

@@ -4,13 +4,15 @@ var node = require('vscode-languageserver/node');
 var config = require('@herb-tools/config');
 var formatter = require('@herb-tools/formatter');
 var vscodeLanguageserverTextdocument = require('vscode-languageserver-textdocument');
-var core = require('@herb-tools/core');
 var nodeWasm = require('@herb-tools/node-wasm');
 var linter = require('@herb-tools/linter');
 var loader = require('@herb-tools/linter/loader');
 var loader$1 = require('@herb-tools/rewriter/loader');
+var core = require('@herb-tools/core');
+var printer = require('@herb-tools/printer');
+var rewriter = require('@herb-tools/rewriter');
 
-var version = "0.8.10";
+var version = "0.9.1";
 
 class Settings {
     constructor(params, connection) {
@@ -154,21 +156,14 @@ class Diagnostics {
         else {
             const parseResult = this.parserService.parseDocument(textDocument);
             const lintResult = await this.linterService.lintDocument(textDocument);
-            const unreachableCodeDiagnostics = this.getUnreachableCodeDiagnostics(parseResult.document);
             allDiagnostics = [
                 ...parseResult.diagnostics,
                 ...lintResult.diagnostics,
-                ...unreachableCodeDiagnostics,
             ];
         }
         this.diagnostics.set(textDocument, allDiagnostics);
         this.sendDiagnosticsFor(textDocument);
     }
-    getUnreachableCodeDiagnostics(document) {
-        const collector = new UnreachableCodeCollector();
-        collector.visit(document);
-        return collector.diagnostics;
-    }
     async refreshDocument(document) {
         await this.validate(document);
     }
@@ -185,228 +180,69 @@ class Diagnostics {
         this.diagnostics.delete(textDocument);
     }
 }
-class UnreachableCodeCollector extends core.Visitor {
-    constructor() {
-        super(...arguments);
-        this.diagnostics = [];
-        this.processedIfNodes = new Set();
-        this.processedElseNodes = new Set();
-    }
-    visitERBCaseNode(node) {
-        this.checkUnreachableChildren(node.children);
-        this.checkAndMarkElseClause(node.else_clause);
-        this.visitChildNodes(node);
-    }
-    visitERBCaseMatchNode(node) {
-        this.checkUnreachableChildren(node.children);
-        this.checkAndMarkElseClause(node.else_clause);
-        this.visitChildNodes(node);
-    }
-    visitERBIfNode(node) {
-        if (this.processedIfNodes.has(node)) {
-            return;
-        }
-        this.markIfChainAsProcessed(node);
-        this.markElseNodesInIfChain(node);
-        const entireChainEmpty = this.isEntireIfChainEmpty(node);
-        if (entireChainEmpty) {
-            this.checkEmptyStatements(node, node.statements, "if");
-        }
-        else {
-            this.checkIfChainParts(node);
-        }
-        this.visitChildNodes(node);
-    }
-    visitERBElseNode(node) {
-        if (this.processedElseNodes.has(node)) {
-            this.visitChildNodes(node);
-            return;
-        }
-        this.checkEmptyStatements(node, node.statements, "else");
-        this.visitChildNodes(node);
-    }
-    visitERBUnlessNode(node) {
-        const unlessHasContent = this.statementsHaveContent(node.statements);
-        const elseHasContent = node.else_clause && this.statementsHaveContent(node.else_clause.statements);
-        if (node.else_clause) {
-            this.processedElseNodes.add(node.else_clause);
-        }
-        const entireBlockEmpty = !unlessHasContent && !elseHasContent;
-        if (entireBlockEmpty) {
-            this.checkEmptyStatements(node, node.statements, "unless");
-        }
-        else {
-            if (!unlessHasContent) {
-                this.checkEmptyStatementsWithEndLocation(node, node.statements, "unless", node.else_clause);
-            }
-            if (node.else_clause && !elseHasContent) {
-                this.checkEmptyStatements(node.else_clause, node.else_clause.statements, "else");
-            }
-        }
-        this.visitChildNodes(node);
-    }
-    visitERBForNode(node) {
-        this.checkEmptyStatements(node, node.statements, "for");
-        this.visitChildNodes(node);
-    }
-    visitERBWhileNode(node) {
-        this.checkEmptyStatements(node, node.statements, "while");
-        this.visitChildNodes(node);
-    }
-    visitERBUntilNode(node) {
-        this.checkEmptyStatements(node, node.statements, "until");
-        this.visitChildNodes(node);
-    }
-    visitERBWhenNode(node) {
-        if (!node.then_keyword) {
-            this.checkEmptyStatements(node, node.statements, "when");
-        }
-        this.visitChildNodes(node);
-    }
-    visitERBBeginNode(node) {
-        this.checkEmptyStatements(node, node.statements, "begin");
-        this.visitChildNodes(node);
-    }
-    visitERBRescueNode(node) {
-        this.checkEmptyStatements(node, node.statements, "rescue");
-        this.visitChildNodes(node);
-    }
-    visitERBEnsureNode(node) {
-        this.checkEmptyStatements(node, node.statements, "ensure");
-        this.visitChildNodes(node);
-    }
-    visitERBBlockNode(node) {
-        this.checkEmptyStatements(node, node.body, "block");
-        this.visitChildNodes(node);
-    }
-    visitERBInNode(node) {
-        if (!node.then_keyword) {
-            this.checkEmptyStatements(node, node.statements, "in");
-        }
-        this.visitChildNodes(node);
-    }
-    checkUnreachableChildren(children) {
-        for (const child of children) {
-            if (core.isHTMLTextNode(child) && child.content.trim() === "") {
-                continue;
-            }
-            this.addDiagnostic(child.location, "Unreachable code: content between case and when/in is never executed");
-        }
-    }
-    checkEmptyStatements(node, statements, blockType) {
-        this.checkEmptyStatementsWithEndLocation(node, statements, blockType, null);
-    }
-    checkEmptyStatementsWithEndLocation(node, statements, blockType, subsequentNode) {
-        if (this.statementsHaveContent(statements)) {
-            return;
-        }
-        const startLocation = node.location.start;
-        const endLocation = subsequentNode
-            ? subsequentNode.location.start
-            : node.location.end;
-        this.addDiagnostic({ start: startLocation, end: endLocation }, `Empty ${blockType} block: this control flow statement has no content`);
-    }
-    addDiagnostic(location, message) {
-        const diagnostic = {
-            range: {
-                start: {
-                    line: this.toZeroBased(location.start.line),
-                    character: location.start.column
-                },
-                end: {
-                    line: this.toZeroBased(location.end.line),
-                    character: location.end.column
-                }
-            },
-            message,
-            severity: node.DiagnosticSeverity.Hint,
-            tags: [node.DiagnosticTag.Unnecessary],
-            source: "Herb Language Server"
-        };
-        this.diagnostics.push(diagnostic);
-    }
-    statementsHaveContent(statements) {
-        return statements.some(statement => {
-            if (core.isHTMLTextNode(statement)) {
-                return statement.content.trim() !== "";
-            }
-            return true;
-        });
-    }
-    checkAndMarkElseClause(elseClause) {
-        if (!elseClause) {
-            return;
-        }
-        this.processedElseNodes.add(elseClause);
-        if (!this.statementsHaveContent(elseClause.statements)) {
-            this.checkEmptyStatements(elseClause, elseClause.statements, "else");
-        }
-    }
-    markIfChainAsProcessed(node) {
-        this.processedIfNodes.add(node);
-        this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if (current.type === 'AST_ERB_IF_NODE') {
-                this.processedIfNodes.add(current);
-            }
-        });
-    }
-    markElseNodesInIfChain(node) {
-        this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if (current.type === 'AST_ERB_ELSE_NODE') {
-                this.processedElseNodes.add(current);
-            }
-        });
+
+function lspPosition(herbPosition) {
+    return node.Position.create(herbPosition.line - 1, herbPosition.column);
+}
+function lspLine(herbPosition) {
+    return herbPosition.line - 1;
+}
+function lspRangeFromLocation(herbLocation) {
+    return node.Range.create(lspPosition(herbLocation.start), lspPosition(herbLocation.end));
+}
+function erbTagToRange(node$1) {
+    if (!node$1.tag_opening || !node$1.tag_closing)
+        return null;
+    return node.Range.create(lspPosition(node$1.tag_opening.location.start), lspPosition(node$1.tag_closing.location.end));
+}
+function tokenToRange(token) {
+    if (!token)
+        return null;
+    return lspRangeFromLocation(token.location);
+}
+function nodeToRange(node) {
+    return lspRangeFromLocation(node.location);
+}
+function openTagRanges(tag) {
+    const ranges = [];
+    if (tag.tag_opening && tag.tag_name) {
+        ranges.push(node.Range.create(lspPosition(tag.tag_opening.location.start), lspPosition(tag.tag_name.location.end)));
     }
-    traverseSubsequentNodes(startNode, callback) {
-        let current = startNode;
-        while (current) {
-            callback(current);
-            if ('subsequent' in current) {
-                current = current.subsequent;
-            }
-            else {
-                break;
-            }
-        }
+    ranges.push(tokenToRange(tag.tag_closing));
+    return ranges;
+}
+function isPositionInRange(position, range) {
+    if (position.line < range.start.line || position.line > range.end.line) {
+        return false;
     }
-    checkIfChainParts(node) {
-        if (!this.statementsHaveContent(node.statements)) {
-            this.checkEmptyStatementsWithEndLocation(node, node.statements, "if", node.subsequent);
-        }
-        this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if (!('statements' in current) || !Array.isArray(current.statements)) {
-                return;
-            }
-            if (this.statementsHaveContent(current.statements)) {
-                return;
-            }
-            const blockType = current.type === 'AST_ERB_IF_NODE' ? 'elsif' : 'else';
-            const nextSubsequent = 'subsequent' in current ? current.subsequent : null;
-            if (nextSubsequent) {
-                this.checkEmptyStatementsWithEndLocation(current, current.statements, blockType, nextSubsequent);
-            }
-            else {
-                this.checkEmptyStatements(current, current.statements, blockType);
-            }
-        });
+    if (position.line === range.start.line && position.character < range.start.character) {
+        return false;
     }
-    isEntireIfChainEmpty(node) {
-        if (this.statementsHaveContent(node.statements)) {
-            return false;
-        }
-        let hasContent = false;
-        this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if ('statements' in current && Array.isArray(current.statements)) {
-                if (this.statementsHaveContent(current.statements)) {
-                    hasContent = true;
-                }
-            }
-        });
-        return !hasContent;
+    if (position.line === range.end.line && position.character > range.end.character) {
+        return false;
     }
-    toZeroBased(line) {
-        return line - 1;
+    return true;
+}
+function rangeSize(range) {
+    if (range.start.line === range.end.line) {
+        return range.end.character - range.start.character;
     }
+    return (range.end.line - range.start.line) * 10000 + range.end.character;
+}
+/**
+ * Returns a Range that spans the entire document
+ */
+function getFullDocumentRange(document) {
+    const lastLine = document.lineCount - 1;
+    const lastLineText = document.getText({
+        start: node.Position.create(lastLine, 0),
+        end: node.Position.create(lastLine + 1, 0)
+    });
+    const lastLineLength = lastLineText.length;
+    return {
+        start: node.Position.create(0, 0),
+        end: node.Position.create(lastLine, lastLineLength)
+    };
 }
 
 class ErrorVisitor extends nodeWasm.Visitor {
@@ -423,7 +259,7 @@ class ErrorVisitor extends nodeWasm.Visitor {
         const diagnostic = {
             source: this.source,
             severity: node.DiagnosticSeverity.Error,
-            range: this.rangeFromHerbError(error),
+            range: lspRangeFromLocation(error.location),
             message: error.message,
             code: error.type,
             data: {
@@ -433,9 +269,6 @@ class ErrorVisitor extends nodeWasm.Visitor {
         };
         this.diagnostics.push(diagnostic);
     }
-    rangeFromHerbError(error) {
-        return node.Range.create(node.Position.create(error.location.start.line - 1, error.location.start.column), node.Position.create(error.location.end.line - 1, error.location.end.column));
-    }
 }
 class ParserService {
     parseDocument(textDocument) {
@@ -448,6 +281,9 @@ class ParserService {
             diagnostics: errorVisitor.diagnostics
         };
     }
+    parseContent(content, options) {
+        return nodeWasm.Herb.parse(content, options);
+    }
 }
 
 function camelize(value) {
@@ -467,20 +303,16 @@ function lintToDignosticSeverity(severity) {
         case "hint": return node.DiagnosticSeverity.Hint;
     }
 }
-/**
- * Returns a Range that spans the entire document
- */
-function getFullDocumentRange(document) {
-    const lastLine = document.lineCount - 1;
-    const lastLineText = document.getText({
-        start: node.Position.create(lastLine, 0),
-        end: node.Position.create(lastLine + 1, 0)
+function lintToDignosticTags(tags) {
+    if (!tags)
+        return [];
+    return tags.flatMap(tag => {
+        switch (tag) {
+            case "unnecessary": return [node.DiagnosticTag.Unnecessary];
+            case "deprecated": return [node.DiagnosticTag.Deprecated];
+            default: return [];
+        }
     });
-    const lastLineLength = lastLineText.length;
-    return {
-        start: node.Position.create(0, 0),
-        end: node.Position.create(lastLine, lastLineLength)
-    };
 }
 
 const OPEN_CONFIG_ACTION$1 = 'Open .herb.yml';
@@ -563,8 +395,24 @@ class LinterService {
             this.connection.window.showWarningMessage(message);
         }
     }
+    shouldLintFile(uri) {
+        const filePath = uri.replace(/^file:\/\//, '');
+        if (filePath.endsWith('.herb.yml'))
+            return false;
+        const config$1 = this.settings.projectConfig;
+        if (!config$1)
+            return true;
+        const hasConfigFile = config.Config.exists(config$1.projectPath);
+        if (!hasConfigFile)
+            return true;
+        const relativePath = filePath.replace(this.project.projectPath + '/', '');
+        return config$1.isLinterEnabledForPath(relativePath);
+    }
     async lintDocument(textDocument) {
         var _a, _b, _c, _d;
+        if (!this.shouldLintFile(textDocument.uri)) {
+            return { diagnostics: [] };
+        }
         const settings = await this.settings.getDocumentSettings(textDocument.uri);
         const linterEnabled = (_b = (_a = settings === null || settings === void 0 ? void 0 : settings.linter) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : true;
         if (!linterEnabled) {
@@ -590,14 +438,14 @@ class LinterService {
         const content = textDocument.getText();
         const lintResult = this.linter.lint(content, { fileName: textDocument.uri });
         const diagnostics = lintResult.offenses.map(offense => {
-            const range = node.Range.create(node.Position.create(offense.location.start.line - 1, offense.location.start.column), node.Position.create(offense.location.end.line - 1, offense.location.end.column));
+            const range = lspRangeFromLocation(offense.location);
             const customRulePath = this.customRulePaths.get(offense.rule);
             const codeDescription = {
                 href: customRulePath
                     ? `file://${customRulePath}`
-                    : `https://herb-tools.dev/linter/rules/${offense.rule}`
+                    : linter.ruleDocumentationUrl(offense.rule)
             };
-            return {
+            const diagnostic = {
                 source: this.source,
                 severity: lintToDignosticSeverity(offense.severity),
                 range,
@@ -606,6 +454,11 @@ class LinterService {
                 data: { rule: offense.rule },
                 codeDescription
             };
+            const tags = lintToDignosticTags(offense.tags);
+            if (tags.length > 0) {
+                diagnostic.tags = tags;
+            }
+            return diagnostic;
         });
         return { diagnostics };
     }
@@ -770,7 +623,7 @@ class FormattingService {
             this.postRewriters = [];
         }
     }
-    async formatOnSave(document, reason) {
+    async formatOnSave(document, reason, textOverride) {
         this.connection.console.log(`[Formatting] formatOnSave called for ${document.uri}`);
         if (reason !== node.TextDocumentSaveReason.Manual) {
             this.connection.console.log(`[Formatting] Skipping: reason=${reason} (not manual)`);
@@ -781,7 +634,7 @@ class FormattingService {
             this.connection.console.log(`[Formatting] Skipping: file not in formatter config`);
             return [];
         }
-        return this.performFormatting({ textDocument: { uri: document.uri }, options: { tabSize: 2, insertSpaces: true } });
+        return this.performFormatting({ textDocument: { uri: document.uri }, options: { tabSize: 2, insertSpaces: true } }, textOverride);
     }
     shouldFormatFile(filePath) {
         if (filePath.endsWith('.herb.yml'))
@@ -809,13 +662,13 @@ class FormattingService {
             }
         };
     }
-    async performFormatting(params) {
+    async performFormatting(params, textOverride) {
         const document = this.documents.get(params.textDocument.uri);
         if (!document) {
             return [];
         }
         try {
-            const text = document.getText();
+            const text = textOverride !== null && textOverride !== void 0 ? textOverride : document.getText();
             const config = await this.getConfigWithSettings(params.textDocument.uri);
             this.connection.console.log(`[Formatting] Creating formatter with ${this.preRewriters.length} pre-rewriters, ${this.postRewriters.length} post-rewriters`);
             if (this.failedRewriters.size > 0) {
@@ -1287,10 +1140,7 @@ class CodeActionService {
         };
     }
     offenseToRange(offense) {
-        return {
-            start: node.Position.create(offense.location.start.line - 1, offense.location.start.column),
-            end: node.Position.create(offense.location.end.line - 1, offense.location.end.column)
-        };
+        return lspRangeFromLocation(offense.location);
     }
     rangesEqual(r1, r2) {
         return (r1.start.line === r2.start.line &&
@@ -1309,6 +1159,14 @@ class CodeActionService {
 
 class DocumentSaveService {
     constructor(connection, settings, autofixService, formattingService) {
+        /**
+         * Tracks documents that were recently autofixed via applyFixesAndFormatting
+         * (triggered by onDocumentFormatting). When editor.formatOnSave is enabled,
+         * onDocumentFormatting fires BEFORE willSaveWaitUntil. If applyFixesAndFormatting
+         * already applied autofix, applyFixes must skip to avoid conflicting edits
+         * (since this.documents hasn't been updated between the two events).
+         */
+        this.recentlyAutofixedViaFormatting = new Set();
         this.connection = connection;
         this.settings = settings;
         this.autofixService = autofixService;
@@ -1325,6 +1183,10 @@ class DocumentSaveService {
         this.connection.console.log(`[DocumentSave] applyFixes fixOnSave=${fixOnSave}`);
         if (!fixOnSave)
             return [];
+        if (this.recentlyAutofixedViaFormatting.delete(document.uri)) {
+            this.connection.console.log(`[DocumentSave] applyFixes skipping: already autofixed via formatting`);
+            return [];
+        }
         return this.autofixService.autofix(document);
     }
     /**
@@ -1340,97 +1202,1150 @@ class DocumentSaveService {
         let autofixEdits = [];
         if (fixOnSave) {
             autofixEdits = await this.autofixService.autofix(document);
+            if (autofixEdits.length > 0) {
+                this.recentlyAutofixedViaFormatting.add(document.uri);
+            }
         }
         if (!formatterEnabled)
             return autofixEdits;
         if (autofixEdits.length === 0) {
             return this.formattingService.formatOnSave(document, reason);
         }
-        const autofixedDocument = {
-            ...document,
-            uri: document.uri,
-            getText: () => autofixEdits[0].newText,
-        };
-        return this.formattingService.formatOnSave(autofixedDocument, reason);
+        return this.formattingService.formatOnSave(document, reason, autofixEdits[0].newText);
     }
 }
 
-class Service {
-    constructor(connection, params) {
-        this.connection = connection;
-        this.settings = new Settings(params, this.connection);
-        this.documentService = new DocumentService(this.connection);
-        this.project = new Project(connection, this.settings.projectPath.replace("file://", ""));
-        this.parserService = new ParserService();
-        this.linterService = new LinterService(this.connection, this.settings, this.project);
-        this.formattingService = new FormattingService(this.connection, this.documentService.documents, this.project, this.settings);
-        this.autofixService = new AutofixService(this.connection, this.config);
-        this.configService = new ConfigService(this.project.projectPath);
-        this.codeActionService = new CodeActionService(this.project, this.config);
-        this.diagnostics = new Diagnostics(this.connection, this.documentService, this.parserService, this.linterService, this.configService);
-        this.documentSaveService = new DocumentSaveService(this.connection, this.settings, this.autofixService, this.formattingService);
-        if (params.initializationOptions) {
-            this.settings.globalSettings = params.initializationOptions;
-        }
+class FoldingRangeService {
+    constructor(parserService) {
+        this.parserService = parserService;
     }
-    async init() {
-        await this.project.initialize();
-        await this.formattingService.initialize();
-        try {
-            this.config = await config.Config.loadForEditor(this.project.projectPath, version);
-            this.codeActionService.setConfig(this.config);
-            this.autofixService.setConfig(this.config);
-            if (this.config.version && this.config.version !== version) {
-                this.connection.console.warn(`Config file version (${this.config.version}) does not match current version (${version}). ` +
-                    `Consider updating your .herb.yml file.`);
-            }
-        }
-        catch (error) {
-            this.connection.console.warn(`Failed to load config: ${error instanceof Error ? error.message : String(error)}. Using personal settings with defaults.`);
-            this.config = config.Config.fromObject({
-                linter: this.settings.globalSettings.linter,
-                formatter: this.settings.globalSettings.formatter
-            }, { projectPath: this.project.projectPath, version });
-            this.codeActionService.setConfig(this.config);
-            this.autofixService.setConfig(this.config);
+    getFoldingRanges(textDocument) {
+        const parseResult = this.parserService.parseDocument(textDocument);
+        const collector = new FoldingRangeCollector();
+        collector.visit(parseResult.document);
+        return collector.ranges;
+    }
+}
+class FoldingRangeCollector extends core.Visitor {
+    constructor() {
+        super(...arguments);
+        this.ranges = [];
+        this.processedIfNodes = new Set();
+    }
+    visitHTMLElementNode(node) {
+        if (node.body.length > 0 && node.open_tag && node.close_tag) {
+            this.addRange(node.open_tag.location.end, node.close_tag.location.start);
         }
-        await this.settings.initializeProjectConfig(this.config);
-        await this.formattingService.refreshConfig(this.config);
-        this.linterService.rebuildLinter();
-        this.documentService.onDidClose((change) => {
-            this.settings.documentSettings.delete(change.document.uri);
-        });
-        this.documentService.onDidChangeContent(async (change) => {
-            await this.diagnostics.refreshDocument(change.document);
-        });
+        this.visitChildNodes(node);
     }
-    async refresh() {
-        await this.project.refresh();
-        await this.formattingService.refreshConfig(this.config);
-        await this.diagnostics.refreshAllDocuments();
+    visitHTMLOpenTagNode(node) {
+        if (node.children.length > 0 && node.tag_opening && node.tag_closing) {
+            this.addRange(node.tag_opening.location.end, node.tag_closing.location.start);
+        }
+        this.visitChildNodes(node);
     }
-    async refreshConfig() {
-        try {
-            this.config = await config.Config.loadForEditor(this.project.projectPath, version);
-            this.codeActionService.setConfig(this.config);
-            this.autofixService.setConfig(this.config);
-            if (this.config.version && this.config.version !== version) {
-                this.connection.console.warn(`Config file version (${this.config.version}) does not match current version (${version}). ` +
-                    `Consider updating your .herb.yml file.`);
-            }
+    visitHTMLCommentNode(node$1) {
+        if (node$1.comment_start && node$1.comment_end) {
+            this.addRange(node$1.comment_start.location.end, node$1.comment_end.location.start, node.FoldingRangeKind.Comment);
         }
-        catch (error) {
-            this.connection.console.warn(`Failed to load config: ${error instanceof Error ? error.message : String(error)}. Using personal settings with defaults.`);
-            this.config = config.Config.fromObject({
-                linter: this.settings.globalSettings.linter,
-                formatter: this.settings.globalSettings.formatter
-            }, { projectPath: this.project.projectPath, version });
-            this.codeActionService.setConfig(this.config);
-            this.autofixService.setConfig(this.config);
+        this.visitChildNodes(node$1);
+    }
+    visitHTMLAttributeValueNode(node) {
+        if (node.children.length > 0) {
+            const first = node.children[0];
+            const last = node.children[node.children.length - 1];
+            this.addRange(first.location.start, last.location.end);
+        }
+        this.visitChildNodes(node);
+    }
+    visitCDATANode(node) {
+        this.addRange(node.location.start, node.location.end);
+        this.visitChildNodes(node);
+    }
+    visitHTMLConditionalElementNode(node) {
+        this.addRange(node.location.start, node.location.end);
+        this.visitChildNodes(node);
+    }
+    visitERBNode(node) {
+        var _a;
+        if (node.tag_closing && 'end_node' in node && ((_a = node.end_node) === null || _a === void 0 ? void 0 : _a.tag_opening)) {
+            this.addRange(node.tag_closing.location.end, node.end_node.tag_opening.location.start);
+        }
+        else {
+            this.addRange(node.location.start, node.location.end);
+        }
+    }
+    visitERBContentNode(node) {
+        if (node.tag_opening && node.tag_closing) {
+            this.addRange(node.tag_opening.location.end, node.tag_closing.location.start);
+        }
+        this.visitChildNodes(node);
+    }
+    visitERBIfNode(node) {
+        var _a, _b;
+        if (this.processedIfNodes.has(node)) {
+            this.visitChildNodes(node);
+            return;
+        }
+        this.markIfChainAsProcessed(node);
+        const nextAfterIf = (_a = node.subsequent) !== null && _a !== void 0 ? _a : node.end_node;
+        if (node.tag_closing && (nextAfterIf === null || nextAfterIf === void 0 ? void 0 : nextAfterIf.tag_opening)) {
+            this.addRange(node.tag_closing.location.end, nextAfterIf.tag_opening.location.start);
+        }
+        let current = node.subsequent;
+        while (current) {
+            if (core.isERBIfNode(current)) {
+                const nextAfterElsif = (_b = current.subsequent) !== null && _b !== void 0 ? _b : node.end_node;
+                if (current.tag_closing && (nextAfterElsif === null || nextAfterElsif === void 0 ? void 0 : nextAfterElsif.tag_opening)) {
+                    this.addRange(current.tag_closing.location.end, nextAfterElsif.tag_opening.location.start);
+                }
+                current = current.subsequent;
+            }
+            else {
+                break;
+            }
+        }
+        this.visitChildNodes(node);
+    }
+    visitERBUnlessNode(node) {
+        var _a, _b;
+        const nextAfterUnless = (_a = node.else_clause) !== null && _a !== void 0 ? _a : node.end_node;
+        if (node.tag_closing && (nextAfterUnless === null || nextAfterUnless === void 0 ? void 0 : nextAfterUnless.tag_opening)) {
+            this.addRange(node.tag_closing.location.end, nextAfterUnless.tag_opening.location.start);
+        }
+        if (node.else_clause) {
+            if (node.else_clause.tag_closing && ((_b = node.end_node) === null || _b === void 0 ? void 0 : _b.tag_opening)) {
+                this.addRange(node.else_clause.tag_closing.location.end, node.end_node.tag_opening.location.start);
+            }
+        }
+        this.visitChildNodes(node);
+    }
+    visitERBCaseNode(node) {
+        this.addCaseFoldingRanges(node);
+        this.visitChildNodes(node);
+    }
+    visitERBCaseMatchNode(node) {
+        this.addCaseFoldingRanges(node);
+        this.visitChildNodes(node);
+    }
+    visitERBWhenNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitERBInNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitERBBeginNode(node) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const nextAfterBegin = (_c = (_b = (_a = node.rescue_clause) !== null && _a !== void 0 ? _a : node.else_clause) !== null && _b !== void 0 ? _b : node.ensure_clause) !== null && _c !== void 0 ? _c : node.end_node;
+        if (node.tag_closing && (nextAfterBegin === null || nextAfterBegin === void 0 ? void 0 : nextAfterBegin.tag_opening)) {
+            this.addRange(node.tag_closing.location.end, nextAfterBegin.tag_opening.location.start);
+        }
+        let rescue = node.rescue_clause;
+        while (rescue) {
+            const nextAfterRescue = (_f = (_e = (_d = rescue.subsequent) !== null && _d !== void 0 ? _d : node.else_clause) !== null && _e !== void 0 ? _e : node.ensure_clause) !== null && _f !== void 0 ? _f : node.end_node;
+            if (rescue.tag_closing && (nextAfterRescue === null || nextAfterRescue === void 0 ? void 0 : nextAfterRescue.tag_opening)) {
+                this.addRange(rescue.tag_closing.location.end, nextAfterRescue.tag_opening.location.start);
+            }
+            rescue = rescue.subsequent;
+        }
+        if (node.else_clause) {
+            const nextAfterElse = (_g = node.ensure_clause) !== null && _g !== void 0 ? _g : node.end_node;
+            if (node.else_clause.tag_closing && (nextAfterElse === null || nextAfterElse === void 0 ? void 0 : nextAfterElse.tag_opening)) {
+                this.addRange(node.else_clause.tag_closing.location.end, nextAfterElse.tag_opening.location.start);
+            }
+        }
+        if (node.ensure_clause) {
+            if (node.ensure_clause.tag_closing && ((_h = node.end_node) === null || _h === void 0 ? void 0 : _h.tag_opening)) {
+                this.addRange(node.ensure_clause.tag_closing.location.end, node.end_node.tag_opening.location.start);
+            }
+        }
+        this.visitChildNodes(node);
+    }
+    visitERBRescueNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitERBElseNode(node) {
+        this.addRange(node.location.start, node.location.end);
+        this.visitChildNodes(node);
+    }
+    visitERBEnsureNode(node) {
+        this.visitChildNodes(node);
+    }
+    markIfChainAsProcessed(node) {
+        this.processedIfNodes.add(node);
+        let current = node.subsequent;
+        while (current) {
+            if (core.isERBIfNode(current)) {
+                this.processedIfNodes.add(current);
+                current = current.subsequent;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    addCaseFoldingRanges(node) {
+        var _a, _b, _c, _d;
+        const conditions = node.conditions;
+        const firstCondition = conditions[0];
+        const nextAfterCase = (_a = firstCondition !== null && firstCondition !== void 0 ? firstCondition : node.else_clause) !== null && _a !== void 0 ? _a : node.end_node;
+        if (node.tag_closing && (nextAfterCase === null || nextAfterCase === void 0 ? void 0 : nextAfterCase.tag_opening)) {
+            this.addRange(node.tag_closing.location.end, nextAfterCase.tag_opening.location.start);
+        }
+        for (let i = 0; i < conditions.length; i++) {
+            const condition = conditions[i];
+            const nextCondition = (_c = (_b = conditions[i + 1]) !== null && _b !== void 0 ? _b : node.else_clause) !== null && _c !== void 0 ? _c : node.end_node;
+            if (condition.tag_closing && (nextCondition === null || nextCondition === void 0 ? void 0 : nextCondition.tag_opening)) {
+                this.addRange(condition.tag_closing.location.end, nextCondition.tag_opening.location.start);
+            }
+        }
+        if (node.else_clause) {
+            if (node.else_clause.tag_closing && ((_d = node.end_node) === null || _d === void 0 ? void 0 : _d.tag_opening)) {
+                this.addRange(node.else_clause.tag_closing.location.end, node.end_node.tag_opening.location.start);
+            }
+        }
+    }
+    addRange(start, end, kind) {
+        const startLine = lspLine(start);
+        const endLine = lspLine(end) - 1;
+        if (endLine > startLine) {
+            this.ranges.push({
+                startLine,
+                startCharacter: start.column,
+                endLine,
+                endCharacter: end.column,
+                kind,
+            });
         }
-        await this.settings.refreshProjectConfig(this.config);
-        await this.formattingService.refreshConfig(this.config);
-        this.linterService.rebuildLinter();
+    }
+}
+
+class DocumentHighlightCollector extends core.Visitor {
+    constructor() {
+        super(...arguments);
+        this.groups = [];
+        this.processedIfNodes = new Set();
+    }
+    visitERBNode(node) {
+        if ('end_node' in node && node.end_node) {
+            this.addGroup([erbTagToRange(node), erbTagToRange(node.end_node)]);
+        }
+    }
+    visitERBContentNode(node) {
+        this.addGroup([tokenToRange(node.tag_opening), tokenToRange(node.tag_closing)]);
+        this.visitChildNodes(node);
+    }
+    visitHTMLCommentNode(node) {
+        this.addGroup([tokenToRange(node.comment_start), tokenToRange(node.comment_end)]);
+        this.visitChildNodes(node);
+    }
+    visitHTMLElementNode(node) {
+        const ranges = [];
+        if (node.open_tag && core.isHTMLOpenTagNode(node.open_tag)) {
+            ranges.push(...openTagRanges(node.open_tag));
+        }
+        else if (node.open_tag) {
+            ranges.push(nodeToRange(node.open_tag));
+        }
+        if (node.close_tag) {
+            ranges.push(nodeToRange(node.close_tag));
+        }
+        this.addGroup(ranges);
+        this.visitChildNodes(node);
+    }
+    visitHTMLAttributeNode(node) {
+        const ranges = [];
+        if (node.name) {
+            ranges.push(nodeToRange(node.name));
+        }
+        if (node.equals) {
+            ranges.push(tokenToRange(node.equals));
+        }
+        if (node.value) {
+            ranges.push(nodeToRange(node.value));
+        }
+        this.addGroup(ranges);
+        this.visitChildNodes(node);
+    }
+    visitHTMLConditionalElementNode(node) {
+        const ranges = [];
+        if (node.open_conditional) {
+            ranges.push(erbTagToRange(node.open_conditional));
+        }
+        if (node.open_tag) {
+            ranges.push(...openTagRanges(node.open_tag));
+        }
+        if (node.close_tag) {
+            ranges.push(nodeToRange(node.close_tag));
+        }
+        if (node.close_conditional) {
+            ranges.push(erbTagToRange(node.close_conditional));
+        }
+        this.addGroup(ranges);
+        this.visitChildNodes(node);
+    }
+    visitERBIfNode(node) {
+        if (this.processedIfNodes.has(node)) {
+            this.visitChildNodes(node);
+            return;
+        }
+        this.markIfChainAsProcessed(node);
+        const ranges = [];
+        ranges.push(erbTagToRange(node));
+        let current = node.subsequent;
+        while (current) {
+            if (core.isERBIfNode(current)) {
+                ranges.push(erbTagToRange(current));
+                current = current.subsequent;
+            }
+            else if (core.isERBElseNode(current)) {
+                ranges.push(erbTagToRange(current));
+                break;
+            }
+            else {
+                break;
+            }
+        }
+        if (node.end_node) {
+            ranges.push(erbTagToRange(node.end_node));
+        }
+        this.addGroup(ranges);
+        this.visitChildNodes(node);
+    }
+    visitERBUnlessNode(node) {
+        const ranges = [];
+        ranges.push(erbTagToRange(node));
+        if (node.else_clause) {
+            ranges.push(erbTagToRange(node.else_clause));
+        }
+        if (node.end_node) {
+            ranges.push(erbTagToRange(node.end_node));
+        }
+        this.addGroup(ranges);
+        this.visitChildNodes(node);
+    }
+    visitERBCaseNode(node) {
+        this.visitERBAnyCaseNode(node);
+    }
+    visitERBCaseMatchNode(node) {
+        this.visitERBAnyCaseNode(node);
+    }
+    visitERBAnyCaseNode(node) {
+        const ranges = [];
+        ranges.push(erbTagToRange(node));
+        for (const condition of node.conditions) {
+            ranges.push(erbTagToRange(condition));
+        }
+        if (node.else_clause) {
+            ranges.push(erbTagToRange(node.else_clause));
+        }
+        if (node.end_node) {
+            ranges.push(erbTagToRange(node.end_node));
+        }
+        this.addGroup(ranges);
+        this.visitChildNodes(node);
+    }
+    visitERBBeginNode(node) {
+        const ranges = [];
+        ranges.push(erbTagToRange(node));
+        let rescue = node.rescue_clause;
+        while (rescue) {
+            ranges.push(erbTagToRange(rescue));
+            rescue = rescue.subsequent;
+        }
+        if (node.else_clause) {
+            ranges.push(erbTagToRange(node.else_clause));
+        }
+        if (node.ensure_clause) {
+            ranges.push(erbTagToRange(node.ensure_clause));
+        }
+        if (node.end_node) {
+            ranges.push(erbTagToRange(node.end_node));
+        }
+        this.addGroup(ranges);
+        this.visitChildNodes(node);
+    }
+    markIfChainAsProcessed(node) {
+        this.processedIfNodes.add(node);
+        let current = node.subsequent;
+        while (current) {
+            if (core.isERBIfNode(current)) {
+                this.processedIfNodes.add(current);
+                current = current.subsequent;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    addGroup(ranges) {
+        const filtered = ranges.filter((r) => r !== null);
+        if (filtered.length >= 2) {
+            this.groups.push(filtered);
+        }
+    }
+}
+class DocumentHighlightService {
+    constructor(parserService) {
+        this.parserService = parserService;
+    }
+    getDocumentHighlights(textDocument, position) {
+        const parseResult = this.parserService.parseDocument(textDocument);
+        const collector = new DocumentHighlightCollector();
+        collector.visit(parseResult.document);
+        let bestGroup = null;
+        let bestSize = Infinity;
+        for (const group of collector.groups) {
+            const matchingRange = group.find(range => isPositionInRange(position, range));
+            if (matchingRange) {
+                const size = rangeSize(matchingRange);
+                if (size < bestSize) {
+                    bestSize = size;
+                    bestGroup = group;
+                }
+            }
+        }
+        if (bestGroup) {
+            return bestGroup.map(range => node.DocumentHighlight.create(range, node.DocumentHighlightKind.Text));
+        }
+        return [];
+    }
+}
+
+const ACTION_VIEW_HELPERS = {
+    "ActionView::Helpers::TagHelper#tag": {
+        signature: "tag.<tag name>(optional content, options)",
+        documentationURL: "https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-tag",
+    },
+    "ActionView::Helpers::TagHelper#content_tag": {
+        signature: "content_tag(name, content_or_options_with_block = nil, options = nil, escape = true, &block)",
+        documentationURL: "https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-content_tag",
+    },
+    "ActionView::Helpers::UrlHelper#link_to": {
+        signature: "link_to(name = nil, options = nil, html_options = nil, &block)",
+        documentationURL: "https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to",
+    },
+    "Turbo::FramesHelper#turbo_frame_tag": {
+        signature: "turbo_frame_tag(*ids, src: nil, target: nil, **attributes, &block)",
+        documentationURL: "https://www.rubydoc.info/github/hotwired/turbo-rails/Turbo/FramesHelper:turbo_frame_tag",
+    },
+};
+
+class ActionViewElementCollector extends nodeWasm.Visitor {
+    constructor() {
+        super(...arguments);
+        this.elements = [];
+    }
+    visitHTMLElementNode(node) {
+        if (node.element_source && node.element_source !== "HTML" && core.isERBOpenTagNode(node.open_tag)) {
+            this.elements.push({
+                node,
+                range: nodeToRange(node),
+            });
+        }
+        this.visitChildNodes(node);
+    }
+}
+class HoverService {
+    constructor(parserService) {
+        this.parserService = parserService;
+    }
+    getHover(textDocument, position) {
+        const parseResult = this.parserService.parseContent(textDocument.getText(), {
+            action_view_helpers: true,
+            track_whitespace: true,
+        });
+        const collector = new ActionViewElementCollector();
+        collector.visit(parseResult.value);
+        let bestElement = null;
+        let bestSize = Infinity;
+        for (const element of collector.elements) {
+            if (isPositionInRange(position, element.range)) {
+                const size = rangeSize(element.range);
+                if (size < bestSize) {
+                    bestSize = size;
+                    bestElement = element;
+                }
+            }
+        }
+        if (!bestElement) {
+            return null;
+        }
+        const elementSource = bestElement.node.element_source;
+        const rewriter$1 = new rewriter.ActionViewTagHelperToHTMLRewriter();
+        const rewrittenNode = rewriter$1.rewrite(bestElement.node, { baseDir: process.cwd() });
+        const htmlOutput = printer.IdentityPrinter.print(rewrittenNode);
+        const helper = ACTION_VIEW_HELPERS[elementSource];
+        const parts = [];
+        if (helper) {
+            parts.push(`\`\`\`ruby\n${helper.signature}\n\`\`\``);
+        }
+        parts.push(`**HTML equivalent**\n\`\`\`erb\n${htmlOutput.trim()}\n\`\`\``);
+        if (helper) {
+            parts.push(`[${elementSource}](${helper.documentationURL})`);
+        }
+        return {
+            contents: {
+                kind: node.MarkupKind.Markdown,
+                value: parts.join("\n\n"),
+            },
+            range: bestElement.range,
+        };
+    }
+}
+
+class ElementCollector extends nodeWasm.Visitor {
+    constructor() {
+        super(...arguments);
+        this.actionViewElements = [];
+        this.htmlElements = [];
+    }
+    visitHTMLElementNode(node) {
+        if (node.element_source && node.element_source !== "HTML" && core.isERBOpenTagNode(node.open_tag)) {
+            this.actionViewElements.push({
+                node,
+                range: nodeToRange(node),
+            });
+        }
+        else if (core.isHTMLOpenTagNode(node.open_tag) && node.open_tag.tag_name) {
+            this.htmlElements.push({
+                node,
+                range: nodeToRange(node),
+            });
+        }
+        this.visitChildNodes(node);
+    }
+}
+class RewriteCodeActionService {
+    constructor(parserService) {
+        this.parserService = parserService;
+    }
+    getCodeActions(document, requestedRange) {
+        const parseResult = this.parserService.parseContent(document.getText(), {
+            action_view_helpers: true,
+            track_whitespace: true,
+        });
+        const collector = new ElementCollector();
+        collector.visit(parseResult.value);
+        const actions = [];
+        for (const element of collector.actionViewElements) {
+            if (!this.rangesOverlap(element.range, requestedRange))
+                continue;
+            const action = this.createActionViewToHTMLAction(document, element);
+            if (action) {
+                actions.push(action);
+            }
+        }
+        for (const element of collector.htmlElements) {
+            if (!this.rangesOverlap(element.range, requestedRange))
+                continue;
+            const action = this.createHTMLToActionViewAction(document, element);
+            if (action) {
+                actions.push(action);
+            }
+        }
+        return actions;
+    }
+    createActionViewToHTMLAction(document, element) {
+        var _a;
+        const originalText = document.getText(element.range);
+        const parseResult = this.parserService.parseContent(originalText, {
+            action_view_helpers: true,
+            track_whitespace: true,
+        });
+        if (parseResult.failed)
+            return null;
+        const rewriter$1 = new rewriter.ActionViewTagHelperToHTMLRewriter();
+        rewriter$1.rewrite(parseResult.value, { baseDir: process.cwd() });
+        const rewrittenText = printer.IdentityPrinter.print(parseResult.value);
+        if (rewrittenText === originalText)
+            return null;
+        const edit = {
+            changes: {
+                [document.uri]: [node.TextEdit.replace(element.range, rewrittenText)]
+            }
+        };
+        const tagName = (_a = element.node.tag_name) === null || _a === void 0 ? void 0 : _a.value;
+        const title = tagName
+            ? `Herb: Convert to \`<${tagName}>\``
+            : "Herb: Convert to HTML";
+        return {
+            title,
+            kind: node.CodeActionKind.RefactorRewrite,
+            edit,
+        };
+    }
+    createHTMLToActionViewAction(document, element) {
+        var _a;
+        const originalText = document.getText(element.range);
+        const parseResult = this.parserService.parseContent(originalText, {
+            track_whitespace: true,
+        });
+        if (parseResult.failed)
+            return null;
+        const rewriter$1 = new rewriter.HTMLToActionViewTagHelperRewriter();
+        rewriter$1.rewrite(parseResult.value, { baseDir: process.cwd() });
+        const rewrittenText = printer.IdentityPrinter.print(parseResult.value);
+        if (rewrittenText === originalText)
+            return null;
+        const edit = {
+            changes: {
+                [document.uri]: [node.TextEdit.replace(element.range, rewrittenText)]
+            }
+        };
+        const tagName = (_a = element.node.tag_name) === null || _a === void 0 ? void 0 : _a.value;
+        const isAnchor = tagName === "a";
+        const isTurboFrame = tagName === "turbo-frame";
+        const methodName = tagName === null || tagName === void 0 ? void 0 : tagName.replace(/-/g, "_");
+        const title = isAnchor
+            ? "Herb: Convert to `link_to`"
+            : isTurboFrame
+                ? "Herb: Convert to `turbo_frame_tag`"
+                : methodName
+                    ? `Herb: Convert to \`tag.${methodName}\``
+                    : "Herb: Convert to tag helper";
+        return {
+            title,
+            kind: node.CodeActionKind.RefactorRewrite,
+            edit,
+        };
+    }
+    rangesOverlap(r1, r2) {
+        if (r1.end.line < r2.start.line)
+            return false;
+        if (r1.start.line > r2.end.line)
+            return false;
+        if (r1.end.line === r2.start.line && r1.end.character < r2.start.character)
+            return false;
+        if (r1.start.line === r2.end.line && r1.start.character > r2.end.character)
+            return false;
+        return true;
+    }
+}
+
+class LineContextCollector extends core.Visitor {
+    constructor() {
+        super(...arguments);
+        this.lineMap = new Map();
+        this.erbNodesPerLine = new Map();
+        this.htmlCommentNodesPerLine = new Map();
+    }
+    visitERBNode(node) {
+        if (!node.tag_opening || !node.tag_closing)
+            return;
+        const startLine = lspLine(node.tag_opening.location.start);
+        const nodes = this.erbNodesPerLine.get(startLine) || [];
+        nodes.push(node);
+        this.erbNodesPerLine.set(startLine, nodes);
+        if (core.isERBCommentNode(node)) {
+            this.setLine(startLine, "erb-comment", node);
+        }
+        else {
+            this.setLine(startLine, "erb-tag", node);
+        }
+    }
+    visitERBContentNode(node) {
+        this.visitERBNode(node);
+        this.visitChildNodes(node);
+    }
+    visitHTMLCommentNode(node) {
+        const startLine = lspLine(node.location.start);
+        const endLine = lspLine(node.location.end);
+        for (let line = startLine; line <= endLine; line++) {
+            this.htmlCommentNodesPerLine.set(line, node);
+            this.setLine(line, "html-comment", node);
+        }
+        this.visitChildNodes(node);
+    }
+    visitHTMLElementNode(node) {
+        const startLine = lspLine(node.location.start);
+        const endLine = lspLine(node.location.end);
+        for (let line = startLine; line <= endLine; line++) {
+            if (!this.lineMap.has(line)) {
+                this.setLine(line, "html-content", node);
+            }
+        }
+        this.visitChildNodes(node);
+    }
+    visitHTMLTextNode(node) {
+        const startLine = lspLine(node.location.start);
+        const endLine = lspLine(node.location.end);
+        for (let line = startLine; line <= endLine; line++) {
+            if (!this.lineMap.has(line)) {
+                this.setLine(line, "html-content", node);
+            }
+        }
+        this.visitChildNodes(node);
+    }
+    setLine(line, context, node) {
+        const existing = this.lineMap.get(line);
+        if (existing) {
+            if (existing.context === "erb-comment" || existing.context === "erb-tag")
+                return;
+            if (context === "erb-comment" || context === "erb-tag") {
+                this.lineMap.set(line, { line, context, node });
+                return;
+            }
+            if (existing.context === "html-comment")
+                return;
+        }
+        this.lineMap.set(line, { line, context, node });
+    }
+}
+
+function commentERBNode(node) {
+    const mutable = rewriter.asMutable(node);
+    if (mutable.tag_opening) {
+        const currentValue = mutable.tag_opening.value;
+        mutable.tag_opening = core.createSyntheticToken(currentValue.substring(0, 2) + "#" + currentValue.substring(2), mutable.tag_opening.type);
+    }
+}
+function uncommentERBNode(node) {
+    var _a;
+    const mutable = rewriter.asMutable(node);
+    if (mutable.tag_opening && mutable.tag_opening.value === "<%#") {
+        const contentValue = ((_a = mutable.content) === null || _a === void 0 ? void 0 : _a.value) || "";
+        if (contentValue.startsWith(" graphql ") ||
+            contentValue.startsWith(" %= ") ||
+            contentValue.startsWith(" == ") ||
+            contentValue.startsWith(" % ") ||
+            contentValue.startsWith(" = ") ||
+            contentValue.startsWith(" - ")) {
+            mutable.tag_opening = core.createSyntheticToken("<%", mutable.tag_opening.type);
+            mutable.content = core.createSyntheticToken(contentValue.substring(1), mutable.content.type);
+        }
+        else {
+            mutable.tag_opening = core.createSyntheticToken("<%", mutable.tag_opening.type);
+        }
+    }
+}
+function determineStrategy(erbNodes, lineText) {
+    if (erbNodes.length === 0) {
+        return "html-only";
+    }
+    if (erbNodes.length === 1) {
+        const node = erbNodes[0];
+        if (!node.tag_opening || !node.tag_closing)
+            return "html-only";
+        const nodeStart = node.tag_opening.location.start.column;
+        const nodeEnd = node.tag_closing.location.end.column;
+        const isSoleContent = lineText.substring(0, nodeStart).trim() === "" && lineText.substring(nodeEnd).trim() === "";
+        if (isSoleContent) {
+            return "single-erb";
+        }
+        return "whole-line";
+    }
+    const segments = getLineSegments(lineText, erbNodes);
+    const hasHTML = segments.some(segment => !segment.isERB && segment.text.trim() !== "");
+    if (!hasHTML) {
+        return "all-erb";
+    }
+    const allControlTags = erbNodes.every(node => { var _a; return ((_a = node.tag_opening) === null || _a === void 0 ? void 0 : _a.value) === "<%"; });
+    if (allControlTags) {
+        return "per-segment";
+    }
+    return "whole-line";
+}
+function getLineSegments(lineText, erbNodes) {
+    const segments = [];
+    const sorted = [...erbNodes].sort((a, b) => a.tag_opening.location.start.column - b.tag_opening.location.start.column);
+    let position = 0;
+    for (const node of sorted) {
+        const nodeStart = node.tag_opening.location.start.column;
+        const nodeEnd = node.tag_closing.location.end.column;
+        if (nodeStart > position) {
+            segments.push({ text: lineText.substring(position, nodeStart), isERB: false });
+        }
+        segments.push({ text: lineText.substring(nodeStart, nodeEnd), isERB: true, node });
+        position = nodeEnd;
+    }
+    if (position < lineText.length) {
+        segments.push({ text: lineText.substring(position), isERB: false });
+    }
+    return segments;
+}
+/**
+ * Comment a line using AST mutation for strategies where the parser produces flat children,
+ * and text-segment manipulation for per-segment (where the parser nests nodes).
+ */
+function commentLineContent(content, erbNodes, strategy, parserService) {
+    if (strategy === "per-segment") {
+        return commentPerSegment(content, erbNodes);
+    }
+    const parseResult = parserService.parseContent(content, { track_whitespace: true });
+    const lineCollector = new LineContextCollector();
+    parseResult.visit(lineCollector);
+    const lineERBNodes = lineCollector.erbNodesPerLine.get(0) || [];
+    const document = parseResult.value;
+    const children = rewriter.asMutable(document).children;
+    switch (strategy) {
+        case "all-erb":
+            for (const node of lineERBNodes) {
+                commentERBNode(node);
+            }
+            break;
+        case "whole-line": {
+            for (const node of lineERBNodes) {
+                commentERBNode(node);
+            }
+            const commentNode = new core.HTMLCommentNode({
+                type: "AST_HTML_COMMENT_NODE",
+                location: core.Location.zero,
+                errors: [],
+                comment_start: core.createSyntheticToken("<!--", "TOKEN_HTML_COMMENT_START"),
+                children: [core.createLiteral(" "), ...children.slice(), core.createLiteral(" ")],
+                comment_end: core.createSyntheticToken("-->", "TOKEN_HTML_COMMENT_END"),
+            });
+            children.length = 0;
+            children.push(commentNode);
+            break;
+        }
+        case "html-only": {
+            const commentNode = new core.HTMLCommentNode({
+                type: "AST_HTML_COMMENT_NODE",
+                location: core.Location.zero,
+                errors: [],
+                comment_start: core.createSyntheticToken("<!--", "TOKEN_HTML_COMMENT_START"),
+                children: [core.createLiteral(" "), ...children.slice(), core.createLiteral(" ")],
+                comment_end: core.createSyntheticToken("-->", "TOKEN_HTML_COMMENT_END"),
+            });
+            children.length = 0;
+            children.push(commentNode);
+            break;
+        }
+    }
+    return printer.IdentityPrinter.print(document, { ignoreErrors: true });
+}
+/**
+ * Per-segment commenting uses text segments because the parser creates nested
+ * structures (e.g., ERBIfNode) that don't allow flat child iteration.
+ */
+function commentPerSegment(content, erbNodes) {
+    const segments = getLineSegments(content, erbNodes);
+    return segments.map(segment => {
+        if (segment.isERB) {
+            return segment.text.substring(0, 2) + "#" + segment.text.substring(2);
+        }
+        else if (segment.text.trim() !== "") {
+            return `<!-- ${segment.text} -->`;
+        }
+        return segment.text;
+    }).join("");
+}
+function uncommentLineContent(content, parserService) {
+    const parseResult = parserService.parseContent(content, { track_whitespace: true });
+    const lineCollector = new LineContextCollector();
+    parseResult.visit(lineCollector);
+    const lineERBNodes = lineCollector.erbNodesPerLine.get(0) || [];
+    const document = parseResult.value;
+    const children = rewriter.asMutable(document).children;
+    for (const node of lineERBNodes) {
+        if (core.isERBCommentNode(node)) {
+            uncommentERBNode(node);
+        }
+    }
+    let index = 0;
+    while (index < children.length) {
+        const child = children[index];
+        if (child.type === "AST_HTML_COMMENT_NODE") {
+            const commentNode = child;
+            const innerChildren = [...commentNode.children];
+            if (innerChildren.length > 0) {
+                const first = innerChildren[0];
+                if (core.isLiteralNode(first) && first.content.startsWith(" ")) {
+                    const trimmed = first.content.substring(1);
+                    if (trimmed === "") {
+                        innerChildren.shift();
+                    }
+                    else {
+                        innerChildren[0] = core.createLiteral(trimmed);
+                    }
+                }
+            }
+            if (innerChildren.length > 0) {
+                const last = innerChildren[innerChildren.length - 1];
+                if (core.isLiteralNode(last) && last.content.endsWith(" ")) {
+                    const trimmed = last.content.substring(0, last.content.length - 1);
+                    if (trimmed === "") {
+                        innerChildren.pop();
+                    }
+                    else {
+                        innerChildren[innerChildren.length - 1] = core.createLiteral(trimmed);
+                    }
+                }
+            }
+            const innerERBNodes = [];
+            const innerCollector = new LineContextCollector();
+            for (const innerChild of innerChildren) {
+                innerCollector.visit(innerChild);
+            }
+            innerERBNodes.push(...(innerCollector.erbNodesPerLine.get(0) || []));
+            for (const erbNode of innerERBNodes) {
+                if (core.isERBCommentNode(erbNode)) {
+                    uncommentERBNode(erbNode);
+                }
+            }
+            children.splice(index, 1, ...innerChildren);
+            index += innerChildren.length;
+            continue;
+        }
+        index++;
+    }
+    return printer.IdentityPrinter.print(document, { ignoreErrors: true });
+}
+
+class CommentService {
+    constructor(parserService) {
+        this.parserService = parserService;
+    }
+    toggleLineComment(document, range) {
+        const parseResult = this.parserService.parseDocument(document);
+        const collector = new LineContextCollector();
+        collector.visit(parseResult.document);
+        const startLine = range.start.line;
+        const endLine = range.end.line;
+        const lineInfos = [];
+        for (let line = startLine; line <= endLine; line++) {
+            const lineText = document.getText(node.Range.create(line, 0, line + 1, 0)).replace(/\n$/, "");
+            if (lineText.trim() === "") {
+                continue;
+            }
+            if (this.lineIsIfFalseWrapped(lineText) !== null) {
+                lineInfos.push({ line, context: "erb-comment", node: null });
+                continue;
+            }
+            const htmlCommentNode = collector.htmlCommentNodesPerLine.get(line);
+            const info = collector.lineMap.get(line);
+            if (htmlCommentNode && this.htmlCommentSpansLine(htmlCommentNode, lineText)) {
+                lineInfos.push({ line, context: "html-comment", node: htmlCommentNode });
+            }
+            else if (info) {
+                if (info.context === "html-comment") {
+                    lineInfos.push({ line, context: "html-content", node: null });
+                }
+                else {
+                    lineInfos.push(info);
+                }
+            }
+            else {
+                lineInfos.push({ line, context: "html-content", node: null });
+            }
+        }
+        if (lineInfos.length === 0)
+            return [];
+        const allCommented = lineInfos.every(info => info.context === "erb-comment" || info.context === "html-comment");
+        const edits = [];
+        if (allCommented) {
+            for (const info of lineInfos) {
+                const lineText = document.getText(node.Range.create(info.line, 0, info.line + 1, 0)).replace(/\n$/, "");
+                const edit = this.uncommentLine(info, lineText, collector);
+                if (edit)
+                    edits.push(edit);
+            }
+        }
+        else {
+            for (const info of lineInfos) {
+                if (info.context === "erb-comment" || info.context === "html-comment")
+                    continue;
+                const lineText = document.getText(node.Range.create(info.line, 0, info.line + 1, 0)).replace(/\n$/, "");
+                const erbNodes = collector.erbNodesPerLine.get(info.line) || [];
+                const edit = this.commentLine(info, lineText, erbNodes, collector);
+                if (edit)
+                    edits.push(edit);
+            }
+        }
+        return edits;
+    }
+    toggleBlockComment(document, range) {
+        const startLine = range.start.line;
+        const endLine = range.end.line;
+        const firstLineText = document.getText(node.Range.create(startLine, 0, startLine + 1, 0)).replace(/\n$/, "");
+        const lastLineText = document.getText(node.Range.create(endLine, 0, endLine + 1, 0)).replace(/\n$/, "");
+        const isWrapped = firstLineText.trim() === "<% if false %>" && lastLineText.trim() === "<% end %>";
+        if (isWrapped) {
+            return [
+                node.TextEdit.del(node.Range.create(endLine, 0, endLine + 1, 0)),
+                node.TextEdit.del(node.Range.create(startLine, 0, startLine + 1, 0)),
+            ];
+        }
+        else {
+            const firstLineIndent = this.getIndentation(firstLineText);
+            return [
+                node.TextEdit.insert(node.Position.create(endLine + 1, 0), `${firstLineIndent}<% end %>\n`),
+                node.TextEdit.insert(node.Position.create(startLine, 0), `${firstLineIndent}<% if false %>\n`),
+            ];
+        }
+    }
+    commentLine(info, lineText, erbNodes, collector) {
+        const lineRange = node.Range.create(info.line, 0, info.line, lineText.length);
+        const indent = this.getIndentation(lineText);
+        const content = lineText.trimStart();
+        const htmlCommentNode = collector.htmlCommentNodesPerLine.get(info.line);
+        if (htmlCommentNode) {
+            return node.TextEdit.replace(lineRange, `${indent}<% if false %>${content}<% end %>`);
+        }
+        const strategy = determineStrategy(erbNodes, lineText);
+        if (strategy === "single-erb") {
+            const node$1 = erbNodes[0];
+            const insertColumn = node$1.tag_opening.location.start.column + 2;
+            return node.TextEdit.insert(node.Position.create(info.line, insertColumn), "#");
+        }
+        const result = commentLineContent(content, erbNodes, strategy, this.parserService);
+        return node.TextEdit.replace(lineRange, indent + result);
+    }
+    lineIsIfFalseWrapped(lineText) {
+        const trimmed = lineText.trimStart();
+        const indent = this.getIndentation(lineText);
+        if (trimmed.startsWith("<% if false %>") && trimmed.endsWith("<% end %>")) {
+            const inner = trimmed.slice("<% if false %>".length, -"<% end %>".length);
+            return indent + inner;
+        }
+        return null;
+    }
+    uncommentLine(info, lineText, collector) {
+        var _a;
+        const lineRange = node.Range.create(info.line, 0, info.line, lineText.length);
+        const indent = this.getIndentation(lineText);
+        const ifFalseContent = this.lineIsIfFalseWrapped(lineText);
+        if (ifFalseContent !== null) {
+            return node.TextEdit.replace(lineRange, ifFalseContent);
+        }
+        if (info.context === "erb-comment") {
+            const node$1 = info.node;
+            if (!(node$1 === null || node$1 === void 0 ? void 0 : node$1.tag_opening) || !(node$1 === null || node$1 === void 0 ? void 0 : node$1.tag_closing))
+                return null;
+            const contentValue = (_a = node$1.content) === null || _a === void 0 ? void 0 : _a.value;
+            const trimmedContent = (contentValue === null || contentValue === void 0 ? void 0 : contentValue.trim()) || "";
+            if (trimmedContent.startsWith("<") && !trimmedContent.startsWith("<%")) {
+                return node.TextEdit.replace(lineRange, `${indent}${trimmedContent}`);
+            }
+            if (lspLine(node$1.tag_opening.location.start) !== info.line)
+                return null;
+            const erbNodes = collector.erbNodesPerLine.get(info.line) || [];
+            if (erbNodes.length > 1) {
+                const content = lineText.trimStart();
+                const result = uncommentLineContent(content, this.parserService);
+                return node.TextEdit.replace(lineRange, indent + result);
+            }
+            const hashColumn = node$1.tag_opening.location.start.column + 2;
+            if ((contentValue === null || contentValue === void 0 ? void 0 : contentValue.startsWith(" graphql ")) ||
+                (contentValue === null || contentValue === void 0 ? void 0 : contentValue.startsWith(" %= ")) ||
+                (contentValue === null || contentValue === void 0 ? void 0 : contentValue.startsWith(" == ")) ||
+                (contentValue === null || contentValue === void 0 ? void 0 : contentValue.startsWith(" % ")) ||
+                (contentValue === null || contentValue === void 0 ? void 0 : contentValue.startsWith(" = ")) ||
+                (contentValue === null || contentValue === void 0 ? void 0 : contentValue.startsWith(" - "))) {
+                return node.TextEdit.del(node.Range.create(info.line, hashColumn, info.line, hashColumn + 2));
+            }
+            return node.TextEdit.del(node.Range.create(info.line, hashColumn, info.line, hashColumn + 1));
+        }
+        if (info.context === "html-comment") {
+            const commentNode = info.node;
+            if ((commentNode === null || commentNode === void 0 ? void 0 : commentNode.comment_start) && (commentNode === null || commentNode === void 0 ? void 0 : commentNode.comment_end)) {
+                const contentStart = commentNode.comment_start.location.end.column;
+                const contentEnd = commentNode.comment_end.location.start.column;
+                const innerContent = lineText.substring(contentStart, contentEnd).trim();
+                const result = uncommentLineContent(innerContent, this.parserService);
+                return node.TextEdit.replace(lineRange, `${indent}${result}`);
+            }
+        }
+        return null;
+    }
+    htmlCommentSpansLine(node, lineText) {
+        if (!node.comment_start || !node.comment_end)
+            return false;
+        const commentStart = node.comment_start.location.start.column;
+        const commentEnd = node.comment_end.location.end.column;
+        const contentBefore = lineText.substring(0, commentStart).trim();
+        const contentAfter = lineText.substring(commentEnd).trim();
+        return contentBefore === "" && contentAfter === "";
+    }
+    getIndentation(lineText) {
+        const match = lineText.match(/^(\s*)/);
+        return match ? match[1] : "";
+    }
+}
+
+class Service {
+    constructor(connection, params) {
+        this.connection = connection;
+        this.settings = new Settings(params, this.connection);
+        this.documentService = new DocumentService(this.connection);
+        this.project = new Project(connection, this.settings.projectPath.replace("file://", ""));
+        this.parserService = new ParserService();
+        this.linterService = new LinterService(this.connection, this.settings, this.project);
+        this.formattingService = new FormattingService(this.connection, this.documentService.documents, this.project, this.settings);
+        this.autofixService = new AutofixService(this.connection, this.config);
+        this.configService = new ConfigService(this.project.projectPath);
+        this.codeActionService = new CodeActionService(this.project, this.config);
+        this.diagnostics = new Diagnostics(this.connection, this.documentService, this.parserService, this.linterService, this.configService);
+        this.documentSaveService = new DocumentSaveService(this.connection, this.settings, this.autofixService, this.formattingService);
+        this.foldingRangeService = new FoldingRangeService(this.parserService);
+        this.documentHighlightService = new DocumentHighlightService(this.parserService);
+        this.hoverService = new HoverService(this.parserService);
+        this.rewriteCodeActionService = new RewriteCodeActionService(this.parserService);
+        this.commentService = new CommentService(this.parserService);
+        if (params.initializationOptions) {
+            this.settings.globalSettings = params.initializationOptions;
+        }
+    }
+    async init() {
+        await this.project.initialize();
+        await this.formattingService.initialize();
+        try {
+            this.config = await config.Config.loadForEditor(this.project.projectPath, version);
+            this.codeActionService.setConfig(this.config);
+            this.autofixService.setConfig(this.config);
+            if (this.config.version && this.config.version !== version) {
+                this.connection.console.warn(`Config file version (${this.config.version}) does not match current version (${version}). ` +
+                    `Consider updating your .herb.yml file.`);
+            }
+        }
+        catch (error) {
+            this.connection.console.warn(`Failed to load config: ${error instanceof Error ? error.message : String(error)}. Using personal settings with defaults.`);
+            this.config = config.Config.fromObject({
+                linter: this.settings.globalSettings.linter,
+                formatter: this.settings.globalSettings.formatter
+            }, { projectPath: this.project.projectPath, version });
+            this.codeActionService.setConfig(this.config);
+            this.autofixService.setConfig(this.config);
+        }
+        await this.settings.initializeProjectConfig(this.config);
+        await this.formattingService.refreshConfig(this.config);
+        this.linterService.rebuildLinter();
+        this.documentService.onDidClose((change) => {
+            this.settings.documentSettings.delete(change.document.uri);
+        });
+        this.documentService.onDidChangeContent(async (change) => {
+            await this.diagnostics.refreshDocument(change.document);
+        });
+    }
+    async refresh() {
+        await this.project.refresh();
+        await this.formattingService.refreshConfig(this.config);
+        await this.diagnostics.refreshAllDocuments();
+    }
+    async refreshConfig() {
+        try {
+            this.config = await config.Config.loadForEditor(this.project.projectPath, version);
+            this.codeActionService.setConfig(this.config);
+            this.autofixService.setConfig(this.config);
+            if (this.config.version && this.config.version !== version) {
+                this.connection.console.warn(`Config file version (${this.config.version}) does not match current version (${version}). ` +
+                    `Consider updating your .herb.yml file.`);
+            }
+        }
+        catch (error) {
+            this.connection.console.warn(`Failed to load config: ${error instanceof Error ? error.message : String(error)}. Using personal settings with defaults.`);
+            this.config = config.Config.fromObject({
+                linter: this.settings.globalSettings.linter,
+                formatter: this.settings.globalSettings.formatter
+            }, { projectPath: this.project.projectPath, version });
+            this.codeActionService.setConfig(this.config);
+            this.autofixService.setConfig(this.config);
+        }
+        await this.settings.refreshProjectConfig(this.config);
+        await this.formattingService.refreshConfig(this.config);
+        this.linterService.rebuildLinter();
     }
 }
 
@@ -1460,8 +2375,11 @@ class Server {
                     documentFormattingProvider: true,
                     documentRangeFormattingProvider: true,
                     codeActionProvider: {
-                        codeActionKinds: [node.CodeActionKind.QuickFix, node.CodeActionKind.SourceFixAll]
+                        codeActionKinds: [node.CodeActionKind.QuickFix, node.CodeActionKind.SourceFixAll, node.CodeActionKind.RefactorRewrite]
                     },
+                    foldingRangeProvider: true,
+                    documentHighlightProvider: true,
+                    hoverProvider: true,
                 },
             };
             if (this.service.settings.hasWorkspaceFolderCapability) {
@@ -1543,15 +2461,49 @@ class Server {
         this.connection.onDocumentRangeFormatting((params) => {
             return this.service.formattingService.formatRange(params);
         });
+        this.connection.onDocumentHighlight((params) => {
+            const document = this.service.documentService.get(params.textDocument.uri);
+            if (!document)
+                return [];
+            return this.service.documentHighlightService.getDocumentHighlights(document, params.position);
+        });
+        this.connection.onHover((params) => {
+            const document = this.service.documentService.get(params.textDocument.uri);
+            if (!document)
+                return null;
+            return this.service.hoverService.getHover(document, params.position);
+        });
         this.connection.onCodeAction((params) => {
             const document = this.service.documentService.get(params.textDocument.uri);
             if (!document)
                 return [];
+            const parseResult = this.service.parserService.parseDocument(document);
+            if (parseResult.diagnostics.length > 0)
+                return [];
             const diagnostics = params.context.diagnostics;
             const documentText = document.getText();
             const linterDisableCodeActions = this.service.codeActionService.createCodeActions(params.textDocument.uri, diagnostics, documentText);
             const autofixCodeActions = this.service.codeActionService.autofixCodeActions(params, document);
-            return autofixCodeActions.concat(linterDisableCodeActions);
+            const rewriteCodeActions = this.service.rewriteCodeActionService.getCodeActions(document, params.range);
+            return autofixCodeActions.concat(linterDisableCodeActions).concat(rewriteCodeActions);
+        });
+        this.connection.onFoldingRanges((params) => {
+            const document = this.service.documentService.get(params.textDocument.uri);
+            if (!document)
+                return [];
+            return this.service.foldingRangeService.getFoldingRanges(document);
+        });
+        this.connection.onRequest('herb/toggleLineComment', (params) => {
+            const document = this.service.documentService.get(params.textDocument.uri);
+            if (!document)
+                return [];
+            return this.service.commentService.toggleLineComment(document, params.range);
+        });
+        this.connection.onRequest('herb/toggleBlockComment', (params) => {
+            const document = this.service.documentService.get(params.textDocument.uri);
+            if (!document)
+                return [];
+            return this.service.commentService.toggleBlockComment(document, params.range);
         });
     }
     listen() {
@@ -1582,17 +2534,31 @@ class CLI {
 }
 
 exports.CLI = CLI;
+exports.CommentService = CommentService;
 exports.Diagnostics = Diagnostics;
+exports.DocumentHighlightCollector = DocumentHighlightCollector;
+exports.DocumentHighlightService = DocumentHighlightService;
 exports.DocumentService = DocumentService;
+exports.FoldingRangeCollector = FoldingRangeCollector;
+exports.FoldingRangeService = FoldingRangeService;
 exports.FormattingService = FormattingService;
 exports.Project = Project;
 exports.Server = Server;
 exports.Service = Service;
 exports.Settings = Settings;
-exports.UnreachableCodeCollector = UnreachableCodeCollector;
 exports.camelize = camelize;
 exports.capitalize = capitalize;
 exports.dasherize = dasherize;
+exports.erbTagToRange = erbTagToRange;
 exports.getFullDocumentRange = getFullDocumentRange;
+exports.isPositionInRange = isPositionInRange;
 exports.lintToDignosticSeverity = lintToDignosticSeverity;
+exports.lintToDignosticTags = lintToDignosticTags;
+exports.lspLine = lspLine;
+exports.lspPosition = lspPosition;
+exports.lspRangeFromLocation = lspRangeFromLocation;
+exports.nodeToRange = nodeToRange;
+exports.openTagRanges = openTagRanges;
+exports.rangeSize = rangeSize;
+exports.tokenToRange = tokenToRange;
 //# sourceMappingURL=index.cjs.map