@herb-tools/language-server 0.8.10 → 0.9.0

package/dist/index.cjs

@@ -9,8 +9,10 @@ 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 printer = require('@herb-tools/printer');
+var rewriter = require('@herb-tools/rewriter');
 
-var version = "0.8.10";
+var version = "0.9.0";
 
 class Settings {
     constructor(params, connection) {
@@ -137,6 +139,70 @@ class DocumentService {
     }
 }
 
+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)));
+    }
+    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;
+    }
+    if (position.line === range.start.line && position.character < range.start.character) {
+        return false;
+    }
+    if (position.line === range.end.line && position.character > range.end.character) {
+        return false;
+    }
+    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 Diagnostics {
     constructor(connection, documentService, parserService, linterService, configService) {
         this.diagnostics = new Map();
@@ -308,16 +374,7 @@ class UnreachableCodeCollector extends core.Visitor {
     }
     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
-                }
-            },
+            range: lspRangeFromLocation(location),
             message,
             severity: node.DiagnosticSeverity.Hint,
             tags: [node.DiagnosticTag.Unnecessary],
@@ -345,14 +402,14 @@ class UnreachableCodeCollector extends core.Visitor {
     markIfChainAsProcessed(node) {
         this.processedIfNodes.add(node);
         this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if (current.type === 'AST_ERB_IF_NODE') {
+            if (core.isERBIfNode(current)) {
                 this.processedIfNodes.add(current);
             }
         });
     }
     markElseNodesInIfChain(node) {
         this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if (current.type === 'AST_ERB_ELSE_NODE') {
+            if (core.isERBElseNode(current)) {
                 this.processedElseNodes.add(current);
             }
         });
@@ -360,10 +417,14 @@ class UnreachableCodeCollector extends core.Visitor {
     traverseSubsequentNodes(startNode, callback) {
         let current = startNode;
         while (current) {
-            callback(current);
-            if ('subsequent' in current) {
+            if (core.isERBIfNode(current)) {
+                callback(current);
                 current = current.subsequent;
             }
+            else if (core.isERBElseNode(current)) {
+                callback(current);
+                break;
+            }
             else {
                 break;
             }
@@ -374,14 +435,11 @@ class UnreachableCodeCollector extends core.Visitor {
             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;
+            const blockType = core.isERBIfNode(current) ? 'elsif' : 'else';
+            const nextSubsequent = core.isERBIfNode(current) ? current.subsequent : null;
             if (nextSubsequent) {
                 this.checkEmptyStatementsWithEndLocation(current, current.statements, blockType, nextSubsequent);
             }
@@ -396,17 +454,12 @@ class UnreachableCodeCollector extends core.Visitor {
         }
         let hasContent = false;
         this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if ('statements' in current && Array.isArray(current.statements)) {
-                if (this.statementsHaveContent(current.statements)) {
-                    hasContent = true;
-                }
+            if (this.statementsHaveContent(current.statements)) {
+                hasContent = true;
             }
         });
         return !hasContent;
     }
-    toZeroBased(line) {
-        return line - 1;
-    }
 }
 
 class ErrorVisitor extends nodeWasm.Visitor {
@@ -423,7 +476,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 +486,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 +498,9 @@ class ParserService {
             diagnostics: errorVisitor.diagnostics
         };
     }
+    parseContent(content, options) {
+        return nodeWasm.Herb.parse(content, options);
+    }
 }
 
 function camelize(value) {
@@ -467,21 +520,6 @@ 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)
-    });
-    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';
 class LinterService {
@@ -563,8 +601,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,12 +644,12 @@ 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 {
                 source: this.source,
@@ -770,7 +824,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 +835,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 +863,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 +1341,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 +1360,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 +1384,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,18 +1403,1066 @@ 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(document, reason, autofixEdits[0].newText);
+    }
+}
+
+class FoldingRangeService {
+    constructor(parserService) {
+        this.parserService = parserService;
+    }
+    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);
+        }
+        this.visitChildNodes(node);
+    }
+    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);
+    }
+    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);
+        }
+        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,
+            });
+        }
+    }
+}
+
+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,
         };
-        return this.formattingService.formatOnSave(autofixedDocument, reason);
+    }
+    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] : "";
     }
 }
 
@@ -1369,6 +2480,11 @@ class Service {
         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;
         }
@@ -1460,8 +2576,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,6 +2662,18 @@ 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)
@@ -1551,7 +2682,26 @@ class Server {
             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,8 +2732,13 @@ 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;
@@ -1593,6 +2748,15 @@ 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.lspLine = lspLine;
+exports.lspPosition = lspPosition;
+exports.lspRangeFromLocation = lspRangeFromLocation;
+exports.nodeToRange = nodeToRange;
+exports.openTagRanges = openTagRanges;
+exports.rangeSize = rangeSize;
+exports.tokenToRange = tokenToRange;
 //# sourceMappingURL=index.cjs.map