@herb-tools/linter 0.8.9 → 0.9.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import { getNodesBeforePosition, getNodesAfterPosition, filterNodes, ERBContentNode, isERBOutputNode, Visitor, isToken, isParseResult, getStaticAttributeName, hasDynamicAttributeName as hasDynamicAttributeName$1, getCombinedAttributeName, hasStaticContent, getStaticContentFromNodes, Location, hasERBOutput, isEffectivelyStatic, getValidatableStaticContent, isERBNode, isWhitespaceNode, isCommentNode, isLiteralNode, isHTMLTextNode, Position, filterERBContentNodes, isNode, LiteralNode, didyoumean, filterLiteralNodes, Token, getTagName as getTagName$1, isHTMLElementNode, isHTMLOpenTagNode, HTMLCloseTagNode, WhitespaceNode, filterWhitespaceNodes, HTMLOpenTagNode, isERBCommentNode } from '@herb-tools/core';
 import picomatch from 'picomatch';
+import { getNodesBeforePosition, getNodesAfterPosition, filterNodes, ERBContentNode, isERBOutputNode, isERBIfNode, isERBUnlessNode, isERBElseNode, isHTMLTextNode, Visitor, isToken, isParseResult, forEachAttribute, getAttributeName, hasDynamicAttributeNameOnAttribute, getStaticAttributeValue, getAttributeValueNodes, hasERBOutput, isEffectivelyStatic, getValidatableStaticContent, getAttributeValue, getCombinedAttributeNameString, Location, Position, isERBOpenTagNode, isERBNode, isWhitespaceNode, isCommentNode, isLiteralNode, isERBCaseNode, isPureWhitespaceNode, isERBWhenNode, isHTMLElementNode, isEquivalentElement, findParentArray, removeNodeFromArray, replaceNodeWithBody, createLiteral, HTMLElementNode, PrismVisitor, splitLiteralsAtWhitespace, groupNodesByClass, filterERBContentNodes, isHTMLOpenTagNode, getTagLocalName, getAttribute, isERBCommentNode, getAttributes, findAttributeByName, isNode, LiteralNode, didyoumean, hasAttributeValue, isRubyLiteralNode, filterHTMLAttributeNodes, filterLiteralNodes, getAttributeValueQuoteType, Token, hasAttribute, isHTMLAttributeValueNode, isERBContentNode, getStaticAttributeName, isERBControlFlowNode, HTMLCloseTagNode, getTagName, createWhitespaceNode, filterWhitespaceNodes, getStaticContentFromNodes, getOpenTag, isHTMLCloseTagNode, HTMLOpenTagNode, DEFAULT_PARSER_OPTIONS } from '@herb-tools/core';
 
 class PrintContext {
     output = "";
@@ -141,7 +141,9 @@ class Printer extends Visitor {
         return this.context.getOutput();
     }
     write(content) {
-        this.context.write(content);
+        if (content !== null && content !== undefined) {
+            this.context.write(content);
+        }
     }
 }
 
@@ -201,6 +203,12 @@ class IdentityPrinter extends Printer {
             this.write(node.tag_closing.value);
         }
     }
+    visitHTMLVirtualCloseTagNode(_node) {
+        // Virtual closing tags don't print anything (they are synthetic)
+    }
+    visitHTMLOmittedCloseTagNode(_node) {
+        // Omitted closing tags don't print anything
+    }
     visitHTMLElementNode(node) {
         const tagName = node.tag_name?.value;
         if (tagName) {
@@ -219,6 +227,24 @@ class IdentityPrinter extends Printer {
             this.context.exitTag();
         }
     }
+    visitHTMLConditionalElementNode(node) {
+        const tagName = node.tag_name?.value;
+        if (tagName) {
+            this.context.enterTag(tagName);
+        }
+        if (node.open_conditional) {
+            this.visit(node.open_conditional);
+        }
+        if (node.body) {
+            node.body.forEach(child => this.visit(child));
+        }
+        if (node.close_conditional) {
+            this.visit(node.close_conditional);
+        }
+        if (tagName) {
+            this.context.exitTag();
+        }
+    }
     visitHTMLAttributeNode(node) {
         if (node.name) {
             this.visit(node.name);
@@ -242,6 +268,12 @@ class IdentityPrinter extends Printer {
             this.write(node.close_quote.value);
         }
     }
+    visitRubyLiteralNode(node) {
+        this.write(node.content);
+    }
+    visitRubyHTMLAttributesSplatNode(node) {
+        this.write(node.content);
+    }
     visitHTMLCommentNode(node) {
         if (node.comment_start) {
             this.write(node.comment_start.value);
@@ -278,6 +310,9 @@ class IdentityPrinter extends Printer {
             this.write(node.tag_closing.value);
         }
     }
+    visitERBOpenTagNode(node) {
+        this.printERBNode(node);
+    }
     visitERBContentNode(node) {
         this.printERBNode(node);
     }
@@ -444,6 +479,259 @@ class IdentityPrinter extends Printer {
     }
 }
 
+/**
+ * IndentPrinter - Re-indentation printer that preserves content but adjusts indentation
+ *
+ * Extends IdentityPrinter to preserve all content as-is while replacing
+ * leading whitespace on each line with the correct indentation based on
+ * the AST nesting depth.
+ */
+class IndentPrinter extends IdentityPrinter {
+    indentLevel = 0;
+    indentWidth;
+    pendingIndent = false;
+    constructor(indentWidth = 2) {
+        super();
+        this.indentWidth = indentWidth;
+    }
+    get indent() {
+        return " ".repeat(this.indentLevel * this.indentWidth);
+    }
+    write(content) {
+        if (this.pendingIndent && content.length > 0) {
+            this.pendingIndent = false;
+            this.context.write(this.indent + content);
+        }
+        else {
+            this.context.write(content);
+        }
+    }
+    visitLiteralNode(node) {
+        this.writeWithIndent(node.content);
+    }
+    visitHTMLTextNode(node) {
+        this.writeWithIndent(node.content);
+    }
+    visitHTMLElementNode(node) {
+        const tagName = node.tag_name?.value;
+        if (tagName) {
+            this.context.enterTag(tagName);
+        }
+        if (node.open_tag) {
+            this.visit(node.open_tag);
+        }
+        if (node.body) {
+            this.indentLevel++;
+            node.body.forEach(child => this.visit(child));
+            this.indentLevel--;
+        }
+        if (node.close_tag) {
+            this.visit(node.close_tag);
+        }
+        if (tagName) {
+            this.context.exitTag();
+        }
+    }
+    visitERBIfNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            this.indentLevel++;
+            node.statements.forEach(statement => this.visit(statement));
+            this.indentLevel--;
+        }
+        if (node.subsequent) {
+            this.visit(node.subsequent);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBElseNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            this.indentLevel++;
+            node.statements.forEach(statement => this.visit(statement));
+            this.indentLevel--;
+        }
+    }
+    visitERBBlockNode(node) {
+        this.printERBNode(node);
+        if (node.body) {
+            this.indentLevel++;
+            node.body.forEach(child => this.visit(child));
+            this.indentLevel--;
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBCaseNode(node) {
+        this.printERBNode(node);
+        if (node.children) {
+            this.indentLevel++;
+            node.children.forEach(child => this.visit(child));
+            this.indentLevel--;
+        }
+        if (node.conditions) {
+            this.indentLevel++;
+            node.conditions.forEach(condition => this.visit(condition));
+            this.indentLevel--;
+        }
+        if (node.else_clause) {
+            this.indentLevel++;
+            this.visit(node.else_clause);
+            this.indentLevel--;
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBWhenNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            this.indentLevel++;
+            node.statements.forEach(statement => this.visit(statement));
+            this.indentLevel--;
+        }
+    }
+    visitERBWhileNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            this.indentLevel++;
+            node.statements.forEach(statement => this.visit(statement));
+            this.indentLevel--;
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBUntilNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            this.indentLevel++;
+            node.statements.forEach(statement => this.visit(statement));
+            this.indentLevel--;
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBForNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            this.indentLevel++;
+            node.statements.forEach(statement => this.visit(statement));
+            this.indentLevel--;
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBBeginNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            this.indentLevel++;
+            node.statements.forEach(statement => this.visit(statement));
+            this.indentLevel--;
+        }
+        if (node.rescue_clause) {
+            this.visit(node.rescue_clause);
+        }
+        if (node.else_clause) {
+            this.visit(node.else_clause);
+        }
+        if (node.ensure_clause) {
+            this.visit(node.ensure_clause);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBRescueNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            this.indentLevel++;
+            node.statements.forEach(statement => this.visit(statement));
+            this.indentLevel--;
+        }
+        if (node.subsequent) {
+            this.visit(node.subsequent);
+        }
+    }
+    visitERBEnsureNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            this.indentLevel++;
+            node.statements.forEach(statement => this.visit(statement));
+            this.indentLevel--;
+        }
+    }
+    visitERBUnlessNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            this.indentLevel++;
+            node.statements.forEach(statement => this.visit(statement));
+            this.indentLevel--;
+        }
+        if (node.else_clause) {
+            this.visit(node.else_clause);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    /**
+     * Write content, replacing leading whitespace on each line with the current indent.
+     *
+     * Uses a pendingIndent mechanism: when content ends with a newline followed by
+     * whitespace-only, sets pendingIndent=true instead of writing the indent immediately.
+     * The indent is then applied at the correct level when the next node writes content
+     * (via the overridden write() method).
+     */
+    writeWithIndent(content) {
+        if (!content.includes("\n")) {
+            if (this.pendingIndent) {
+                this.pendingIndent = false;
+                const trimmed = content.replace(/^[ \t]+/, "");
+                if (trimmed.length > 0) {
+                    this.context.write(this.indent + trimmed);
+                }
+            }
+            else {
+                this.context.write(content);
+            }
+            return;
+        }
+        const lines = content.split("\n");
+        const lastIndex = lines.length - 1;
+        for (let i = 0; i < lines.length; i++) {
+            if (i > 0) {
+                this.context.write("\n");
+            }
+            const line = lines[i];
+            const trimmed = line.replace(/^[ \t]+/, "");
+            if (i === 0) {
+                if (this.pendingIndent) {
+                    this.pendingIndent = false;
+                    if (trimmed.length > 0) {
+                        this.context.write(this.indent + trimmed);
+                    }
+                }
+                else {
+                    this.context.write(line);
+                }
+            }
+            else if (i === lastIndex && trimmed.length === 0) {
+                this.pendingIndent = true;
+            }
+            else if (trimmed.length === 0) ;
+            else {
+                this.context.write(this.indent + trimmed);
+            }
+        }
+    }
+}
+
 const DEFAULT_ERB_TO_RUBY_STRING_OPTIONS = {
     ...DEFAULT_PRINT_OPTIONS,
     forceQuotes: false
@@ -465,7 +753,6 @@ const DEFAULT_ERB_TO_RUBY_STRING_OPTIONS = {
  * - `<% if logged_in? %>Welcome<% else %>Login<% end %>!` => `"#{logged_in? ? "Welcome" : "Login"}!"`
  */
 class ERBToRubyStringPrinter extends IdentityPrinter {
-    // TODO: cleanup `.type === "AST_*" checks`
     static print(node, options = DEFAULT_ERB_TO_RUBY_STRING_OPTIONS) {
         const erbNodes = filterNodes([node], ERBContentNode);
         if (erbNodes.length === 1 && isERBOutputNode(erbNodes[0]) && !options.forceQuotes) {
@@ -477,19 +764,18 @@ class ERBToRubyStringPrinter extends IdentityPrinter {
             if (hasOnlyERBContent && childErbNodes.length === 1 && isERBOutputNode(childErbNodes[0]) && !options.forceQuotes) {
                 return (childErbNodes[0].content?.value || "").trim();
             }
-            if (node.children.length === 1 && node.children[0].type === "AST_ERB_IF_NODE" && !options.forceQuotes) {
-                const ifNode = node.children[0];
+            const firstChild = node.children[0];
+            if (node.children.length === 1 && isERBIfNode(firstChild) && !options.forceQuotes) {
                 const printer = new ERBToRubyStringPrinter();
-                if (printer.canConvertToTernary(ifNode)) {
-                    printer.convertToTernaryWithoutWrapper(ifNode);
+                if (printer.canConvertToTernary(firstChild)) {
+                    printer.convertToTernaryWithoutWrapper(firstChild);
                     return printer.context.getOutput();
                 }
             }
-            if (node.children.length === 1 && node.children[0].type === "AST_ERB_UNLESS_NODE" && !options.forceQuotes) {
-                const unlessNode = node.children[0];
+            if (node.children.length === 1 && isERBUnlessNode(firstChild) && !options.forceQuotes) {
                 const printer = new ERBToRubyStringPrinter();
-                if (printer.canConvertUnlessToTernary(unlessNode)) {
-                    printer.convertUnlessToTernaryWithoutWrapper(unlessNode);
+                if (printer.canConvertUnlessToTernary(firstChild)) {
+                    printer.convertUnlessToTernaryWithoutWrapper(firstChild);
                     return printer.context.getOutput();
                 }
             }
@@ -529,15 +815,15 @@ class ERBToRubyStringPrinter extends IdentityPrinter {
         this.visitChildNodes(node);
     }
     canConvertToTernary(node) {
-        if (node.subsequent && node.subsequent.type !== "AST_ERB_ELSE_NODE") {
+        if (node.subsequent && !isERBElseNode(node.subsequent)) {
             return false;
         }
-        const ifOnlyText = node.statements ? node.statements.every(statement => statement.type === "AST_HTML_TEXT_NODE") : true;
+        const ifOnlyText = node.statements ? node.statements.every(isHTMLTextNode) : true;
         if (!ifOnlyText)
             return false;
-        if (node.subsequent && node.subsequent.type === "AST_ERB_ELSE_NODE") {
+        if (isERBElseNode(node.subsequent)) {
             return node.subsequent.statements
-                ? node.subsequent.statements.every(statement => statement.type === "AST_HTML_TEXT_NODE")
+                ? node.subsequent.statements.every(isHTMLTextNode)
                 : true;
         }
         return true;
@@ -564,14 +850,14 @@ class ERBToRubyStringPrinter extends IdentityPrinter {
         this.context.write('"');
         this.context.write(" : ");
         this.context.write('"');
-        if (node.subsequent && node.subsequent.type === "AST_ERB_ELSE_NODE" && node.subsequent.statements) {
+        if (isERBElseNode(node.subsequent) && node.subsequent.statements) {
             node.subsequent.statements.forEach(statement => this.visit(statement));
         }
         this.context.write('"');
         this.context.write("}");
     }
     convertToTernaryWithoutWrapper(node) {
-        if (node.subsequent && node.subsequent.type !== "AST_ERB_ELSE_NODE") {
+        if (node.subsequent && !isERBElseNode(node.subsequent)) {
             return false;
         }
         if (node.content?.value) {
@@ -594,18 +880,18 @@ class ERBToRubyStringPrinter extends IdentityPrinter {
         this.context.write('"');
         this.context.write(" : ");
         this.context.write('"');
-        if (node.subsequent && node.subsequent.type === "AST_ERB_ELSE_NODE" && node.subsequent.statements) {
+        if (isERBElseNode(node.subsequent) && node.subsequent.statements) {
             node.subsequent.statements.forEach(statement => this.visit(statement));
         }
         this.context.write('"');
     }
     canConvertUnlessToTernary(node) {
-        const unlessOnlyText = node.statements ? node.statements.every(statement => statement.type === "AST_HTML_TEXT_NODE") : true;
+        const unlessOnlyText = node.statements ? node.statements.every(isHTMLTextNode) : true;
         if (!unlessOnlyText)
             return false;
-        if (node.else_clause && node.else_clause.type === "AST_ERB_ELSE_NODE") {
+        if (isERBElseNode(node.else_clause)) {
             return node.else_clause.statements
-                ? node.else_clause.statements.every(statement => statement.type === "AST_HTML_TEXT_NODE")
+                ? node.else_clause.statements.every(isHTMLTextNode)
                 : true;
         }
         return true;
@@ -634,7 +920,7 @@ class ERBToRubyStringPrinter extends IdentityPrinter {
         this.context.write('"');
         this.context.write(" : ");
         this.context.write('"');
-        if (node.else_clause && node.else_clause.type === "AST_ERB_ELSE_NODE") {
+        if (isERBElseNode(node.else_clause)) {
             node.else_clause.statements.forEach(statement => this.visit(statement));
         }
         this.context.write('"');
@@ -663,13 +949,16 @@ class ERBToRubyStringPrinter extends IdentityPrinter {
         this.context.write('"');
         this.context.write(" : ");
         this.context.write('"');
-        if (node.else_clause && node.else_clause.type === "AST_ERB_ELSE_NODE") {
+        if (isERBElseNode(node.else_clause)) {
             node.else_clause.statements.forEach(statement => this.visit(statement));
         }
         this.context.write('"');
     }
 }
 
+const DEFAULT_LINTER_PARSER_OPTIONS = {
+    track_whitespace: true,
+};
 /**
  * Default configuration for rules when defaultConfig is not specified.
  * Custom rules can omit defaultConfig and will use these defaults.
@@ -684,26 +973,61 @@ const DEFAULT_RULE_CONFIG = {
  */
 class ParserRule {
     static type = "parser";
+    static ruleName;
     /** Indicates whether this rule supports autofix. Defaults to false. */
     static autocorrectable = false;
     /** Indicates whether this rule supports unsafe autofix (requires --fix-unsafely). Defaults to false. */
     static unsafeAutocorrectable = false;
+    /** Indicates whether the source should be re-indented after autofix. Defaults to false. */
+    static reindentAfterAutofix = false;
+    get ruleName() {
+        return this.constructor.ruleName;
+    }
     get defaultConfig() {
         return DEFAULT_RULE_CONFIG;
     }
+    get parserOptions() {
+        return DEFAULT_LINTER_PARSER_OPTIONS;
+    }
+    createOffense(message, location, autofixContext, severity) {
+        return {
+            rule: this.ruleName,
+            code: this.ruleName,
+            source: "Herb Linter",
+            message,
+            location,
+            autofixContext,
+            severity,
+        };
+    }
 }
 /**
  * Base class for lexer rules.
  */
 class LexerRule {
     static type = "lexer";
+    static ruleName;
     /** Indicates whether this rule supports autofix. Defaults to false. */
     static autocorrectable = false;
     /** Indicates whether this rule supports unsafe autofix (requires --fix-unsafely). Defaults to false. */
     static unsafeAutocorrectable = false;
+    get ruleName() {
+        return this.constructor.ruleName;
+    }
     get defaultConfig() {
         return DEFAULT_RULE_CONFIG;
     }
+    createOffense(message, location, autofixContext, severity) {
+        return {
+            rule: this.ruleName,
+            code: this.ruleName,
+            source: "Herb Linter",
+            message,
+            location,
+            autofixContext,
+            severity,
+        };
+    }
 }
 /**
  * Default context object with all keys defined but set to undefined
@@ -716,13 +1040,28 @@ const DEFAULT_LINT_CONTEXT = {
 };
 class SourceRule {
     static type = "source";
+    static ruleName;
     /** Indicates whether this rule supports autofix. Defaults to false. */
     static autocorrectable = false;
     /** Indicates whether this rule supports unsafe autofix (requires --fix-unsafely). Defaults to false. */
     static unsafeAutocorrectable = false;
+    get ruleName() {
+        return this.constructor.ruleName;
+    }
     get defaultConfig() {
         return DEFAULT_RULE_CONFIG;
     }
+    createOffense(message, location, autofixContext, severity) {
+        return {
+            rule: this.ruleName,
+            code: this.ruleName,
+            source: "Herb Linter",
+            message,
+            location,
+            autofixContext,
+            severity,
+        };
+    }
 }
 
 var ControlFlowType;
@@ -746,7 +1085,7 @@ class BaseRuleVisitor extends Visitor {
      * Helper method to create an unbound lint offense (without severity).
      * The Linter will bind severity based on the rule's config.
      */
-    createOffense(message, location, autofixContext) {
+    createOffense(message, location, autofixContext, severity) {
         return {
             rule: this.ruleName,
             code: this.ruleName,
@@ -754,13 +1093,14 @@ class BaseRuleVisitor extends Visitor {
             message,
             location,
             autofixContext,
+            severity,
         };
     }
     /**
      * Helper method to add an offense to the offenses array
      */
-    addOffense(message, location, autofixContext) {
-        this.offenses.push(this.createOffense(message, location, autofixContext));
+    addOffense(message, location, autofixContext, severity) {
+        this.offenses.push(this.createOffense(message, location, autofixContext, severity));
     }
 }
 /**
@@ -829,195 +1169,7 @@ class ControlFlowTrackingVisitor extends BaseRuleVisitor {
     }
 }
 /**
- * Gets attributes from an HTMLOpenTagNode
- */
-function getAttributes(node) {
-    return node.children.filter(node => node.type === "AST_HTML_ATTRIBUTE_NODE");
-}
-/**
- * Gets the tag name from an HTML tag node (lowercased)
- */
-function getTagName(node) {
-    if (!node)
-        return null;
-    return node.tag_name?.value.toLowerCase() || null;
-}
-/**
- * Gets the attribute name from an HTMLAttributeNode (lowercased)
- * Returns null if the attribute name contains dynamic content (ERB)
- */
-function getAttributeName(attributeNode, lowercase = true) {
-    if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
-        const nameNode = attributeNode.name;
-        const staticName = getStaticAttributeName(nameNode);
-        if (!lowercase)
-            return staticName;
-        return staticName ? staticName.toLowerCase() : null;
-    }
-    return null;
-}
-/**
- * Checks if an attribute has a dynamic (ERB-containing) name
- */
-function hasDynamicAttributeName(attributeNode) {
-    if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
-        const nameNode = attributeNode.name;
-        return hasDynamicAttributeName$1(nameNode);
-    }
-    return false;
-}
-/**
- * Gets the combined string representation of an attribute name (for debugging)
- * This includes both static content and ERB syntax
- */
-function getCombinedAttributeNameString(attributeNode) {
-    if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
-        const nameNode = attributeNode.name;
-        return getCombinedAttributeName(nameNode);
-    }
-    return "";
-}
-/**
- * Checks if an attribute value contains only static content (no ERB)
- */
-function hasStaticAttributeValue(attributeNode) {
-    const valueNode = attributeNode.value;
-    if (!valueNode?.children)
-        return false;
-    return valueNode.children.every(child => child.type === "AST_LITERAL_NODE");
-}
-/**
- * Checks if an attribute value contains dynamic content (ERB)
- */
-function hasDynamicAttributeValue(attributeNode) {
-    const valueNode = attributeNode.value;
-    if (!valueNode?.children)
-        return false;
-    return valueNode.children.some(child => child.type === "AST_ERB_CONTENT_NODE");
-}
-/**
- * Gets the static string value of an attribute (returns null if it contains ERB)
- */
-function getStaticAttributeValue(attributeNode) {
-    if (!hasStaticAttributeValue(attributeNode))
-        return null;
-    const valueNode = attributeNode.value;
-    const result = valueNode.children
-        ?.filter(child => child.type === "AST_LITERAL_NODE")
-        .map(child => child.content)
-        .join("") || "";
-    return result;
-}
-/**
- * Gets the value nodes array for dynamic inspection
- */
-function getAttributeValueNodes(attributeNode) {
-    const valueNode = attributeNode.value;
-    return valueNode?.children || [];
-}
-/**
- * Checks if an attribute value contains any static content (for validation purposes)
- */
-function hasStaticAttributeValueContent(attributeNode) {
-    const valueNodes = getAttributeValueNodes(attributeNode);
-    return hasStaticContent(valueNodes);
-}
-/**
- * Gets the static content of an attribute value (all literal parts combined)
- * Returns the concatenated literal content, or null if no literal nodes exist
- */
-function getStaticAttributeValueContent(attributeNode) {
-    const valueNodes = getAttributeValueNodes(attributeNode);
-    return getStaticContentFromNodes(valueNodes);
-}
-/**
- * Gets the attribute value content from an HTMLAttributeValueNode
- */
-function getAttributeValue(attributeNode) {
-    const valueNode = attributeNode.value;
-    if (valueNode === null)
-        return null;
-    if (valueNode.type !== "AST_HTML_ATTRIBUTE_VALUE_NODE" || !valueNode.children?.length) {
-        return null;
-    }
-    let result = "";
-    for (const child of valueNode.children) {
-        switch (child.type) {
-            case "AST_ERB_CONTENT_NODE": {
-                const erbNode = child;
-                if (erbNode.content) {
-                    result += `${erbNode.tag_opening?.value}${erbNode.content.value}${erbNode.tag_closing?.value}`;
-                }
-                break;
-            }
-            case "AST_LITERAL_NODE": {
-                result += child.content;
-                break;
-            }
-        }
-    }
-    return result;
-}
-/**
- * Checks if an attribute has a value
- */
-function hasAttributeValue(attributeNode) {
-    return attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE";
-}
-/**
- * Gets the quote type used for an attribute value
- */
-function getAttributeValueQuoteType(nodeOrAttribute) {
-    let valueNode;
-    if (nodeOrAttribute.type === "AST_HTML_ATTRIBUTE_NODE") {
-        const attributeNode = nodeOrAttribute;
-        if (attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
-            valueNode = attributeNode.value;
-        }
-    }
-    else if (nodeOrAttribute.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
-        valueNode = nodeOrAttribute;
-    }
-    if (valueNode) {
-        if (valueNode.quoted && valueNode.open_quote) {
-            return valueNode.open_quote.value === '"' ? "double" : "single";
-        }
-        return "none";
-    }
-    return null;
-}
-/**
- * Finds an attribute by name in a list of attributes
- */
-function findAttributeByName(attributes, attributeName) {
-    for (const child of attributes) {
-        if (child.type === "AST_HTML_ATTRIBUTE_NODE") {
-            const attributeNode = child;
-            const name = getAttributeName(attributeNode);
-            if (name === attributeName.toLowerCase()) {
-                return attributeNode;
-            }
-        }
-    }
-    return null;
-}
-/**
- * Checks if a tag has a specific attribute
- */
-function hasAttribute(node, attributeName) {
-    if (!node)
-        return false;
-    return getAttribute(node, attributeName) !== null;
-}
-/**
- * Checks if a tag has a specific attribute
- */
-function getAttribute(node, attributeName) {
-    const attributes = getAttributes(node);
-    return findAttributeByName(attributes, attributeName);
-}
-/**
- * Common HTML element categorization
+ * Common HTML element categorization
  */
 const HTML_INLINE_ELEMENTS = new Set([
     "a", "abbr", "acronym", "b", "bdo", "big", "br", "button", "cite", "code",
@@ -1098,6 +1250,25 @@ const VALID_ARIA_ROLES = new Set([
     "treegrid", "treeitem",
     "log", "marquee"
 ]);
+/**
+ * Abstract ARIA roles used to support the WAI-ARIA Roles Model.
+ * Authors MUST NOT use abstract roles in content.
+ * @see https://www.w3.org/TR/wai-aria-1.0/roles#abstract_roles
+ */
+const ABSTRACT_ARIA_ROLES = new Set([
+    "command",
+    "composite",
+    "input",
+    "landmark",
+    "range",
+    "roletype",
+    "section",
+    "sectionhead",
+    "select",
+    "structure",
+    "widget",
+    "window"
+]);
 const ARIA_ATTRIBUTES = new Set([
     'aria-activedescendant',
     'aria-atomic',
@@ -1205,7 +1376,7 @@ class AttributeVisitorMixin extends BaseRuleVisitor {
         forEachAttribute(node, (attributeNode) => {
             const staticAttributeName = getAttributeName(attributeNode);
             const originalAttributeName = getAttributeName(attributeNode, false) || "";
-            const isDynamicName = hasDynamicAttributeName(attributeNode);
+            const isDynamicName = hasDynamicAttributeNameOnAttribute(attributeNode);
             const staticAttributeValue = getStaticAttributeValue(attributeNode);
             const valueNodes = getAttributeValueNodes(attributeNode);
             const hasOutputERB = hasERBOutput(valueNodes);
@@ -1267,27 +1438,6 @@ class AttributeVisitorMixin extends BaseRuleVisitor {
         // Default implementation does nothing
     }
 }
-/**
- * Checks if an attribute value is quoted
- */
-function isAttributeValueQuoted(attributeNode) {
-    if (attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
-        const valueNode = attributeNode.value;
-        return !!valueNode.quoted;
-    }
-    return false;
-}
-/**
- * Iterates over all attributes of a tag node, calling the callback for each attribute
- */
-function forEachAttribute(node, callback) {
-    const attributes = getAttributes(node);
-    for (const child of attributes) {
-        if (child.type === "AST_HTML_ATTRIBUTE_NODE") {
-            callback(child);
-        }
-    }
-}
 /**
  * Base lexer visitor class that provides common functionality for lexer-based rule visitors
  */
@@ -1303,7 +1453,7 @@ class BaseLexerRuleVisitor {
      * Helper method to create an unbound lint offense (without severity).
      * The Linter will bind severity based on the rule's config.
      */
-    createOffense(message, location, autofixContext) {
+    createOffense(message, location, autofixContext, severity) {
         return {
             rule: this.ruleName,
             code: this.ruleName,
@@ -1311,13 +1461,14 @@ class BaseLexerRuleVisitor {
             message,
             location,
             autofixContext,
+            severity,
         };
     }
     /**
      * Helper method to add an offense to the offenses array
      */
-    addOffense(message, location, autofixContext) {
-        this.offenses.push(this.createOffense(message, location, autofixContext));
+    addOffense(message, location, autofixContext, severity) {
+        this.offenses.push(this.createOffense(message, location, autofixContext, severity));
     }
     /**
      * Main entry point for lexer rule visitors
@@ -1358,7 +1509,7 @@ class BaseSourceRuleVisitor {
      * Helper method to create an unbound lint offense (without severity).
      * The Linter will bind severity based on the rule's config.
      */
-    createOffense(message, location, autofixContext) {
+    createOffense(message, location, autofixContext, severity) {
         return {
             rule: this.ruleName,
             code: this.ruleName,
@@ -1366,13 +1517,14 @@ class BaseSourceRuleVisitor {
             message,
             location,
             autofixContext,
+            severity,
         };
     }
     /**
      * Helper method to add an offense to the offenses array
      */
-    addOffense(message, location, autofixContext) {
-        this.offenses.push(this.createOffense(message, location, autofixContext));
+    addOffense(message, location, autofixContext, severity) {
+        this.offenses.push(this.createOffense(message, location, autofixContext, severity));
     }
     /**
      * Main entry point for source rule visitors
@@ -1570,6 +1722,157 @@ function isHeadTag(tagName) {
         !isHtmlOnlyTag(tag) &&
         (isHeadOnlyTag(tag) || isHeadAndBodyTag(tag)));
 }
+/**
+ * Converts a character offset in a source string to a Position (line, column).
+ * Lines are 1-based, columns are 0-based.
+ */
+function positionFromOffset(source, offset) {
+    let line = 1;
+    let column = 0;
+    let currentOffset = 0;
+    for (let i = 0; i < source.length && currentOffset < offset; i++) {
+        const char = source[i];
+        currentOffset++;
+        if (char === "\n") {
+            line++;
+            column = 0;
+        }
+        else {
+            column++;
+        }
+    }
+    return new Position(line, column);
+}
+/**
+ * Creates a Location from a source string, a start offset, and a length.
+ */
+function locationFromOffset(source, startOffset, length) {
+    const start = positionFromOffset(source, startOffset);
+    const end = positionFromOffset(source, startOffset + length);
+    return Location.from(start.line, start.column, end.line, end.column);
+}
+/**
+ * Checks if a position (line, column) is within a node's location range.
+ * @param node - The node to check
+ * @param line - Line number (1-based)
+ * @param column - Column number (0-based)
+ * @returns true if the position is within the node's location
+ */
+function isPositionInNode(node, line, column) {
+    if (!node.location)
+        return false;
+    const { start, end } = node.location;
+    if (line < start.line)
+        return false;
+    if (line === start.line && column < start.column)
+        return false;
+    if (line > end.line)
+        return false;
+    if (line === end.line && column >= end.column)
+        return false;
+    return true;
+}
+/**
+ * Finds a node in the AST that contains a specific position.
+ * Returns the deepest (most specific) node that matches the position and optional predicate.
+ *
+ * @param root - The root node to search from
+ * @param line - Line number (1-based)
+ * @param column - Column number (0-based)
+ * @param predicate - Optional predicate function to filter nodes
+ * @returns The matching node or null if not found
+ */
+function findNodeAtPosition(root, line, column, predicate) {
+    let bestMatch = null;
+    const visited = new Set();
+    function search(node) {
+        if (!node || visited.has(node))
+            return;
+        visited.add(node);
+        if (isPositionInNode(node, line, column)) {
+            if (!predicate || predicate(node)) {
+                if (!bestMatch || isMoreSpecific(node, bestMatch)) {
+                    bestMatch = node;
+                }
+            }
+        }
+        const nodeAny = node;
+        if (typeof nodeAny.compactChildNodes === 'function') {
+            for (const child of nodeAny.compactChildNodes()) {
+                search(child);
+            }
+        }
+        else {
+            if (nodeAny.children && Array.isArray(nodeAny.children)) {
+                for (const child of nodeAny.children) {
+                    if (child)
+                        search(child);
+                }
+            }
+            if (nodeAny.body && Array.isArray(nodeAny.body)) {
+                for (const child of nodeAny.body) {
+                    if (child)
+                        search(child);
+                }
+            }
+        }
+    }
+    function isMoreSpecific(nodeA, nodeB) {
+        if (!nodeA.location || !nodeB.location)
+            return false;
+        const aStart = nodeA.location.start;
+        const aEnd = nodeA.location.end;
+        const bStart = nodeB.location.start;
+        const bEnd = nodeB.location.end;
+        const startsAtOrAfter = aStart.line > bStart.line || (aStart.line === bStart.line && aStart.column >= bStart.column);
+        const endsAtOrBefore = aEnd.line < bEnd.line || (aEnd.line === bEnd.line && aEnd.column <= bEnd.column);
+        return startsAtOrAfter && endsAtOrBefore;
+    }
+    search(root);
+    return bestMatch;
+}
+
+class ActionViewNoSilentHelperVisitor extends BaseRuleVisitor {
+    visitHTMLElementNode(node) {
+        this.checkActionViewHelper(node);
+        super.visitHTMLElementNode(node);
+    }
+    checkActionViewHelper(node) {
+        if (!node.element_source || node.element_source === "HTML")
+            return;
+        if (!isERBOpenTagNode(node.open_tag))
+            return;
+        if (isERBOutputNode(node.open_tag))
+            return;
+        const tagOpening = node.open_tag.tag_opening?.value;
+        if (!tagOpening)
+            return;
+        const helperName = node.element_source.includes("#")
+            ? node.element_source.split("#").pop()
+            : node.element_source;
+        this.addOffense(`Avoid using \`${tagOpening} %>\` with \`${helperName}\`. Use \`<%= %>\` to ensure the helper's output is rendered.`, node.open_tag.location);
+    }
+}
+class ActionViewNoSilentHelperRule extends ParserRule {
+    static ruleName = "actionview-no-silent-helper";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    get parserOptions() {
+        return {
+            track_whitespace: true,
+            action_view_helpers: true,
+        };
+    }
+    check(result, context) {
+        const visitor = new ActionViewNoSilentHelperVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
 
 class ERBCommentSyntaxVisitor extends BaseRuleVisitor {
     visitERBContentNode(node) {
@@ -1587,7 +1890,7 @@ class ERBCommentSyntaxVisitor extends BaseRuleVisitor {
 }
 class ERBCommentSyntax extends ParserRule {
     static autocorrectable = true;
-    name = "erb-comment-syntax";
+    static ruleName = "erb-comment-syntax";
     get defaultConfig() {
         return {
             enabled: true,
@@ -1595,7 +1898,7 @@ class ERBCommentSyntax extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new ERBCommentSyntaxVisitor(this.name, context);
+        const visitor = new ERBCommentSyntaxVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -1651,7 +1954,7 @@ class ERBNoCaseNodeChildrenVisitor extends BaseRuleVisitor {
     }
 }
 class ERBNoCaseNodeChildrenRule extends ParserRule {
-    name = "erb-no-case-node-children";
+    static ruleName = "erb-no-case-node-children";
     get defaultConfig() {
         return {
             enabled: true,
@@ -1659,27 +1962,132 @@ class ERBNoCaseNodeChildrenRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new ERBNoCaseNodeChildrenVisitor(this.name, context);
+        const visitor = new ERBNoCaseNodeChildrenVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
-class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
-    visitERBContentNode(node) {
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const dedent = createDedent({});
+function createDedent(options) {
+  dedent.withOptions = newOptions => createDedent(_objectSpread(_objectSpread({}, options), newOptions));
+  return dedent;
+  function dedent(strings, ...values) {
+    const raw = typeof strings === "string" ? [strings] : strings.raw;
+    const {
+      alignValues = false,
+      escapeSpecialCharacters = Array.isArray(strings),
+      trimWhitespace = true
+    } = options;
+
+    // first, perform interpolation
+    let result = "";
+    for (let i = 0; i < raw.length; i++) {
+      let next = raw[i];
+      if (escapeSpecialCharacters) {
+        // handle escaped newlines, backticks, and interpolation characters
+        next = next.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{");
+      }
+      result += next;
+      if (i < values.length) {
+        const value = alignValues ? alignValue(values[i], result) : values[i];
+
+        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+        result += value;
+      }
+    }
+
+    // now strip indentation
+    const lines = result.split("\n");
+    let mindent = null;
+    for (const l of lines) {
+      const m = l.match(/^(\s+)\S+/);
+      if (m) {
+        const indent = m[1].length;
+        if (!mindent) {
+          // this is the first indented line
+          mindent = indent;
+        } else {
+          mindent = Math.min(mindent, indent);
+        }
+      }
+    }
+    if (mindent !== null) {
+      const m = mindent; // appease TypeScript
+      result = lines
+      // https://github.com/typescript-eslint/typescript-eslint/issues/7140
+      // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
+      .map(l => l[0] === " " || l[0] === "\t" ? l.slice(m) : l).join("\n");
+    }
+
+    // dedent eats leading and trailing whitespace too
+    if (trimWhitespace) {
+      result = result.trim();
+    }
+
+    // handle escaped newlines at the end to ensure they don't get stripped too
+    if (escapeSpecialCharacters) {
+      result = result.replace(/\\n/g, "\n");
+    }
+
+    // Workaround for Bun issue with Unicode characters
+    // https://github.com/oven-sh/bun/issues/8745
+    if (typeof Bun !== "undefined") {
+      result = result.replace(
+      // Matches e.g. \\u{1f60a} or \\u5F1F
+      /\\u(?:\{([\da-fA-F]{1,6})\}|([\da-fA-F]{4}))/g, (_, braced, unbraced) => {
+        var _ref;
+        const hex = (_ref = braced !== null && braced !== void 0 ? braced : unbraced) !== null && _ref !== void 0 ? _ref : "";
+        return String.fromCodePoint(parseInt(hex, 16));
+      });
+    }
+    return result;
+  }
+}
+
+/**
+ * Adjusts the indentation of a multi-line interpolated value to match the current line.
+ */
+function alignValue(value, precedingText) {
+  if (typeof value !== "string" || !value.includes("\n")) {
+    return value;
+  }
+  const currentLine = precedingText.slice(precedingText.lastIndexOf("\n") + 1);
+  const indentMatch = currentLine.match(/^(\s+)/);
+  if (indentMatch) {
+    const indent = indentMatch[1];
+    return value.replace(/\n/g, `\n${indent}`);
+  }
+  return value;
+}
+
+class ERBNoConditionalHTMLElementRuleVisitor extends BaseRuleVisitor {
+    visitHTMLConditionalElementNode(node) {
+        const tagName = node.tag_name?.value || "element";
+        const condition = node.condition || "condition";
+        const suggestion = dedent `
+      Consider using a \`capture\` block instead:
+
+        <% content = capture do %>
+          ... your content here ...
+        <% end %>
+
+        <%= ${condition} ? content_tag(:${tagName}, content) : content %>
+    `;
+        this.addOffense(dedent `
+        Avoid opening and closing \`<${tagName}>\` tags in separate conditional blocks with the same condition. \
+        This pattern is difficult to read and maintain. ${suggestion}
+      `, node.location);
         this.visitChildNodes(node);
-        const { content, tag_closing } = node;
-        if (!content)
-            return;
-        if (tag_closing?.value === "")
-            return;
-        if (content.value.trim().length > 0)
-            return;
-        this.addOffense("ERB tag should not be empty. Remove empty ERB tags or add content.", node.location);
     }
 }
-class ERBNoEmptyTagsRule extends ParserRule {
-    name = "erb-no-empty-tags";
+class ERBNoConditionalHTMLElementRule extends ParserRule {
+    static ruleName = "erb-no-conditional-html-element";
     get defaultConfig() {
         return {
             enabled: true,
@@ -1687,37 +2095,311 @@ class ERBNoEmptyTagsRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new ERBNoEmptyTagsVisitor(this.name, context);
+        const visitor = new ERBNoConditionalHTMLElementRuleVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
-function positionFromOffset(source, offset) {
-    let line = 1;
-    let column = 0;
-    let currentOffset = 0;
-    for (let i = 0; i < source.length && currentOffset < offset; i++) {
-        const char = source[i];
-        currentOffset++;
-        if (char === "\n") {
-            line++;
-            column = 0;
+class ERBNoConditionalOpenTagRuleVisitor extends BaseRuleVisitor {
+    visitHTMLConditionalOpenTagNode(node) {
+        const tagName = node.tag_name?.value || "element";
+        this.addOffense(`Avoid using ERB conditionals to split the open and closing tag of \`<${tagName}>\` element.`, node.location);
+        this.visitChildNodes(node);
+    }
+}
+class ERBNoConditionalOpenTagRule extends ParserRule {
+    static ruleName = "erb-no-conditional-open-tag";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoConditionalOpenTagRuleVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+function getSignificantNodes(statements) {
+    return statements.filter(node => !isPureWhitespaceNode(node));
+}
+function allEquivalentElements(nodes) {
+    if (nodes.length < 2)
+        return false;
+    if (!nodes.every(node => isHTMLElementNode(node)))
+        return false;
+    const first = nodes[0];
+    return nodes.slice(1).every(node => isEquivalentElement(first, node));
+}
+function collectBranchesFromIf(node) {
+    const branches = [];
+    let current = node.subsequent;
+    branches.push(node.statements);
+    while (current) {
+        if (isERBElseNode(current)) {
+            branches.push(current.statements);
+            return branches;
+        }
+        if (isERBIfNode(current)) {
+            branches.push(current.statements);
+            current = current.subsequent;
         }
         else {
-            column++;
+            break;
         }
     }
-    return new Position(line, column);
+    return null;
 }
-class ERBNoExtraNewLineVisitor extends BaseSourceRuleVisitor {
-    visitSource(source) {
-        if (source.length === 0)
+function collectBranchesFromUnless(node) {
+    if (!node.else_clause)
+        return null;
+    return [node.statements, node.else_clause.statements];
+}
+function collectBranchesFromCase(node) {
+    if (!node.else_clause)
+        return null;
+    const branches = [];
+    for (const condition of node.conditions) {
+        if (isERBWhenNode(condition)) {
+            branches.push(condition.statements);
+        }
+    }
+    branches.push(node.else_clause.statements);
+    return branches;
+}
+function collectBranches(node) {
+    if (isERBIfNode(node))
+        return collectBranchesFromIf(node);
+    if (isERBUnlessNode(node))
+        return collectBranchesFromUnless(node);
+    if (isERBCaseNode(node))
+        return collectBranchesFromCase(node);
+    return null;
+}
+function findCommonPrefixCount(branches, minLength) {
+    let count = 0;
+    for (let index = 0; index < minLength; index++) {
+        const nodesAtIndex = branches.map(branch => branch[index]);
+        if (allEquivalentElements(nodesAtIndex)) {
+            count++;
+        }
+        else {
+            break;
+        }
+    }
+    return count;
+}
+function findCommonSuffixCount(branches, minLength, prefixCount) {
+    let count = 0;
+    for (let offset = 0; offset < minLength - prefixCount; offset++) {
+        const nodesAtOffset = branches.map(branch => branch[branch.length - 1 - offset]);
+        if (allEquivalentElements(nodesAtOffset)) {
+            count++;
+        }
+        else {
+            break;
+        }
+    }
+    return count;
+}
+function createWrapper(template, body) {
+    return new HTMLElementNode({
+        type: "AST_HTML_ELEMENT_NODE",
+        open_tag: template.open_tag,
+        tag_name: template.tag_name,
+        body,
+        close_tag: template.close_tag,
+        is_void: template.is_void,
+        element_source: template.element_source,
+        location: Location.zero,
+        errors: [],
+    });
+}
+class ERBNoDuplicateBranchElementsVisitor extends BaseRuleVisitor {
+    processedIfNodes = new Set();
+    visitERBIfNode(node) {
+        if (this.processedIfNodes.has(node)) {
+            this.visitChildNodes(node);
             return;
-        const regex = /\n{4,}/g;
-        let match;
-        while ((match = regex.exec(source)) !== null) {
-            const startOffset = match.index + 3;
+        }
+        this.checkConditionalNode(node);
+        this.visitChildNodes(node);
+    }
+    visitERBUnlessNode(node) {
+        this.checkConditionalNode(node);
+        this.visitChildNodes(node);
+    }
+    visitERBCaseNode(node) {
+        this.checkConditionalNode(node);
+        this.visitChildNodes(node);
+    }
+    checkConditionalNode(node) {
+        const branches = collectBranches(node);
+        if (!branches)
+            return;
+        if (isERBIfNode(node)) {
+            this.markSubsequentIfNodesAsProcessed(node);
+        }
+        const state = { isFirstOffense: true };
+        this.checkBranches(branches, node, state);
+    }
+    markSubsequentIfNodesAsProcessed(node) {
+        let current = node.subsequent;
+        while (current) {
+            if (isERBIfNode(current)) {
+                this.processedIfNodes.add(current);
+                current = current.subsequent;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    checkBranches(branches, conditionalNode, state) {
+        const significantBranches = branches.map(getSignificantNodes);
+        if (significantBranches.some(branch => branch.length === 0))
+            return;
+        const minLength = Math.min(...significantBranches.map(branch => branch.length));
+        const prefixCount = findCommonPrefixCount(significantBranches, minLength);
+        const suffixCount = findCommonSuffixCount(significantBranches, minLength, prefixCount);
+        for (let index = 0; index < prefixCount; index++) {
+            const elements = significantBranches.map(branch => branch[index]);
+            this.reportAndRecurse(elements, conditionalNode, state);
+        }
+        for (let offset = 0; offset < suffixCount; offset++) {
+            const elements = significantBranches.map(branch => branch[branch.length - 1 - offset]);
+            this.reportAndRecurse(elements, conditionalNode, state);
+        }
+    }
+    reportAndRecurse(elements, conditionalNode, state) {
+        const bodies = elements.map(element => element.body);
+        const bodiesMatch = elements.every(element => IdentityPrinter.print(element) === IdentityPrinter.print(elements[0]));
+        for (const element of elements) {
+            const printed = IdentityPrinter.print(element.open_tag);
+            const autofixContext = state.isFirstOffense
+                ? { node: conditionalNode }
+                : undefined;
+            this.addOffense(`The \`${printed}\` element is duplicated across all branches of this conditional and can be moved outside.`, bodiesMatch ? element.location : (element?.open_tag?.location || element.location), autofixContext);
+            state.isFirstOffense = false;
+        }
+        if (!bodiesMatch && bodies.every(body => body.length > 0)) {
+            this.checkBranches(bodies, conditionalNode, state);
+        }
+    }
+}
+class ERBNoDuplicateBranchElementsRule extends ParserRule {
+    static ruleName = "erb-no-duplicate-branch-elements";
+    static autocorrectable = true;
+    static reindentAfterAutofix = true;
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "warning",
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoDuplicateBranchElementsVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+    autofix(offense, result) {
+        if (!offense.autofixContext)
+            return null;
+        const conditionalNode = offense.autofixContext.node;
+        const branches = collectBranches(conditionalNode);
+        if (!branches)
+            return null;
+        const significantBranches = branches.map(getSignificantNodes);
+        if (significantBranches.some(branch => branch.length === 0))
+            return null;
+        const minLength = Math.min(...significantBranches.map(branch => branch.length));
+        const prefixCount = findCommonPrefixCount(significantBranches, minLength);
+        const suffixCount = findCommonSuffixCount(significantBranches, minLength, prefixCount);
+        if (prefixCount === 0 && suffixCount === 0)
+            return null;
+        const parentInfo = findParentArray(result.value, conditionalNode);
+        if (!parentInfo)
+            return null;
+        let { array: parentArray, index: conditionalIndex } = parentInfo;
+        let hasWrapped = false;
+        const hoistElement = (elements, position) => {
+            const bodiesMatch = elements.every(element => IdentityPrinter.print(element) === IdentityPrinter.print(elements[0]));
+            if (bodiesMatch) {
+                for (let i = 0; i < branches.length; i++) {
+                    removeNodeFromArray(branches[i], elements[i]);
+                }
+                if (position === "before") {
+                    parentArray.splice(conditionalIndex, 0, elements[0]);
+                    conditionalIndex++;
+                }
+                else {
+                    parentArray.splice(conditionalIndex + 1, 0, elements[0]);
+                }
+            }
+            else {
+                if (hasWrapped)
+                    return;
+                for (let i = 0; i < branches.length; i++) {
+                    replaceNodeWithBody(branches[i], elements[i]);
+                }
+                const wrapper = createWrapper(elements[0], [createLiteral("\n"), conditionalNode, createLiteral("\n")]);
+                parentArray[conditionalIndex] = wrapper;
+                parentArray = wrapper.body;
+                conditionalIndex = 1;
+                hasWrapped = true;
+            }
+        };
+        for (let index = 0; index < prefixCount; index++) {
+            const elements = significantBranches.map(branch => branch[index]);
+            hoistElement(elements, "before");
+        }
+        for (let offset = 0; offset < suffixCount; offset++) {
+            const elements = significantBranches.map(branch => branch[branch.length - 1 - offset]);
+            hoistElement(elements, "after");
+        }
+        return result;
+    }
+}
+
+class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
+    visitERBContentNode(node) {
+        this.visitChildNodes(node);
+        const { content, tag_closing } = node;
+        if (!content)
+            return;
+        if (tag_closing?.value === "")
+            return;
+        if (content.value.trim().length > 0)
+            return;
+        this.addOffense("ERB tag should not be empty. Remove empty ERB tags or add content.", node.location);
+    }
+}
+class ERBNoEmptyTagsRule extends ParserRule {
+    static ruleName = "erb-no-empty-tags";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoEmptyTagsVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class ERBNoExtraNewLineVisitor extends BaseSourceRuleVisitor {
+    visitSource(source) {
+        if (source.length === 0)
+            return;
+        const regex = /\n{4,}/g;
+        let match;
+        while ((match = regex.exec(source)) !== null) {
+            const startOffset = match.index + 3;
             const endOffset = match.index + match[0].length;
             const start = positionFromOffset(source, startOffset);
             const end = positionFromOffset(source, endOffset);
@@ -1731,161 +2413,820 @@ class ERBNoExtraNewLineVisitor extends BaseSourceRuleVisitor {
         }
     }
 }
-class ERBNoExtraNewLineRule extends SourceRule {
-    static autocorrectable = true;
-    name = "erb-no-extra-newline";
+class ERBNoExtraNewLineRule extends SourceRule {
+    static autocorrectable = true;
+    static ruleName = "erb-no-extra-newline";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(source, context) {
+        const visitor = new ERBNoExtraNewLineVisitor(this.ruleName, context);
+        visitor.visit(source);
+        return visitor.offenses;
+    }
+    autofix(offense, source, _context) {
+        if (!offense.autofixContext)
+            return null;
+        const { startOffset, endOffset } = offense.autofixContext;
+        const before = source.substring(0, startOffset);
+        const after = source.substring(endOffset);
+        return before + after;
+    }
+}
+
+class ERBNoExtraWhitespaceInsideTagsVisitor extends BaseRuleVisitor {
+    visitERBNode(node) {
+        const openTag = node.tag_opening;
+        const closeTag = node.tag_closing;
+        const { value } = node.content ?? {};
+        if (!openTag || !closeTag || !value)
+            return;
+        if (this.hasExtraLeadingWhitespace(value)) {
+            this.reportWhitespace(node, openTag, closeTag, value, "start", 0, `Remove extra whitespace after \`${openTag.value}\`.`, "after-open");
+        }
+        if (openTag.value === "<%#") {
+            const prefix = this.getCommentedTagPrefix(value);
+            if (prefix) {
+                const afterPrefix = value.substring(prefix.length);
+                const tag = `<%#${prefix}`;
+                const hasExtraWhitespace = afterPrefix.match(/^\s{2,}/) && !afterPrefix.startsWith("  \n") && !afterPrefix.startsWith("\n");
+                if (hasExtraWhitespace) {
+                    this.reportWhitespace(node, openTag, closeTag, value, "start", prefix.length, `Remove extra whitespace after \`${tag}\`. This looks like a temporarily commented ERB tag.`, "after-comment-equals", "info");
+                }
+                else {
+                    this.addOffense(`\`${tag}\` looks like a temporarily commented ERB tag.`, openTag.location, { node, openTag, closeTag, content: value, fixType: "after-comment-equals", unsafe: true }, "info");
+                }
+            }
+        }
+        if (this.hasExtraTrailingWhitespace(value)) {
+            this.reportWhitespace(node, openTag, closeTag, value, "end", 0, `Remove extra whitespace before \`${closeTag.value}\`.`, "before-close");
+        }
+    }
+    getCommentedTagPrefix(content) {
+        if (content.startsWith("graphql"))
+            return "graphql";
+        if (content.startsWith("%="))
+            return "%=";
+        if (content.startsWith("=="))
+            return "==";
+        if (content.startsWith("%"))
+            return "%";
+        if (content.startsWith("="))
+            return "=";
+        if (content.startsWith("-"))
+            return "-";
+        return null;
+    }
+    hasExtraLeadingWhitespace(content) {
+        return content.startsWith("  ") && !content.startsWith("  \n");
+    }
+    hasExtraTrailingWhitespace(content) {
+        return !content.includes("\n") && /\s{2,}$/.test(content);
+    }
+    getWhitespaceLocation(node, content, position, offset = 0) {
+        const contentLocation = node.content.location;
+        if (position === "start") {
+            const match = content.substring(offset).match(/^\s+/);
+            const length = match ? match[0].length : 0;
+            const startColumn = contentLocation.start.column + offset;
+            return Location.from(contentLocation.start.line, startColumn, contentLocation.start.line, startColumn + length);
+        }
+        else {
+            const match = content.match(/\s+$/);
+            const length = match ? match[0].length : 0;
+            return Location.from(contentLocation.end.line, contentLocation.end.column - length, contentLocation.end.line, contentLocation.end.column);
+        }
+    }
+    reportWhitespace(node, openTag, closeTag, content, position, offset, message, fixType, severity, unsafe) {
+        const location = this.getWhitespaceLocation(node, content, position, offset);
+        this.addOffense(message, location, {
+            node,
+            openTag,
+            closeTag,
+            content,
+            fixType,
+            unsafe,
+        }, severity);
+    }
+}
+class ERBNoExtraWhitespaceRule extends ParserRule {
+    static autocorrectable = true;
+    static ruleName = "erb-no-extra-whitespace-inside-tags";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoExtraWhitespaceInsideTagsVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+    autofix(offense, result, _context) {
+        if (!offense.autofixContext)
+            return null;
+        const { node, fixType } = offense.autofixContext;
+        if (!node.content)
+            return null;
+        const content = node.content.value;
+        switch (fixType) {
+            case "before-close":
+                node.content.value = content.replace(/\s{2,}$/, " ");
+                break;
+            case "after-open":
+                node.content.value = content.replace(/^\s{2,}/, " ");
+                break;
+            case "after-comment-equals": {
+                const prefix = content.startsWith("graphql") ? "graphql" : content.startsWith("%=") ? "%=" : content.startsWith("==") ? "==" : content.startsWith("%") ? "%" : content.startsWith("=") ? "=" : content.startsWith("-") ? "-" : null;
+                if (prefix) {
+                    const afterPrefix = content.substring(prefix.length);
+                    node.content.value = prefix + " " + afterPrefix.replace(/^\s{2,}/, "");
+                }
+                break;
+            }
+            default:
+                return null;
+        }
+        return result;
+    }
+}
+
+class ERBNoInlineCaseConditionsVisitor extends BaseRuleVisitor {
+    visitERBCaseNode(node) {
+        this.checkConditions(node, "when");
+        this.visitChildNodes(node);
+    }
+    visitERBCaseMatchNode(node) {
+        this.checkConditions(node, "in");
+        this.visitChildNodes(node);
+    }
+    checkConditions(node, type) {
+        if (!node.conditions || node.conditions.length === 0)
+            return;
+        for (const condition of node.conditions) {
+            if (condition.tag_opening === null) {
+                this.addOffense(`A \`case\` statement with \`${type}\` conditions in a single ERB tag cannot be reliably parsed, compiled, and formatted. Use separate ERB tags for \`case\` and its conditions (e.g., \`<% case x %>\` followed by \`<% ${type} y %>\`).`, node.location);
+                break;
+            }
+        }
+    }
+}
+class ERBNoInlineCaseConditionsRule extends ParserRule {
+    static ruleName = "erb-no-inline-case-conditions";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "warning",
+        };
+    }
+    get parserOptions() {
+        return { strict: false };
+    }
+    check(result, context) {
+        const visitor = new ERBNoInlineCaseConditionsVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+/**
+ * File path and naming utilities for linter rules
+ */
+/**
+ * Extracts the basename (filename) from a file path
+ * Works with both forward slashes and backslashes
+ */
+function getBasename(filePath) {
+    const lastSlash = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+    return lastSlash === -1 ? filePath : filePath.slice(lastSlash + 1);
+}
+/**
+ * Checks if a file is a Rails partial (filename starts with `_`)
+ * Returns null if fileName is undefined (unknown context)
+ */
+function isPartialFile(fileName) {
+    if (!fileName)
+        return null;
+    return getBasename(fileName).startsWith("_");
+}
+
+class InstanceVariableCollector extends PrismVisitor {
+    instanceVariables = [];
+    visitInstanceVariableReadNode(node) {
+        this.collect(node, "read");
+    }
+    visitInstanceVariableWriteNode(node) {
+        this.collect(node, "write");
+    }
+    visitInstanceVariableAndWriteNode(node) {
+        this.collect(node, "write");
+    }
+    visitInstanceVariableOrWriteNode(node) {
+        this.collect(node, "write");
+    }
+    visitInstanceVariableOperatorWriteNode(node) {
+        this.collect(node, "write");
+    }
+    visitInstanceVariableTargetNode(node) {
+        this.collect(node, "write");
+    }
+    collect(node, usage) {
+        this.instanceVariables.push({
+            name: node.name,
+            usage,
+            startOffset: node.location.startOffset,
+            length: node.location.length
+        });
+    }
+}
+class ERBNoInstanceVariablesInPartialsRule extends ParserRule {
+    static ruleName = "erb-no-instance-variables-in-partials";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error",
+        };
+    }
+    get parserOptions() {
+        return {
+            track_whitespace: true,
+            prism_program: true,
+        };
+    }
+    isEnabled(_result, context) {
+        return isPartialFile(context?.fileName) === true;
+    }
+    check(result, _context) {
+        const source = result.value.source;
+        const prismNode = result.value.prismNode;
+        if (!prismNode || !source)
+            return [];
+        const collector = new InstanceVariableCollector();
+        collector.visit(prismNode);
+        return collector.instanceVariables.map(ivar => {
+            const location = locationFromOffset(source, ivar.startOffset, ivar.length);
+            const message = ivar.usage === "read"
+                ? `Avoid using instance variables in partials. Pass \`${ivar.name}\` as a local variable instead.`
+                : `Avoid setting instance variables in partials. Use a local variable instead of \`${ivar.name}\`.`;
+            return this.createOffense(message, location);
+        });
+    }
+}
+
+function groupToString(group) {
+    return group.map(node => {
+        if (isLiteralNode(node)) {
+            return node.content;
+        }
+        return IdentityPrinter.print(node, { ignoreErrors: true });
+    }).join("");
+}
+class ERBNoInterpolatedClassNamesVisitor extends AttributeVisitorMixin {
+    checkStaticAttributeDynamicValue({ attributeName, valueNodes, attributeNode }) {
+        if (attributeName !== "class")
+            return;
+        const splitNodes = splitLiteralsAtWhitespace(valueNodes);
+        const groups = groupNodesByClass(splitNodes);
+        for (const group of groups) {
+            if (group.every(node => isPureWhitespaceNode(node)))
+                continue;
+            const isInterpolated = group.some(node => !isLiteralNode(node));
+            if (!isInterpolated)
+                continue;
+            const hasAttachedLiteral = group.some(node => isLiteralNode(node) && node.content.trim());
+            if (!hasAttachedLiteral)
+                continue;
+            const className = groupToString(group);
+            this.addOffense(`Avoid ERB interpolation inside class names: \`${className}\`. Use standalone ERB expressions that output complete class names instead.`, attributeNode.value.location);
+        }
+    }
+}
+class ERBNoInterpolatedClassNamesRule extends ParserRule {
+    static ruleName = "erb-no-interpolated-class-names";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "warning"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoInterpolatedClassNamesVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+const JAVASCRIPT_TAG_PATTERN = /\bjavascript_tag\b/;
+class ERBNoJavascriptTagHelperVisitor extends BaseRuleVisitor {
+    visitDocumentNode(node) {
+        for (const child of node.children || []) {
+            if (!isERBNode(child))
+                continue;
+            if (!isERBOutputNode(child))
+                continue;
+            const content = child.content?.value || "";
+            if (JAVASCRIPT_TAG_PATTERN.test(content)) {
+                this.addOffense("Avoid `javascript_tag`. Use inline `<script>` tags instead.", child.location);
+            }
+        }
+        super.visitDocumentNode(node);
+    }
+}
+class ERBNoJavascriptTagHelperRule extends ParserRule {
+    static ruleName = "erb-no-javascript-tag-helper";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "warning"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoJavascriptTagHelperVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
+    visitERBIfNode(node) {
+        this.checkOutputControlFlow(node);
+        this.visitChildNodes(node);
+    }
+    visitERBUnlessNode(node) {
+        this.checkOutputControlFlow(node);
+        this.visitChildNodes(node);
+    }
+    visitERBElseNode(node) {
+        this.checkOutputControlFlow(node);
+        this.visitChildNodes(node);
+    }
+    visitERBEndNode(node) {
+        this.checkOutputControlFlow(node);
+        this.visitChildNodes(node);
+    }
+    static CONTROL_BLOCK_NAMES = {
+        "AST_ERB_IF_NODE": "if",
+        "AST_ERB_ELSE_NODE": "else",
+        "AST_ERB_END_NODE": "end",
+        "AST_ERB_UNLESS_NODE": "unless"
+    };
+    checkOutputControlFlow(controlBlock) {
+        const openTag = controlBlock.tag_opening;
+        if (!openTag) {
+            return;
+        }
+        if (openTag.value === "<%=") {
+            const controlBlockType = ERBNoOutputControlFlowRuleVisitor.CONTROL_BLOCK_NAMES[controlBlock.type] || controlBlock.type;
+            this.addOffense(`Control flow statements like \`${controlBlockType}\` should not be used with output tags. Use \`<% ${controlBlockType} ... %>\` instead.`, openTag.location);
+        }
+    }
+}
+class ERBNoOutputControlFlowRule extends ParserRule {
+    static ruleName = "erb-no-output-control-flow";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoOutputControlFlowRuleVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class ERBNoOutputInAttributeNameVisitor extends BaseRuleVisitor {
+    visitHTMLAttributeNameNode(node) {
+        for (const child of node.children) {
+            if (!isERBNode(child))
+                continue;
+            if (!isERBOutputNode(child))
+                continue;
+            this.addOffense("Avoid ERB output in attribute names. Use static attribute names with dynamic values instead.", child.location);
+        }
+        super.visitHTMLAttributeNameNode(node);
+    }
+}
+class ERBNoOutputInAttributeNameRule extends ParserRule {
+    static ruleName = "erb-no-output-in-attribute-name";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoOutputInAttributeNameVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class ERBNoOutputInAttributePositionVisitor extends BaseRuleVisitor {
+    visitHTMLOpenTagNode(node) {
+        for (const child of node.children) {
+            if (!isERBNode(child))
+                continue;
+            if (!isERBOutputNode(child))
+                continue;
+            this.addOffense("Avoid `<%= %>` in attribute position. Use `<% if ... %>` with static attributes instead.", child.location);
+        }
+        super.visitHTMLOpenTagNode(node);
+    }
+}
+class ERBNoOutputInAttributePositionRule extends ParserRule {
+    static ruleName = "erb-no-output-in-attribute-position";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoOutputInAttributePositionVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class ERBNoRawOutputInAttributeValueVisitor extends AttributeVisitorMixin {
+    checkStaticAttributeDynamicValue({ valueNodes, attributeNode }) {
+        this.checkValueNodes(valueNodes);
+    }
+    checkDynamicAttributeDynamicValue({ valueNodes }) {
+        this.checkValueNodes(valueNodes);
+    }
+    checkValueNodes(nodes) {
+        for (const node of nodes) {
+            if (!isERBNode(node))
+                continue;
+            if (node.tag_opening?.value === "<%==") {
+                this.addOffense("Avoid `<%==` in attribute values. Use `<%= %>` instead to ensure proper HTML escaping.", node.location);
+            }
+        }
+    }
+}
+class ERBNoRawOutputInAttributeValueRule extends ParserRule {
+    static ruleName = "erb-no-raw-output-in-attribute-value";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoRawOutputInAttributeValueVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class ERBNoSilentTagInAttributeNameVisitor extends BaseRuleVisitor {
+    visitHTMLAttributeNameNode(node) {
+        const erbNodes = filterERBContentNodes(node.children);
+        const silentNodes = erbNodes.filter(this.isSilentERBTag);
+        for (const node of silentNodes) {
+            this.addOffense(`Remove silent ERB tag from HTML attribute name. Silent ERB tags (\`${node.tag_opening?.value}\`) do not output content and should not be used in attribute names.`, node.location);
+        }
+    }
+    // TODO: might be worth to extract
+    isSilentERBTag(node) {
+        const silentTags = ["<%", "<%-", "<%#"];
+        return silentTags.includes(node.tag_opening?.value || "");
+    }
+}
+class ERBNoSilentTagInAttributeNameRule extends ParserRule {
+    static ruleName = "erb-no-silent-tag-in-attribute-name";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoSilentTagInAttributeNameVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+const END_PATTERN = /^\s*end\b/;
+class ERBNoStatementInScriptVisitor extends BaseRuleVisitor {
+    visitHTMLElementNode(node) {
+        if (!isHTMLOpenTagNode(node.open_tag)) {
+            super.visitHTMLElementNode(node);
+            return;
+        }
+        if (getTagLocalName(node.open_tag) === "script") {
+            this.checkScriptElement(node);
+        }
+        super.visitHTMLElementNode(node);
+    }
+    checkScriptElement(node) {
+        if (!isHTMLOpenTagNode(node.open_tag))
+            return;
+        const typeAttribute = getAttribute(node.open_tag, "type");
+        const typeValue = typeAttribute ? getStaticAttributeValue(typeAttribute) : null;
+        if (typeValue === "text/html") {
+            return;
+        }
+        if (!node.body || node.body.length === 0) {
+            return;
+        }
+        this.checkNodesForStatements(node.body);
+    }
+    checkNodesForStatements(nodes) {
+        for (const child of nodes) {
+            if (!isERBNode(child))
+                continue;
+            if (isERBOutputNode(child))
+                continue;
+            if (isERBCommentNode(child))
+                continue;
+            const content = child.content?.value || "";
+            if (END_PATTERN.test(content))
+                continue;
+            this.addOffense("Avoid `<% %>` tags inside `<script>`. Use `<%= %>` to interpolate values into JavaScript.", child.location);
+        }
+    }
+}
+class ERBNoStatementInScriptRule extends ParserRule {
+    static ruleName = "erb-no-statement-in-script";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "warning"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoStatementInScriptVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class ERBNoThenInControlFlowVisitor extends BaseRuleVisitor {
+    visitERBIfNode(node) {
+        const content = node.content?.value?.trim() ?? "";
+        const keyword = content.startsWith("elsif") ? "elsif" : "if";
+        this.checkThenKeyword(keyword, node.then_keyword);
+        this.visitChildNodes(node);
+    }
+    visitERBUnlessNode(node) {
+        this.checkThenKeyword("unless", node.then_keyword);
+        this.visitChildNodes(node);
+    }
+    visitERBWhenNode(node) {
+        this.checkThenKeyword("when", node.then_keyword);
+        this.visitChildNodes(node);
+    }
+    visitERBInNode(node) {
+        this.checkThenKeyword("in", node.then_keyword);
+        this.visitChildNodes(node);
+    }
+    checkThenKeyword(keyword, thenKeyword) {
+        if (thenKeyword === null)
+            return;
+        this.addOffense(`Avoid using \`then\` in \`${keyword}\` expressions inside ERB templates. Use the multiline block form instead.`, thenKeyword);
+    }
+}
+class ERBNoThenInControlFlowRule extends ParserRule {
+    static ruleName = "erb-no-then-in-control-flow";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning",
         };
     }
-    check(source, context) {
-        const visitor = new ERBNoExtraNewLineVisitor(this.name, context);
-        visitor.visit(source);
-        return visitor.offenses;
+    get parserOptions() {
+        return { strict: true };
     }
-    autofix(offense, source, _context) {
-        if (!offense.autofixContext)
-            return null;
-        const { startOffset, endOffset } = offense.autofixContext;
-        const before = source.substring(0, startOffset);
-        const after = source.substring(endOffset);
-        return before + after;
+    check(result, context) {
+        const visitor = new ERBNoThenInControlFlowVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
     }
 }
 
-class ERBNoExtraWhitespaceInsideTagsVisitor extends BaseRuleVisitor {
-    visitERBNode(node) {
-        const openTag = node.tag_opening;
-        const closeTag = node.tag_closing;
-        const { value } = node.content ?? {};
-        if (!openTag || !closeTag || !value)
-            return;
-        if (this.hasExtraLeadingWhitespace(value)) {
-            this.reportWhitespace(node, openTag, closeTag, value, "start", 0, `Remove extra whitespace after \`${openTag.value}\`.`, "after-open");
-        }
-        if (openTag.value === "<%#" && value.startsWith("=") && value.length > 1) {
-            const afterEquals = value.substring(1);
-            if (afterEquals.match(/^\s{2,}/) && !afterEquals.startsWith("  \n") && !afterEquals.startsWith("\n")) {
-                this.reportWhitespace(node, openTag, closeTag, value, "start", 1, `Remove extra whitespace after \`<%#=\`.`, "after-comment-equals");
+const TRAILING_WHITESPACE = /[ \t\r\v\f\u00A0]+$/;
+const TRAILING_WHITESPACE_BEFORE_NEWLINE = /[ \t\r\v\f\u00A0]+(?=\n)/g;
+const ONLY_WHITESPACE = /^[ \t\r\v\f\u00A0]+$/;
+class SkipZoneCollector extends Visitor {
+    skipZones = [];
+    SKIP_TAGS = new Set(["pre", "textarea", "script", "style"]);
+    visitHTMLElementNode(node) {
+        if (isHTMLOpenTagNode(node.open_tag)) {
+            const tagName = getTagLocalName(node.open_tag);
+            if (tagName && this.SKIP_TAGS.has(tagName)) {
+                this.skipZones.push({
+                    startLine: node.location.start.line,
+                    startColumn: node.location.start.column,
+                    endLine: node.location.end.line,
+                    endColumn: node.location.end.column
+                });
+                return;
             }
         }
-        if (this.hasExtraTrailingWhitespace(value)) {
-            this.reportWhitespace(node, openTag, closeTag, value, "end", 0, `Remove extra whitespace before \`${closeTag.value}\`.`, "before-close");
-        }
-    }
-    hasExtraLeadingWhitespace(content) {
-        return content.startsWith("  ") && !content.startsWith("  \n");
-    }
-    hasExtraTrailingWhitespace(content) {
-        return !content.includes("\n") && /\s{2,}$/.test(content);
-    }
-    getWhitespaceLocation(node, content, position, offset = 0) {
-        const contentLocation = node.content.location;
-        if (position === "start") {
-            const match = content.substring(offset).match(/^\s+/);
-            const length = match ? match[0].length : 0;
-            const startColumn = contentLocation.start.column + offset;
-            return Location.from(contentLocation.start.line, startColumn, contentLocation.start.line, startColumn + length);
-        }
-        else {
-            const match = content.match(/\s+$/);
-            const length = match ? match[0].length : 0;
-            return Location.from(contentLocation.end.line, contentLocation.end.column - length, contentLocation.end.line, contentLocation.end.column);
-        }
+        super.visitHTMLElementNode(node);
     }
-    reportWhitespace(node, openTag, closeTag, content, position, offset, message, fixType) {
-        const location = this.getWhitespaceLocation(node, content, position, offset);
-        this.addOffense(message, location, {
-            node,
-            openTag,
-            closeTag,
-            content,
-            fixType
+    visitERBNode(node) {
+        if (!node.tag_opening)
+            return;
+        if (!node.tag_closing)
+            return;
+        this.skipZones.push({
+            startLine: node.tag_opening.location.start.line,
+            startColumn: node.tag_opening.location.start.column,
+            endLine: node.tag_closing.location.end.line,
+            endColumn: node.tag_closing.location.end.column
         });
     }
 }
-class ERBNoExtraWhitespaceRule extends ParserRule {
+class ERBNoTrailingWhitespaceRule extends ParserRule {
     static autocorrectable = true;
-    name = "erb-no-extra-whitespace-inside-tags";
+    static ruleName = "erb-no-trailing-whitespace";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "error",
         };
     }
-    check(result, context) {
-        const visitor = new ERBNoExtraWhitespaceInsideTagsVisitor(this.name, context);
-        visitor.visit(result.value);
-        return visitor.offenses;
+    check(result, _context) {
+        const offenses = [];
+        const lines = result.source.split("\n");
+        const candidates = this.findTrailingWhitespaceCandidates(lines);
+        if (candidates.length === 0)
+            return offenses;
+        const skipZones = this.collectSkipZones(result.value);
+        for (const candidate of candidates) {
+            if (!this.isInSkipZone(candidate, skipZones)) {
+                const location = Location.from(candidate.line, candidate.column, candidate.line, candidate.column + candidate.length);
+                const node = findNodeAtPosition(result.value, candidate.line, candidate.column, (n) => isHTMLTextNode(n) || isLiteralNode(n));
+                offenses.push({
+                    rule: this.ruleName,
+                    message: "Extra whitespace detected at end of line.",
+                    location,
+                    autofixContext: node ? { node } : undefined
+                });
+            }
+        }
+        return offenses;
+    }
+    findTrailingWhitespaceCandidates(lines) {
+        const candidates = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const match = line.match(TRAILING_WHITESPACE);
+            if (match && match.index !== undefined) {
+                candidates.push({
+                    line: i + 1,
+                    column: match.index,
+                    length: match[0].length
+                });
+            }
+        }
+        return candidates;
+    }
+    collectSkipZones(root) {
+        const collector = new SkipZoneCollector();
+        collector.visit(root);
+        return collector.skipZones;
+    }
+    isInSkipZone(candidate, skipZones) {
+        for (const zone of skipZones) {
+            if (candidate.line < zone.startLine || candidate.line > zone.endLine)
+                continue;
+            if (candidate.line === zone.endLine && candidate.column >= zone.endColumn)
+                continue;
+            if (candidate.line === zone.startLine && candidate.column < zone.startColumn)
+                continue;
+            return true;
+        }
+        return false;
     }
     autofix(offense, result, _context) {
         if (!offense.autofixContext)
             return null;
-        const { node, fixType } = offense.autofixContext;
-        if (!node.content)
-            return null;
-        const content = node.content.value;
-        switch (fixType) {
-            case "before-close":
-                node.content.value = content.replace(/\s{2,}$/, " ");
-                break;
-            case "after-open":
-                node.content.value = content.replace(/^\s{2,}/, " ");
-                break;
-            case "after-comment-equals":
-                if (content.startsWith("=")) {
-                    const afterEquals = content.substring(1);
-                    node.content.value = "= " + afterEquals.replace(/^\s{2,}/, "");
+        const { node } = offense.autofixContext;
+        if (node.type === "AST_HTML_TEXT_NODE" || node.type === "AST_LITERAL_NODE") {
+            let fixedContent = node.content.replace(TRAILING_WHITESPACE_BEFORE_NEWLINE, "");
+            const offenseIsAtEndOfContent = this.isOffenseAtEndOfContent(offense, node);
+            if (offenseIsAtEndOfContent) {
+                if (this.hasTrailingWhitespaceNotIndentation(fixedContent)) {
+                    fixedContent = fixedContent.replace(TRAILING_WHITESPACE, "");
                 }
-                break;
-            default:
-                return null;
+                if (ONLY_WHITESPACE.test(fixedContent) && node.location.start.column !== 0) {
+                    fixedContent = "";
+                }
+            }
+            node.content = fixedContent;
         }
         return result;
     }
+    isOffenseAtEndOfContent(offense, node) {
+        return offense.location.end.line === node.location.end.line && offense.location.end.column === node.location.end.column;
+    }
+    hasTrailingWhitespaceNotIndentation(content) {
+        if (content.endsWith("\n"))
+            return false;
+        const endMatch = content.match(TRAILING_WHITESPACE);
+        if (!endMatch)
+            return false;
+        const whitespaceStart = content.length - endMatch[0].length;
+        if (whitespaceStart === 0)
+            return false;
+        const characterBefore = content[whitespaceStart - 1];
+        if (characterBefore === "\n")
+            return false;
+        return true;
+    }
 }
 
-class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
-    visitERBIfNode(node) {
-        this.checkOutputControlFlow(node);
-        this.visitChildNodes(node);
+const JS_ATTRIBUTE_PATTERN = /^on/i;
+const SAFE_PATTERN$1 = /\.to_json\s*$|\bj\s*[\s(]|\bescape_javascript\s*[\s(]/;
+class ERBNoUnsafeJSAttributeVisitor extends AttributeVisitorMixin {
+    checkStaticAttributeDynamicValue({ attributeName, valueNodes }) {
+        if (!JS_ATTRIBUTE_PATTERN.test(attributeName))
+            return;
+        for (const node of valueNodes) {
+            if (!isERBNode(node))
+                continue;
+            if (!isERBOutputNode(node))
+                continue;
+            const content = node.content?.value?.trim() || "";
+            if (SAFE_PATTERN$1.test(content))
+                continue;
+            this.addOffense(`Unsafe ERB output in \`${attributeName}\` attribute. Use \`.to_json\`, \`j()\`, or \`escape_javascript()\` to safely encode values.`, node.location);
+        }
     }
-    visitERBUnlessNode(node) {
-        this.checkOutputControlFlow(node);
-        this.visitChildNodes(node);
+}
+class ERBNoUnsafeJSAttributeRule extends ParserRule {
+    static ruleName = "erb-no-unsafe-js-attribute";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
     }
-    visitERBElseNode(node) {
-        this.checkOutputControlFlow(node);
-        this.visitChildNodes(node);
+    check(result, context) {
+        const visitor = new ERBNoUnsafeJSAttributeVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
     }
-    visitERBEndNode(node) {
-        this.checkOutputControlFlow(node);
-        this.visitChildNodes(node);
+}
+
+const RAW_PATTERN = /\braw[\s(]/;
+const HTML_SAFE_PATTERN = /\.html_safe\b/;
+const RAW_TEXT_ELEMENTS = new Set([
+    "title",
+    "textarea",
+    "script",
+    "style",
+    "xmp",
+    "iframe",
+    "noembed",
+    "noframes",
+    "listing",
+    "plaintext",
+]);
+class ERBNoUnsafeRawVisitor extends BaseRuleVisitor {
+    insideRawTextElement = false;
+    visitHTMLElementNode(node) {
+        if (!isHTMLOpenTagNode(node.open_tag)) {
+            super.visitHTMLElementNode(node);
+            return;
+        }
+        const tagName = getTagLocalName(node.open_tag);
+        if (tagName && RAW_TEXT_ELEMENTS.has(tagName)) {
+            const wasInside = this.insideRawTextElement;
+            this.insideRawTextElement = true;
+            super.visitHTMLElementNode(node);
+            this.insideRawTextElement = wasInside;
+            return;
+        }
+        super.visitHTMLElementNode(node);
     }
-    checkOutputControlFlow(controlBlock) {
-        const openTag = controlBlock.tag_opening;
-        if (!openTag) {
+    visitERBContentNode(node) {
+        if (this.insideRawTextElement)
+            return;
+        if (!isERBOutputNode(node))
             return;
+        const content = node.content?.value || "";
+        if (RAW_PATTERN.test(content)) {
+            this.addOffense("Avoid `raw()` in ERB output. It bypasses HTML escaping and can cause cross-site scripting (XSS) vulnerabilities.", node.location);
         }
-        if (openTag.value === "<%=") {
-            let controlBlockType = controlBlock.type;
-            if (controlBlock.type === "AST_ERB_IF_NODE")
-                controlBlockType = "if";
-            if (controlBlock.type === "AST_ERB_ELSE_NODE")
-                controlBlockType = "else";
-            if (controlBlock.type === "AST_ERB_END_NODE")
-                controlBlockType = "end";
-            if (controlBlock.type === "AST_ERB_UNLESS_NODE")
-                controlBlockType = "unless";
-            this.addOffense(`Control flow statements like \`${controlBlockType}\` should not be used with output tags. Use \`<% ${controlBlockType} ... %>\` instead.`, openTag.location);
+        if (HTML_SAFE_PATTERN.test(content)) {
+            this.addOffense("Avoid `.html_safe` in ERB output. It bypasses HTML escaping and can cause cross-site scripting (XSS) vulnerabilities.", node.location);
         }
-        return;
     }
 }
-class ERBNoOutputControlFlowRule extends ParserRule {
-    name = "erb-no-output-control-flow";
+class ERBNoUnsafeRawRule extends ParserRule {
+    static ruleName = "erb-no-unsafe-raw";
     get defaultConfig() {
         return {
             enabled: true,
@@ -1893,28 +3234,50 @@ class ERBNoOutputControlFlowRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name, context);
+        const visitor = new ERBNoUnsafeRawVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
-class ERBNoSilentTagInAttributeNameVisitor extends BaseRuleVisitor {
-    visitHTMLAttributeNameNode(node) {
-        const erbNodes = filterERBContentNodes(node.children);
-        const silentNodes = erbNodes.filter(this.isSilentERBTag);
-        for (const node of silentNodes) {
-            this.addOffense(`Remove silent ERB tag from HTML attribute name. Silent ERB tags (\`${node.tag_opening?.value}\`) do not output content and should not be used in attribute names.`, node.location);
+const SAFE_PATTERN = /\.to_json\b/;
+class ERBNoUnsafeScriptInterpolationVisitor extends BaseRuleVisitor {
+    visitHTMLElementNode(node) {
+        if (!isHTMLOpenTagNode(node.open_tag)) {
+            super.visitHTMLElementNode(node);
+            return;
+        }
+        if (getTagLocalName(node.open_tag) === "script") {
+            this.checkScriptElement(node);
         }
+        super.visitHTMLElementNode(node);
     }
-    // TODO: might be worth to extract
-    isSilentERBTag(node) {
-        const silentTags = ["<%", "<%-", "<%#"];
-        return silentTags.includes(node.tag_opening?.value || "");
+    checkScriptElement(node) {
+        if (!isHTMLOpenTagNode(node.open_tag))
+            return;
+        const typeAttribute = getAttribute(node.open_tag, "type");
+        const typeValue = typeAttribute ? getStaticAttributeValue(typeAttribute) : null;
+        if (typeValue === "text/html")
+            return;
+        if (!node.body || node.body.length === 0)
+            return;
+        this.checkNodesForUnsafeOutput(node.body);
+    }
+    checkNodesForUnsafeOutput(nodes) {
+        for (const child of nodes) {
+            if (!isERBNode(child))
+                continue;
+            if (!isERBOutputNode(child))
+                continue;
+            const content = child.content?.value?.trim() || "";
+            if (SAFE_PATTERN.test(content))
+                continue;
+            this.addOffense("Unsafe ERB output in `<script>` tag. Use `.to_json` to safely serialize values into JavaScript.", child.location);
+        }
     }
 }
-class ERBNoSilentTagInAttributeNameRule extends ParserRule {
-    name = "erb-no-silent-tag-in-attribute-name";
+class ERBNoUnsafeScriptInterpolationRule extends ParserRule {
+    static ruleName = "erb-no-unsafe-script-interpolation";
     get defaultConfig() {
         return {
             enabled: true,
@@ -1922,7 +3285,7 @@ class ERBNoSilentTagInAttributeNameRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new ERBNoSilentTagInAttributeNameVisitor(this.name, context);
+        const visitor = new ERBNoUnsafeScriptInterpolationVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -1934,7 +3297,7 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
         super.visitHTMLOpenTagNode(node);
     }
     checkImgTag(openTag) {
-        const tagName = getTagName(openTag);
+        const tagName = getTagLocalName(openTag);
         if (tagName !== "img")
             return;
         const attributes = getAttributes(openTag);
@@ -1995,7 +3358,7 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
     }
 }
 class ERBPreferImageTagHelperRule extends ParserRule {
-    name = "erb-prefer-image-tag-helper";
+    static ruleName = "erb-prefer-image-tag-helper";
     get defaultConfig() {
         return {
             enabled: true,
@@ -2003,7 +3366,7 @@ class ERBPreferImageTagHelperRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new ERBPreferImageTagHelperVisitor(this.name, context);
+        const visitor = new ERBPreferImageTagHelperVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -2025,7 +3388,7 @@ class ERBRequireTrailingNewlineVisitor extends BaseSourceRuleVisitor {
 }
 class ERBRequireTrailingNewlineRule extends SourceRule {
     static autocorrectable = true;
-    name = "erb-require-trailing-newline";
+    static ruleName = "erb-require-trailing-newline";
     get defaultConfig() {
         return {
             enabled: true,
@@ -2033,7 +3396,7 @@ class ERBRequireTrailingNewlineRule extends SourceRule {
         };
     }
     check(source, context) {
-        const visitor = new ERBRequireTrailingNewlineVisitor(this.name, context);
+        const visitor = new ERBRequireTrailingNewlineVisitor(this.ruleName, context);
         visitor.visit(source);
         return visitor.offenses;
     }
@@ -2060,7 +3423,22 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
         }
     }
     checkCommentTagWhitespace(node, openTag, closeTag, content) {
-        if (!content.startsWith(" ") && !content.startsWith("\n") && !content.startsWith("=")) {
+        const commentedTagPrefix = this.getCommentedTagPrefix(content);
+        if (commentedTagPrefix) {
+            const afterPrefix = content.substring(commentedTagPrefix.length);
+            const tag = `<%#${commentedTagPrefix}`;
+            if (afterPrefix.length > 0 && !afterPrefix[0].match(/\s/)) {
+                this.addOffense(`Add whitespace after \`${tag}\`. This looks like a temporarily commented ERB tag.`, openTag.location, {
+                    node,
+                    openTag,
+                    closeTag,
+                    content,
+                    fixType: "after-comment-equals",
+                    unsafe: true,
+                }, "info");
+            }
+        }
+        else if (!content.startsWith(" ") && !content.startsWith("\n")) {
             this.addOffense(`Add whitespace after \`${openTag.value}\`.`, openTag.location, {
                 node,
                 openTag,
@@ -2069,15 +3447,6 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
                 fixType: "after-open"
             });
         }
-        else if (content.startsWith("=") && content.length > 1 && !content[1].match(/\s/)) {
-            this.addOffense(`Add whitespace after \`<%#=\`.`, openTag.location, {
-                node,
-                openTag,
-                closeTag,
-                content,
-                fixType: "after-comment-equals"
-            });
-        }
         if (!content.endsWith(" ") && !content.endsWith("\n")) {
             this.addOffense(`Add whitespace before \`${closeTag.value}\`.`, closeTag.location, {
                 node,
@@ -2100,6 +3469,21 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
             fixType: "after-open"
         });
     }
+    getCommentedTagPrefix(content) {
+        if (content.startsWith("graphql"))
+            return "graphql";
+        if (content.startsWith("%="))
+            return "%=";
+        if (content.startsWith("=="))
+            return "==";
+        if (content.startsWith("%"))
+            return "%";
+        if (content.startsWith("="))
+            return "=";
+        if (content.startsWith("-"))
+            return "-";
+        return null;
+    }
     checkCloseTagWhitespace(node, openTag, closeTag, content) {
         if (content.endsWith(" ") || content.endsWith("\n")) {
             return;
@@ -2115,7 +3499,7 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
 }
 class ERBRequireWhitespaceRule extends ParserRule {
     static autocorrectable = true;
-    name = "erb-require-whitespace-inside-tags";
+    static ruleName = "erb-require-whitespace-inside-tags";
     get defaultConfig() {
         return {
             enabled: true,
@@ -2123,7 +3507,7 @@ class ERBRequireWhitespaceRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new RequireWhitespaceInsideTags(this.name, context);
+        const visitor = new RequireWhitespaceInsideTags(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -2142,9 +3526,12 @@ class ERBRequireWhitespaceRule extends ParserRule {
             node.content.value = " " + content;
             return result;
         }
-        if (fixType === "after-comment-equals" && content.startsWith("=")) {
-            node.content.value = "= " + content.substring(1);
-            return result;
+        if (fixType === "after-comment-equals") {
+            const prefix = content.startsWith("graphql") ? "graphql" : content.startsWith("%=") ? "%=" : content.startsWith("==") ? "==" : content.startsWith("%") ? "%" : content.startsWith("=") ? "=" : content.startsWith("-") ? "-" : null;
+            if (prefix) {
+                node.content.value = prefix + " " + content.substring(prefix.length);
+                return result;
+            }
         }
         return null;
     }
@@ -2162,7 +3549,7 @@ class ERBRightTrimVisitor extends BaseRuleVisitor {
 }
 class ERBRightTrimRule extends ParserRule {
     static autocorrectable = true;
-    name = "erb-right-trim";
+    static ruleName = "erb-right-trim";
     get defaultConfig() {
         return {
             enabled: true,
@@ -2170,7 +3557,7 @@ class ERBRightTrimRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new ERBRightTrimVisitor(this.name, context);
+        const visitor = new ERBRightTrimVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -2193,27 +3580,6 @@ class ERBRightTrimRule extends ParserRule {
     }
 }
 
-/**
- * File path and naming utilities for linter rules
- */
-/**
- * Extracts the basename (filename) from a file path
- * Works with both forward slashes and backslashes
- */
-function getBasename(filePath) {
-    const lastSlash = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
-    return lastSlash === -1 ? filePath : filePath.slice(lastSlash + 1);
-}
-/**
- * Checks if a file is a Rails partial (filename starts with `_`)
- * Returns null if fileName is undefined (unknown context)
- */
-function isPartialFile(fileName) {
-    if (!fileName)
-        return null;
-    return getBasename(fileName).startsWith("_");
-}
-
 /**
  * Checks if parentheses in a string are balanced
  * Returns false if there are more closing parens than opening at any point
@@ -2286,7 +3652,7 @@ function splitByTopLevelComma(str) {
     return result;
 }
 
-const STRICT_LOCALS_PATTERN = /^locals:\s+\([^)]*\)\s*$/;
+const STRICT_LOCALS_PATTERN = /^locals:\s+\(.*\)\s*$/s;
 function isValidStrictLocalsFormat(content) {
     return STRICT_LOCALS_PATTERN.test(content);
 }
@@ -2311,13 +3677,13 @@ function detectLocalsWithoutColon(content) {
     return /^locals?\(/.test(content);
 }
 function detectSingularLocal(content) {
-    return /^local:/.test(content);
+    return content.startsWith('local:');
 }
 function detectMissingColonBeforeParens(content) {
     return /^locals\s+\(/.test(content);
 }
 function detectMissingSpaceAfterColon(content) {
-    return /^locals:\(/.test(content);
+    return content.startsWith('locals:(');
 }
 function detectMissingParentheses(content) {
     return /^locals:\s*[^(]/.test(content);
@@ -2481,7 +3847,7 @@ class ERBStrictLocalsCommentSyntaxVisitor extends BaseRuleVisitor {
     }
 }
 class ERBStrictLocalsCommentSyntaxRule extends ParserRule {
-    name = "erb-strict-locals-comment-syntax";
+    static ruleName = "erb-strict-locals-comment-syntax";
     get defaultConfig() {
         return {
             enabled: true,
@@ -2489,7 +3855,7 @@ class ERBStrictLocalsCommentSyntaxRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new ERBStrictLocalsCommentSyntaxVisitor(this.name, context);
+        const visitor = new ERBStrictLocalsCommentSyntaxVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -2512,7 +3878,7 @@ class ERBStrictLocalsRequiredVisitor extends BaseSourceRuleVisitor {
 }
 class ERBStrictLocalsRequiredRule extends SourceRule {
     static unsafeAutocorrectable = true;
-    name = "erb-strict-locals-required";
+    static ruleName = "erb-strict-locals-required";
     get defaultConfig() {
         return {
             enabled: false,
@@ -2520,7 +3886,7 @@ class ERBStrictLocalsRequiredRule extends SourceRule {
         };
     }
     check(source, context) {
-        const visitor = new ERBStrictLocalsRequiredVisitor(this.name, context);
+        const visitor = new ERBStrictLocalsRequiredVisitor(this.ruleName, context);
         visitor.visit(source);
         return visitor.offenses;
     }
@@ -2688,71 +4054,75 @@ class HerbDisableCommentParsedVisitor extends HerbDisableCommentBaseVisitor {
     }
 }
 
-class HerbDisableCommentValidRuleNameVisitor extends HerbDisableCommentParsedVisitor {
-    validRuleNames = new Set();
-    validRuleNamesList = [];
-    constructor(ruleName, validRuleNames, context) {
-        super(ruleName, context);
-        this.validRuleNames = new Set([...validRuleNames, "all"]);
-        this.validRuleNamesList = Array.from(this.validRuleNames);
-    }
-    checkParsedHerbDisable(node, _content, herbDisable) {
-        herbDisable.ruleNameDetails.forEach(ruleDetail => {
-            if (this.validRuleNames.has(ruleDetail.name))
-                return;
-            const suggestion = didyoumean(ruleDetail.name, this.validRuleNamesList);
-            const message = suggestion
-                ? `Unknown rule \`${ruleDetail.name}\`. Did you mean \`${suggestion}\`?`
-                : `Unknown rule \`${ruleDetail.name}\`.`;
-            const location = this.createRuleNameLocation(node, ruleDetail);
-            this.addOffenseWithFallback(message, location, node);
-        });
+class HerbDisableCommentMalformedVisitor extends HerbDisableCommentBaseVisitor {
+    checkHerbDisableComment(node, content) {
+        const trimmed = content.trim();
+        const looksLikeHerbDisable = trimmed.startsWith("herb:disable");
+        if (!looksLikeHerbDisable)
+            return;
+        if (trimmed.length > "herb:disable".length) {
+            const charAfterPrefix = trimmed["herb:disable".length];
+            if (charAfterPrefix !== ' ' && charAfterPrefix !== '\t' && charAfterPrefix !== '\n') {
+                this.addOffense("`herb:disable` comment is missing a space after `herb:disable`. Add a space before the rule names.", node.location);
+                return;
+            }
+        }
+        const afterPrefix = trimmed.substring("herb:disable".length).trim();
+        if (afterPrefix.length === 0)
+            return;
+        const parsed = parseHerbDisableContent(content);
+        if (parsed !== null)
+            return;
+        let message = "`herb:disable` comment is malformed.";
+        const rulesString = afterPrefix.trim();
+        if (rulesString.endsWith(',')) {
+            message = "`herb:disable` comment has a trailing comma. Remove the trailing comma.";
+        }
+        else if (rulesString.includes(',,') || rulesString.match(/,\s*,/)) {
+            message = "`herb:disable` comment has consecutive commas. Remove extra commas.";
+        }
+        else if (rulesString.startsWith(',')) {
+            message = "`herb:disable` comment starts with a comma. Remove the leading comma.";
+        }
+        this.addOffense(message, node.location);
     }
 }
-class HerbDisableCommentValidRuleNameRule extends ParserRule {
-    name = "herb-disable-comment-valid-rule-name";
+class HerbDisableCommentMalformedRule extends ParserRule {
+    static ruleName = "herb-disable-comment-malformed";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "warning"
+            severity: "error"
         };
     }
     check(result, context) {
-        const validRuleNames = context?.validRuleNames;
-        if (!validRuleNames)
-            return [];
-        if (validRuleNames.length === 0)
-            return [];
-        const visitor = new HerbDisableCommentValidRuleNameVisitor(this.name, validRuleNames, context);
+        const visitor = new HerbDisableCommentMalformedVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
-class HerbDisableCommentNoRedundantAllVisitor extends HerbDisableCommentParsedVisitor {
-    checkParsedHerbDisable(node, _content, herbDisable) {
-        if (!herbDisable.ruleNames.includes("all"))
-            return;
-        if (herbDisable.ruleNames.length <= 1)
+class HerbDisableCommentMissingRulesVisitor extends HerbDisableCommentBaseVisitor {
+    checkHerbDisableComment(node, content) {
+        const herbDisable = parseHerbDisableContent(content);
+        if (herbDisable)
             return;
-        const allDetail = herbDisable.ruleNameDetails.find(detail => detail.name === "all");
-        if (!allDetail)
+        const emptyFormat = /^\s*herb:disable\s*$/;
+        if (!emptyFormat.test(content))
             return;
-        const location = this.createRuleNameLocation(node, allDetail);
-        const message = `Using \`all\` with specific rules is redundant. Use \`herb:disable all\` by itself or list only specific rules.`;
-        this.addOffenseWithFallback(message, location, node);
+        this.addOffense(`\`herb:disable\` comment is missing rule names. Specify \`all\` or list specific rules to disable.`, node.location);
     }
 }
-class HerbDisableCommentNoRedundantAllRule extends ParserRule {
-    name = "herb-disable-comment-no-redundant-all";
+class HerbDisableCommentMissingRulesRule extends ParserRule {
+    static ruleName = "herb-disable-comment-missing-rules";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "warning"
+            severity: "error"
         };
     }
     check(result, context) {
-        const visitor = new HerbDisableCommentNoRedundantAllVisitor(this.name, context);
+        const visitor = new HerbDisableCommentMissingRulesVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -2774,7 +4144,7 @@ class HerbDisableCommentNoDuplicateRulesVisitor extends HerbDisableCommentParsed
     }
 }
 class HerbDisableCommentNoDuplicateRulesRule extends ParserRule {
-    name = "herb-disable-comment-no-duplicate-rules";
+    static ruleName = "herb-disable-comment-no-duplicate-rules";
     get defaultConfig() {
         return {
             enabled: true,
@@ -2782,81 +4152,36 @@ class HerbDisableCommentNoDuplicateRulesRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new HerbDisableCommentNoDuplicateRulesVisitor(this.name, context);
-        visitor.visit(result.value);
-        return visitor.offenses;
-    }
-}
-
-class HerbDisableCommentMissingRulesVisitor extends HerbDisableCommentBaseVisitor {
-    checkHerbDisableComment(node, content) {
-        const herbDisable = parseHerbDisableContent(content);
-        if (herbDisable)
-            return;
-        const emptyFormat = /^\s*herb:disable\s*$/;
-        if (!emptyFormat.test(content))
-            return;
-        this.addOffense(`\`herb:disable\` comment is missing rule names. Specify \`all\` or list specific rules to disable.`, node.location);
-    }
-}
-class HerbDisableCommentMissingRulesRule extends ParserRule {
-    name = "herb-disable-comment-missing-rules";
-    get defaultConfig() {
-        return {
-            enabled: true,
-            severity: "error"
-        };
-    }
-    check(result, context) {
-        const visitor = new HerbDisableCommentMissingRulesVisitor(this.name, context);
+        const visitor = new HerbDisableCommentNoDuplicateRulesVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
-class HerbDisableCommentMalformedVisitor extends HerbDisableCommentBaseVisitor {
-    checkHerbDisableComment(node, content) {
-        const trimmed = content.trim();
-        const looksLikeHerbDisable = trimmed.startsWith("herb:disable");
-        if (!looksLikeHerbDisable)
+class HerbDisableCommentNoRedundantAllVisitor extends HerbDisableCommentParsedVisitor {
+    checkParsedHerbDisable(node, _content, herbDisable) {
+        if (!herbDisable.ruleNames.includes("all"))
             return;
-        if (trimmed.length > "herb:disable".length) {
-            const charAfterPrefix = trimmed["herb:disable".length];
-            if (charAfterPrefix !== ' ' && charAfterPrefix !== '\t' && charAfterPrefix !== '\n') {
-                this.addOffense("`herb:disable` comment is missing a space after `herb:disable`. Add a space before the rule names.", node.location);
-                return;
-            }
-        }
-        const afterPrefix = trimmed.substring("herb:disable".length).trim();
-        if (afterPrefix.length === 0)
+        if (herbDisable.ruleNames.length <= 1)
             return;
-        const parsed = parseHerbDisableContent(content);
-        if (parsed !== null)
+        const allDetail = herbDisable.ruleNameDetails.find(detail => detail.name === "all");
+        if (!allDetail)
             return;
-        let message = "`herb:disable` comment is malformed.";
-        const rulesString = afterPrefix.trim();
-        if (rulesString.endsWith(',')) {
-            message = "`herb:disable` comment has a trailing comma. Remove the trailing comma.";
-        }
-        else if (rulesString.includes(',,') || rulesString.match(/,\s*,/)) {
-            message = "`herb:disable` comment has consecutive commas. Remove extra commas.";
-        }
-        else if (rulesString.startsWith(',')) {
-            message = "`herb:disable` comment starts with a comma. Remove the leading comma.";
-        }
-        this.addOffense(message, node.location);
+        const location = this.createRuleNameLocation(node, allDetail);
+        const message = `Using \`all\` with specific rules is redundant. Use \`herb:disable all\` by itself or list only specific rules.`;
+        this.addOffenseWithFallback(message, location, node);
     }
 }
-class HerbDisableCommentMalformedRule extends ParserRule {
-    name = "herb-disable-comment-malformed";
+class HerbDisableCommentNoRedundantAllRule extends ParserRule {
+    static ruleName = "herb-disable-comment-no-redundant-all";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new HerbDisableCommentMalformedVisitor(this.name, context);
+        const visitor = new HerbDisableCommentNoRedundantAllVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -2903,7 +4228,7 @@ class HerbDisableCommentUnnecessaryVisitor extends HerbDisableCommentParsedVisit
     }
 }
 class HerbDisableCommentUnnecessaryRule extends ParserRule {
-    name = "herb-disable-comment-unnecessary";
+    static ruleName = "herb-disable-comment-unnecessary";
     get defaultConfig() {
         return {
             enabled: true,
@@ -2919,37 +4244,161 @@ class HerbDisableCommentUnnecessaryRule extends ParserRule {
             return [];
         if (!ignoredOffensesByLine)
             return [];
-        const visitor = new HerbDisableCommentUnnecessaryVisitor(this.name, ignoredOffensesByLine, validRuleNames, context);
+        const visitor = new HerbDisableCommentUnnecessaryVisitor(this.ruleName, ignoredOffensesByLine, validRuleNames, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class HerbDisableCommentValidRuleNameVisitor extends HerbDisableCommentParsedVisitor {
+    validRuleNames = new Set();
+    validRuleNamesList = [];
+    constructor(ruleName, validRuleNames, context) {
+        super(ruleName, context);
+        this.validRuleNames = new Set([...validRuleNames, "all"]);
+        this.validRuleNamesList = Array.from(this.validRuleNames);
+    }
+    checkParsedHerbDisable(node, _content, herbDisable) {
+        herbDisable.ruleNameDetails.forEach(ruleDetail => {
+            if (this.validRuleNames.has(ruleDetail.name))
+                return;
+            const suggestion = didyoumean(ruleDetail.name, this.validRuleNamesList);
+            const message = suggestion
+                ? `Unknown rule \`${ruleDetail.name}\`. Did you mean \`${suggestion}\`?`
+                : `Unknown rule \`${ruleDetail.name}\`.`;
+            const location = this.createRuleNameLocation(node, ruleDetail);
+            this.addOffenseWithFallback(message, location, node);
+        });
+    }
+}
+class HerbDisableCommentValidRuleNameRule extends ParserRule {
+    static ruleName = "herb-disable-comment-valid-rule-name";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "warning"
+        };
+    }
+    check(result, context) {
+        const validRuleNames = context?.validRuleNames;
+        if (!validRuleNames)
+            return [];
+        if (validRuleNames.length === 0)
+            return [];
+        const visitor = new HerbDisableCommentValidRuleNameVisitor(this.ruleName, validRuleNames, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
-class AnchorRechireHrefVisitor extends BaseRuleVisitor {
+const ALLOWED_TYPES = ["text/javascript"];
+class AllowedScriptTypeVisitor extends BaseRuleVisitor {
     visitHTMLOpenTagNode(node) {
+        if (getTagLocalName(node) === "script") {
+            this.visitScriptNode(node);
+        }
+    }
+    visitScriptNode(node) {
+        const typeAttribute = getAttribute(node, "type");
+        if (!typeAttribute) {
+            return;
+        }
+        if (!hasAttributeValue(typeAttribute)) {
+            this.addOffense("Avoid using an empty `type` attribute on the `<script>` tag. Either set a valid type or remove the attribute entirely.", typeAttribute.location);
+            return;
+        }
+        this.validateTypeAttribute(typeAttribute);
+    }
+    validateTypeAttribute(typeAttribute) {
+        const typeValue = getStaticAttributeValue(typeAttribute);
+        if (typeValue === null)
+            return;
+        if (typeValue === "") {
+            this.addOffense("Avoid using an empty `type` attribute on the `<script>` tag. Either set a valid type or remove the attribute entirely.", typeAttribute.location);
+            return;
+        }
+        if (ALLOWED_TYPES.includes(typeValue))
+            return;
+        this.addOffense(`Avoid using \`${typeValue}\` as the \`type\` attribute for the \`<script>\` tag. ` +
+            `Must be one of: ${ALLOWED_TYPES.map(t => `\`${t}\``).join(", ")}` +
+            `${" or blank" }.`, typeAttribute.location);
+    }
+}
+class HTMLAllowedScriptTypeRule extends ParserRule {
+    static ruleName = "html-allowed-script-type";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result, context) {
+        const visitor = new AllowedScriptTypeVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class AnchorRequireHrefVisitor extends BaseRuleVisitor {
+    visitHTMLElementNode(node) {
         this.checkATag(node);
-        super.visitHTMLOpenTagNode(node);
+        super.visitHTMLElementNode(node);
     }
     checkATag(node) {
-        const tagName = getTagName(node);
+        const tagName = getTagLocalName(node);
         if (tagName !== "a") {
             return;
         }
-        if (!hasAttribute(node, "href")) {
-            this.addOffense("Add an `href` attribute to `<a>` to ensure it is focusable and accessible.", node.tag_name.location);
+        const hrefAttribute = this.getHrefAttribute(node);
+        if (!hrefAttribute) {
+            this.addOffense("Add an `href` attribute to `<a>` to ensure it is focusable and accessible. Links should navigate somewhere. If you need a clickable element without navigation, use a `<button>` instead.", node.tag_name.location);
+            return;
+        }
+        const hrefValue = getStaticAttributeValue(hrefAttribute);
+        if (hrefValue === "#") {
+            this.addOffense('Avoid `href="#"` on `<a>`. `href="#"` does not navigate anywhere, scrolls the page to the top, and adds `#` to the URL. If you need a clickable element without navigation, use a `<button>` instead.', hrefAttribute.location);
+            return;
+        }
+        if (hrefValue !== null && hrefValue.startsWith("javascript:void")) {
+            this.addOffense('Avoid `javascript:void(0)` in `href` on `<a>`. Links should navigate somewhere. If you need a clickable element without navigation, use a `<button>` instead.', hrefAttribute.location);
+            return;
+        }
+        if (this.hasNilHrefValue(hrefAttribute)) {
+            this.addOffense("Avoid passing `nil` as the URL for `link_to`. Links should navigate somewhere. If you need a clickable element without navigation, use a `<button>` instead.", hrefAttribute.location);
+        }
+    }
+    hasNilHrefValue(hrefAttribute) {
+        const valueNode = hrefAttribute.value;
+        if (!valueNode)
+            return false;
+        return valueNode.children.some(child => isRubyLiteralNode(child) && child.content === "url_for(nil)");
+    }
+    getHrefAttribute(node) {
+        const openTag = node.open_tag;
+        if (isHTMLOpenTagNode(openTag)) {
+            return getAttribute(openTag, "href");
+        }
+        if (isERBOpenTagNode(openTag)) {
+            return findAttributeByName(filterHTMLAttributeNodes(openTag.children), "href");
         }
+        return null;
     }
 }
 class HTMLAnchorRequireHrefRule extends ParserRule {
-    name = "html-anchor-require-href";
+    static ruleName = "html-anchor-require-href";
     get defaultConfig() {
         return {
             enabled: true,
             severity: "error"
         };
     }
+    get parserOptions() {
+        return {
+            action_view_helpers: true,
+        };
+    }
     check(result, context) {
-        const visitor = new AnchorRechireHrefVisitor(this.name, context);
+        const visitor = new AnchorRequireHrefVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -2971,15 +4420,15 @@ class AriaAttributeMustBeValid extends AttributeVisitorMixin {
     }
 }
 class HTMLAriaAttributeMustBeValid extends ParserRule {
-    name = "html-aria-attribute-must-be-valid";
+    static ruleName = "html-aria-attribute-must-be-valid";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new AriaAttributeMustBeValid(this.name, context);
+        const visitor = new AriaAttributeMustBeValid(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3008,15 +4457,15 @@ class AriaLabelIsWellFormattedVisitor extends AttributeVisitorMixin {
     }
 }
 class HTMLAriaLabelIsWellFormattedRule extends ParserRule {
-    name = "html-aria-label-is-well-formatted";
+    static ruleName = "html-aria-label-is-well-formatted";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new AriaLabelIsWellFormattedVisitor(this.name, context);
+        const visitor = new AriaLabelIsWellFormattedVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3060,15 +4509,15 @@ class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
     }
 }
 class HTMLAriaLevelMustBeValidRule extends ParserRule {
-    name = "html-aria-level-must-be-valid";
+    static ruleName = "html-aria-level-must-be-valid";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new HTMLAriaLevelMustBeValidVisitor(this.name, context);
+        const visitor = new HTMLAriaLevelMustBeValidVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3085,15 +4534,15 @@ class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
     }
 }
 class HTMLAriaRoleHeadingRequiresLevelRule extends ParserRule {
-    name = "html-aria-role-heading-requires-level";
+    static ruleName = "html-aria-role-heading-requires-level";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new AriaRoleHeadingRequiresLevel(this.name, context);
+        const visitor = new AriaRoleHeadingRequiresLevel(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3111,15 +4560,15 @@ class AriaRoleMustBeValid extends AttributeVisitorMixin {
     }
 }
 class HTMLAriaRoleMustBeValidRule extends ParserRule {
-    name = "html-aria-role-must-be-valid";
+    static ruleName = "html-aria-role-must-be-valid";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new AriaRoleMustBeValid(this.name, context);
+        const visitor = new AriaRoleMustBeValid(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3153,7 +4602,7 @@ class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
 }
 class HTMLAttributeDoubleQuotesRule extends ParserRule {
     static autocorrectable = true;
-    name = "html-attribute-double-quotes";
+    static ruleName = "html-attribute-double-quotes";
     get defaultConfig() {
         return {
             enabled: true,
@@ -3161,7 +4610,7 @@ class HTMLAttributeDoubleQuotesRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new AttributeDoubleQuotesVisitor(this.name, context);
+        const visitor = new AttributeDoubleQuotesVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3196,7 +4645,7 @@ class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
 }
 class HTMLAttributeEqualsSpacingRule extends ParserRule {
     static autocorrectable = true;
-    name = "html-attribute-equals-spacing";
+    static ruleName = "html-attribute-equals-spacing";
     get defaultConfig() {
         return {
             enabled: true,
@@ -3204,7 +4653,7 @@ class HTMLAttributeEqualsSpacingRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new HTMLAttributeEqualsSpacingVisitor(this.name, context);
+        const visitor = new HTMLAttributeEqualsSpacingVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3250,7 +4699,7 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
 }
 class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
     static autocorrectable = true;
-    name = "html-attribute-values-require-quotes";
+    static ruleName = "html-attribute-values-require-quotes";
     get defaultConfig() {
         return {
             enabled: true,
@@ -3258,7 +4707,7 @@ class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new AttributeValuesRequireQuotesVisitor(this.name, context);
+        const visitor = new AttributeValuesRequireQuotesVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3295,7 +4744,7 @@ class AvoidBothDisabledAndAriaDisabledVisitor extends BaseRuleVisitor {
         super.visitHTMLOpenTagNode(node);
     }
     checkElement(node) {
-        const tagName = getTagName(node);
+        const tagName = getTagLocalName(node);
         if (!tagName || !ELEMENTS_WITH_NATIVE_DISABLED_ATTRIBUTE_SUPPORT.has(tagName)) {
             return;
         }
@@ -3314,24 +4763,23 @@ class AvoidBothDisabledAndAriaDisabledVisitor extends BaseRuleVisitor {
         if (!attribute)
             return false;
         const valueNode = attribute.value;
-        if (!valueNode || valueNode.type !== "AST_HTML_ATTRIBUTE_VALUE_NODE")
+        if (!isHTMLAttributeValueNode(valueNode))
             return false;
-        const htmlValueNode = valueNode;
-        if (!htmlValueNode.children)
+        if (!valueNode.children)
             return false;
-        return htmlValueNode.children.some((child) => child.type === "AST_ERB_CONTENT_NODE");
+        return valueNode.children.some(isERBContentNode);
     }
 }
 class HTMLAvoidBothDisabledAndAriaDisabledRule extends ParserRule {
-    name = "html-avoid-both-disabled-and-aria-disabled";
+    static ruleName = "html-avoid-both-disabled-and-aria-disabled";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new AvoidBothDisabledAndAriaDisabledVisitor(this.name, context);
+        const visitor = new AvoidBothDisabledAndAriaDisabledVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3340,7 +4788,7 @@ class HTMLAvoidBothDisabledAndAriaDisabledRule extends ParserRule {
 class HTMLBodyOnlyElementsVisitor extends BaseRuleVisitor {
     elementStack = [];
     visitHTMLElementNode(node) {
-        const tagName = getTagName(node.open_tag)?.toLowerCase();
+        const tagName = getTagLocalName(node);
         if (!tagName)
             return;
         this.checkBodyOnlyElement(node, tagName);
@@ -3366,7 +4814,7 @@ class HTMLBodyOnlyElementsVisitor extends BaseRuleVisitor {
 }
 class HTMLBodyOnlyElementsRule extends ParserRule {
     static autocorrectable = false;
-    name = "html-body-only-elements";
+    static ruleName = "html-body-only-elements";
     get defaultConfig() {
         return {
             enabled: true,
@@ -3375,7 +4823,56 @@ class HTMLBodyOnlyElementsRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new HTMLBodyOnlyElementsVisitor(this.name, context);
+        const visitor = new HTMLBodyOnlyElementsVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class DetailsHasSummaryVisitor extends BaseRuleVisitor {
+    visitHTMLElementNode(node) {
+        this.checkDetailsElement(node);
+        super.visitHTMLElementNode(node);
+    }
+    checkDetailsElement(node) {
+        const tagName = getTagLocalName(node);
+        if (tagName !== "details") {
+            return;
+        }
+        if (!this.hasDirectSummaryChild(node)) {
+            this.addOffense("`<details>` element must have a direct `<summary>` child element.", node.location);
+        }
+    }
+    hasDirectSummaryChild(node) {
+        if (!node.body || node.body.length === 0) {
+            return false;
+        }
+        for (const child of node.body) {
+            if (isHTMLElementNode(child)) {
+                const childTagName = getTagLocalName(child);
+                if (childTagName === "summary") {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+class HTMLDetailsHasSummaryRule extends ParserRule {
+    static ruleName = "html-details-has-summary";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "warning"
+        };
+    }
+    get parserOptions() {
+        return {
+            action_view_helpers: true,
+        };
+    }
+    check(result, context) {
+        const visitor = new DetailsHasSummaryVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3400,7 +4897,7 @@ class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
 }
 class HTMLBooleanAttributesNoValueRule extends ParserRule {
     static autocorrectable = true;
-    name = "html-boolean-attributes-no-value";
+    static ruleName = "html-boolean-attributes-no-value";
     get defaultConfig() {
         return {
             enabled: true,
@@ -3408,7 +4905,7 @@ class HTMLBooleanAttributesNoValueRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new BooleanAttributesNoValueVisitor(this.name, context);
+        const visitor = new BooleanAttributesNoValueVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3425,7 +4922,7 @@ class HTMLBooleanAttributesNoValueRule extends ParserRule {
 class HeadOnlyElementsVisitor extends BaseRuleVisitor {
     elementStack = [];
     visitHTMLElementNode(node) {
-        const tagName = getTagName(node)?.toLowerCase();
+        const tagName = getTagLocalName(node);
         if (!tagName)
             return;
         this.checkHeadOnlyElement(node, tagName);
@@ -3449,7 +4946,7 @@ class HeadOnlyElementsVisitor extends BaseRuleVisitor {
         this.addOffense(`Element \`<${tagName}>\` must be placed inside the \`<head>\` tag.`, node.location);
     }
     hasItempropAttribute(node) {
-        return hasAttribute(node.open_tag, "itemprop");
+        return hasAttribute(node, "itemprop");
     }
     get insideHead() {
         return this.elementStack.includes("head");
@@ -3463,7 +4960,7 @@ class HeadOnlyElementsVisitor extends BaseRuleVisitor {
 }
 class HTMLHeadOnlyElementsRule extends ParserRule {
     static autocorrectable = false;
-    name = "html-head-only-elements";
+    static ruleName = "html-head-only-elements";
     get defaultConfig() {
         return {
             enabled: true,
@@ -3472,7 +4969,7 @@ class HTMLHeadOnlyElementsRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new HeadOnlyElementsVisitor(this.name, context);
+        const visitor = new HeadOnlyElementsVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3484,16 +4981,12 @@ class IframeHasTitleVisitor extends BaseRuleVisitor {
         super.visitHTMLOpenTagNode(node);
     }
     checkIframeElement(node) {
-        const tagName = getTagName(node);
+        const tagName = getTagLocalName(node);
         if (tagName !== "iframe") {
             return;
         }
-        const ariaHiddenAttribute = getAttribute(node, "aria-hidden");
-        if (ariaHiddenAttribute) {
-            const ariaHiddenValue = getAttributeValue(ariaHiddenAttribute);
-            if (ariaHiddenValue === "true") {
-                return;
-            }
+        if (getStaticAttributeValue(node, "aria-hidden") === "true") {
+            return;
         }
         const attribute = getAttribute(node, "title");
         if (!attribute) {
@@ -3507,15 +5000,15 @@ class IframeHasTitleVisitor extends BaseRuleVisitor {
     }
 }
 class HTMLIframeHasTitleRule extends ParserRule {
-    name = "html-iframe-has-title";
+    static ruleName = "html-iframe-has-title";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new IframeHasTitleVisitor(this.name, context);
+        const visitor = new IframeHasTitleVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3527,25 +5020,30 @@ class ImgRequireAltVisitor extends BaseRuleVisitor {
         super.visitHTMLOpenTagNode(node);
     }
     checkImgTag(node) {
-        const tagName = getTagName(node);
+        const tagName = getTagLocalName(node);
         if (tagName !== "img") {
             return;
         }
         if (!hasAttribute(node, "alt")) {
             this.addOffense('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.', node.tag_name.location);
+            return;
+        }
+        const altAttribute = getAttribute(node, "alt");
+        if (altAttribute && !hasAttributeValue(altAttribute)) {
+            this.addOffense('The `alt` attribute has no value. Add `alt=""` for decorative images or `alt="description"` for informative images.', altAttribute.location);
         }
     }
 }
 class HTMLImgRequireAltRule extends ParserRule {
-    name = "html-img-require-alt";
+    static ruleName = "html-img-require-alt";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new ImgRequireAltVisitor(this.name, context);
+        const visitor = new ImgRequireAltVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3574,10 +5072,7 @@ class HTMLInputRequireAutocompleteVisitor extends BaseRuleVisitor {
     checkInputTag(node) {
         if (!this.isInputTag(node) || this.hasAutocomplete(node))
             return;
-        const typeAttribute = getAttribute(node, "type");
-        if (!typeAttribute)
-            return;
-        const typeValue = getStaticAttributeValueContent(typeAttribute);
+        const typeValue = getStaticAttributeValue(node, "type");
         if (!typeValue)
             return;
         if (!this.HTML_INPUT_TYPES_REQUIRING_AUTOCOMPLETE.has(typeValue))
@@ -3594,7 +5089,7 @@ class HTMLInputRequireAutocompleteVisitor extends BaseRuleVisitor {
         return true;
     }
     isInputTag(node) {
-        const tagName = getTagName$1(node);
+        const tagName = getTagLocalName(node);
         if (tagName === "input") {
             return true;
         }
@@ -3604,15 +5099,15 @@ class HTMLInputRequireAutocompleteVisitor extends BaseRuleVisitor {
     }
 }
 class HTMLInputRequireAutocompleteRule extends ParserRule {
-    name = "html-input-require-autocomplete";
+    static ruleName = "html-input-require-autocomplete";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new HTMLInputRequireAutocompleteVisitor(this.name, context);
+        const visitor = new HTMLInputRequireAutocompleteVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3624,7 +5119,7 @@ class NavigationHasLabelVisitor extends BaseRuleVisitor {
         super.visitHTMLOpenTagNode(node);
     }
     checkNavigationElement(node) {
-        const tagName = getTagName(node);
+        const tagName = getTagLocalName(node);
         const isNavElement = tagName === "nav";
         const hasNavigationRole = this.hasRoleNavigation(node);
         if (!isNavElement && !hasNavigationRole) {
@@ -3651,15 +5146,81 @@ class NavigationHasLabelVisitor extends BaseRuleVisitor {
     }
 }
 class HTMLNavigationHasLabelRule extends ParserRule {
-    name = "html-navigation-has-label";
+    static ruleName = "html-navigation-has-label";
     get defaultConfig() {
         return {
             enabled: false,
-            severity: "error"
+            severity: "warning"
+        };
+    }
+    check(result, context) {
+        const visitor = new NavigationHasLabelVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class NoAbstractRolesVisitor extends AttributeVisitorMixin {
+    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }) {
+        if (attributeName !== "role")
+            return;
+        if (!attributeValue)
+            return;
+        const normalizedValue = attributeValue.toLowerCase();
+        if (!ABSTRACT_ARIA_ROLES.has(normalizedValue))
+            return;
+        this.addOffense(`The \`role\` attribute must not use abstract ARIA role \`${attributeValue}\`. Abstract roles are not meant to be used directly.`, attributeNode.location);
+    }
+}
+class HTMLNoAbstractRolesRule extends ParserRule {
+    static ruleName = "html-no-abstract-roles";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "warning"
+        };
+    }
+    check(result, context) {
+        const visitor = new NoAbstractRolesVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class NoAriaHiddenBodyVisitor extends BaseRuleVisitor {
+    visitHTMLOpenTagNode(node) {
+        this.checkAriaHiddenOnBody(node);
+        super.visitHTMLOpenTagNode(node);
+    }
+    checkAriaHiddenOnBody(node) {
+        const tagName = getTagLocalName(node);
+        if (tagName !== "body")
+            return;
+        if (this.hasAriaHidden(node)) {
+            this.addOffense("The `aria-hidden` attribute should never be present on the `<body>` element, as it hides the entire document from assistive technology users.", node.tag_name.location);
+        }
+    }
+    hasAriaHidden(node) {
+        if (!hasAttribute(node, "aria-hidden"))
+            return false;
+        const attributes = getAttributes(node);
+        const ariaHiddenAttr = findAttributeByName(attributes, "aria-hidden");
+        if (!ariaHiddenAttr)
+            return false;
+        const value = getAttributeValue(ariaHiddenAttr);
+        return value === null || value === "" || value === "true";
+    }
+}
+class HTMLNoAriaHiddenOnBodyRule extends ParserRule {
+    static ruleName = "html-no-aria-hidden-on-body";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new NavigationHasLabelVisitor(this.name, context);
+        const visitor = new NoAriaHiddenBodyVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3689,7 +5250,7 @@ class NoAriaHiddenOnFocusableVisitor extends BaseRuleVisitor {
         return value === "true";
     }
     isFocusable(node) {
-        const tagName = getTagName(node);
+        const tagName = getTagLocalName(node);
         if (!tagName)
             return false;
         const tabIndexValue = this.getTabIndexValue(node);
@@ -3722,15 +5283,15 @@ class NoAriaHiddenOnFocusableVisitor extends BaseRuleVisitor {
     }
 }
 class HTMLNoAriaHiddenOnFocusableRule extends ParserRule {
-    name = "html-no-aria-hidden-on-focusable";
+    static ruleName = "html-no-aria-hidden-on-focusable";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new NoAriaHiddenOnFocusableVisitor(this.name, context);
+        const visitor = new NoAriaHiddenOnFocusableVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3738,9 +5299,6 @@ class HTMLNoAriaHiddenOnFocusableRule extends ParserRule {
 
 class BlockInsideInlineVisitor extends BaseRuleVisitor {
     inlineStack = [];
-    isValidHTMLOpenTag(node) {
-        return !!(node.open_tag && node.open_tag.type === "AST_HTML_OPEN_TAG_NODE");
-    }
     getElementType(tagName) {
         const isInline = isInlineElement(tagName);
         const isBlock = isBlockElement(tagName);
@@ -3764,19 +5322,18 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
         this.inlineStack = savedStack;
     }
     visitHTMLElementNode(node) {
-        if (!this.isValidHTMLOpenTag(node)) {
+        if (!isHTMLOpenTagNode(node.open_tag)) {
             super.visitHTMLElementNode(node);
             return;
         }
-        const openTag = node.open_tag;
-        const tagName = openTag.tag_name?.value.toLowerCase();
+        const tagName = node.open_tag.tag_name?.value.toLowerCase();
         if (!tagName) {
             super.visitHTMLElementNode(node);
             return;
         }
         const { isInline, isBlock, isUnknown } = this.getElementType(tagName);
         if ((isBlock || isUnknown) && this.inlineStack.length > 0) {
-            this.addOffenseMessage(tagName, isBlock, openTag);
+            this.addOffenseMessage(tagName, isBlock, node.open_tag);
         }
         if (isInline) {
             this.visitInlineElement(node, tagName);
@@ -3786,7 +5343,7 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
     }
 }
 class HTMLNoBlockInsideInlineRule extends ParserRule {
-    name = "html-no-block-inside-inline";
+    static ruleName = "html-no-block-inside-inline";
     get defaultConfig() {
         return {
             enabled: false,
@@ -3794,7 +5351,7 @@ class HTMLNoBlockInsideInlineRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new BlockInsideInlineVisitor(this.name, context);
+        const visitor = new BlockInsideInlineVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3901,7 +5458,7 @@ class NoDuplicateAttributesVisitor extends ControlFlowTrackingVisitor {
     }
 }
 class HTMLNoDuplicateAttributesRule extends ParserRule {
-    name = "html-no-duplicate-attributes";
+    static ruleName = "html-no-duplicate-attributes";
     get defaultConfig() {
         return {
             enabled: true,
@@ -3909,7 +5466,7 @@ class HTMLNoDuplicateAttributesRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new NoDuplicateAttributesVisitor(this.name, context);
+        const visitor = new NoDuplicateAttributesVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -3977,34 +5534,35 @@ class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor {
     }
     extractIdValue(attributeNode) {
         const valueNodes = attributeNode.value?.children || [];
-        if (hasERBOutput(valueNodes) && this.isInControlFlow && this.currentControlFlowType === ControlFlowType.LOOP) {
+        const isDynamic = hasERBOutput(valueNodes);
+        if (isDynamic && this.isInControlFlow && this.currentControlFlowType === ControlFlowType.LOOP) {
             return null;
         }
         const identifier = isEffectivelyStatic(valueNodes) ? getValidatableStaticContent(valueNodes) : OutputPrinter.print(valueNodes);
         if (!identifier)
             return null;
-        return { identifier, shouldTrackDuplicates: true };
+        return { identifier, shouldTrackDuplicates: true, isDynamic };
     }
     isWhitespaceOnlyId(identifier) {
         return identifier !== '' && identifier.trim() === '';
     }
     processIdDuplicate(idValue, attributeNode) {
-        const { identifier, shouldTrackDuplicates } = idValue;
+        const { identifier, shouldTrackDuplicates, isDynamic } = idValue;
         if (!shouldTrackDuplicates)
             return;
         if (this.isInControlFlow) {
-            this.handleControlFlowId(identifier, attributeNode);
+            this.handleControlFlowId(identifier, attributeNode, isDynamic);
         }
         else {
             this.handleGlobalId(identifier, attributeNode);
         }
     }
-    handleControlFlowId(identifier, attributeNode) {
+    handleControlFlowId(identifier, attributeNode, isDynamic) {
         if (this.currentControlFlowType === ControlFlowType.LOOP) {
             this.handleLoopId(identifier, attributeNode);
         }
         else {
-            this.handleConditionalId(identifier, attributeNode);
+            this.handleConditionalId(identifier, attributeNode, isDynamic);
         }
         this.currentBranchIds.add(identifier);
     }
@@ -4018,16 +5576,18 @@ class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor {
             this.addSameLoopIterationOffense(identifier, attributeNode.location);
         }
     }
-    handleConditionalId(identifier, attributeNode) {
+    handleConditionalId(identifier, attributeNode, isDynamic) {
         if (this.currentBranchIds.has(identifier)) {
             this.addSameBranchOffense(identifier, attributeNode.location);
             return;
         }
-        if (this.documentIds.has(identifier)) {
+        if (!isDynamic && this.documentIds.has(identifier)) {
             this.addDuplicateIdOffense(identifier, attributeNode.location);
             return;
         }
-        this.controlFlowIds.add(identifier);
+        if (!isDynamic) {
+            this.controlFlowIds.add(identifier);
+        }
     }
     handleGlobalId(identifier, attributeNode) {
         if (this.documentIds.has(identifier)) {
@@ -4053,7 +5613,7 @@ class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor {
     }
 }
 class HTMLNoDuplicateIdsRule extends ParserRule {
-    name = "html-no-duplicate-ids";
+    static ruleName = "html-no-duplicate-ids";
     get defaultConfig() {
         return {
             enabled: true,
@@ -4061,7 +5621,7 @@ class HTMLNoDuplicateIdsRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new NoDuplicateIdsVisitor(this.name, context);
+        const visitor = new NoDuplicateIdsVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4073,7 +5633,7 @@ class HTMLNoDuplicateMetaNamesVisitor extends ControlFlowTrackingVisitor {
     currentBranchMetas = [];
     controlFlowMetas = [];
     visitHTMLElementNode(node) {
-        const tagName = getTagName(node)?.toLowerCase();
+        const tagName = getTagLocalName(node);
         if (!tagName)
             return;
         if (tagName === "head") {
@@ -4133,21 +5693,23 @@ class HTMLNoDuplicateMetaNamesVisitor extends ControlFlowTrackingVisitor {
         this.currentBranchMetas.push(metaTag);
     }
     extractAttributes(node, metaTag) {
-        if (isHTMLElementNode(node) && node.open_tag) {
-            forEachAttribute(node.open_tag, (attributeNode) => {
-                const name = getAttributeName(attributeNode);
-                const value = getAttributeValue(attributeNode)?.trim();
-                if (name === "name" && value) {
-                    metaTag.nameValue = value;
-                }
-                else if (name === "http-equiv" && value) {
-                    metaTag.httpEquivValue = value;
-                }
-                else if (name === "media" && value) {
-                    metaTag.mediaValue = value;
-                }
-            });
-        }
+        if (!isHTMLElementNode(node))
+            return;
+        if (!isHTMLOpenTagNode(node.open_tag))
+            return;
+        forEachAttribute(node.open_tag, (attributeNode) => {
+            const name = getAttributeName(attributeNode);
+            const value = getAttributeValue(attributeNode)?.trim();
+            if (name === "name" && value) {
+                metaTag.nameValue = value;
+            }
+            else if (name === "http-equiv" && value) {
+                metaTag.httpEquivValue = value;
+            }
+            else if (name === "media" && value) {
+                metaTag.mediaValue = value;
+            }
+        });
     }
     handleControlFlowMeta(metaTag) {
         if (this.currentControlFlowType === ControlFlowType.LOOP) {
@@ -4196,7 +5758,7 @@ class HTMLNoDuplicateMetaNamesVisitor extends ControlFlowTrackingVisitor {
 }
 class HTMLNoDuplicateMetaNamesRule extends ParserRule {
     static autocorrectable = false;
-    name = "html-no-duplicate-meta-names";
+    static ruleName = "html-no-duplicate-meta-names";
     get defaultConfig() {
         return {
             enabled: true,
@@ -4204,7 +5766,7 @@ class HTMLNoDuplicateMetaNamesRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new HTMLNoDuplicateMetaNamesVisitor(this.name, context);
+        const visitor = new HTMLNoDuplicateMetaNamesVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4296,7 +5858,7 @@ class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
     }
 }
 class HTMLNoEmptyAttributesRule extends ParserRule {
-    name = "html-no-empty-attributes";
+    static ruleName = "html-no-empty-attributes";
     get defaultConfig() {
         return {
             enabled: true,
@@ -4304,7 +5866,7 @@ class HTMLNoEmptyAttributesRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new NoEmptyAttributesVisitor(this.name, context);
+        const visitor = new NoEmptyAttributesVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4312,22 +5874,18 @@ class HTMLNoEmptyAttributesRule extends ParserRule {
 
 class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
     visitHTMLElementNode(node) {
-        const tagName = getTagName(node.open_tag)?.toLowerCase();
+        const tagName = getTagLocalName(node);
         if (tagName === "template")
             return;
         this.checkHeadingElement(node);
         super.visitHTMLElementNode(node);
     }
     checkHeadingElement(node) {
-        if (!node.open_tag)
-            return;
-        if (!isHTMLOpenTagNode(node.open_tag))
-            return;
-        const tagName = getTagName(node.open_tag);
+        const tagName = getTagLocalName(node);
         if (!tagName)
             return;
         const isStandardHeading = HEADING_TAGS.has(tagName);
-        const isAriaHeading = this.hasHeadingRole(node.open_tag);
+        const isAriaHeading = this.hasHeadingRole(node);
         if (!isStandardHeading && !isAriaHeading) {
             return;
         }
@@ -4342,81 +5900,67 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
         if (!node.body || node.body.length === 0) {
             return true;
         }
-        let hasAccessibleContent = false;
-        for (const child of node.body) {
+        return !this.hasAccessibleContent(node.body);
+    }
+    hasAccessibleContent(nodes) {
+        for (const child of nodes) {
             if (isLiteralNode(child) || isHTMLTextNode(child)) {
                 if (child.content.trim().length > 0) {
-                    hasAccessibleContent = true;
-                    break;
+                    return true;
                 }
             }
             else if (isHTMLElementNode(child)) {
                 if (this.isElementAccessible(child)) {
-                    hasAccessibleContent = true;
-                    break;
+                    return true;
                 }
             }
-            else {
-                hasAccessibleContent = true;
-                break;
+            else if (isERBOutputNode(child)) {
+                return true;
+            }
+            else if (isERBControlFlowNode(child)) {
+                if (this.hasAccessibleContentInControlFlow(child)) {
+                    return true;
+                }
             }
         }
-        return !hasAccessibleContent;
+        return false;
     }
-    hasHeadingRole(node) {
-        const attributes = getAttributes(node);
-        const roleAttribute = findAttributeByName(attributes, "role");
-        if (!roleAttribute) {
-            return false;
+    hasAccessibleContentInControlFlow(node) {
+        const nodeWithStatements = node;
+        if (nodeWithStatements.statements && this.hasAccessibleContent(nodeWithStatements.statements)) {
+            return true;
         }
-        const roleValue = getAttributeValue(roleAttribute);
-        return roleValue === "heading";
+        if (nodeWithStatements.body && this.hasAccessibleContent(nodeWithStatements.body)) {
+            return true;
+        }
+        if (nodeWithStatements.subsequent) {
+            return this.hasAccessibleContentInControlFlow(nodeWithStatements.subsequent);
+        }
+        return false;
+    }
+    hasHeadingRole(node) {
+        return getStaticAttributeValue(node, "role") === "heading";
     }
     isElementAccessible(node) {
-        if (!node.open_tag)
-            return true;
-        if (!isHTMLOpenTagNode(node.open_tag))
-            return true;
-        const attributes = getAttributes(node.open_tag);
-        const ariaHiddenAttribute = findAttributeByName(attributes, "aria-hidden");
-        if (ariaHiddenAttribute) {
-            const ariaHiddenValue = getAttributeValue(ariaHiddenAttribute);
-            if (ariaHiddenValue === "true") {
-                return false;
-            }
+        if (getStaticAttributeValue(node, "aria-hidden") === "true") {
+            return false;
         }
         if (!node.body || node.body.length === 0) {
             return false;
         }
-        for (const child of node.body) {
-            if (isLiteralNode(child) || isHTMLTextNode(child)) {
-                if (child.content.trim().length > 0) {
-                    return true;
-                }
-            }
-            else if (isHTMLElementNode(child)) {
-                if (this.isElementAccessible(child)) {
-                    return true;
-                }
-            }
-            else {
-                // If there's any non-literal/non-text/non-element content (like ERB), consider it accessible
-                return true;
-            }
-        }
-        return false;
+        return this.hasAccessibleContent(node.body);
     }
 }
 class HTMLNoEmptyHeadingsRule extends ParserRule {
-    name = "html-no-empty-headings";
+    static ruleName = "html-no-empty-headings";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new NoEmptyHeadingsVisitor(this.name, context);
+        const visitor = new NoEmptyHeadingsVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4432,25 +5976,32 @@ class NestedLinkVisitor extends BaseRuleVisitor {
         return false;
     }
     visitHTMLElementNode(node) {
-        if (!node.open_tag || node.open_tag.type !== "AST_HTML_OPEN_TAG_NODE") {
+        if (!node.open_tag) {
             super.visitHTMLElementNode(node);
             return;
         }
-        const openTag = node.open_tag;
-        const tagName = getTagName(openTag);
-        if (tagName !== "a") {
-            super.visitHTMLElementNode(node);
-            return;
+        switch (node.open_tag.type) {
+            case "AST_HTML_OPEN_TAG_NODE": {
+                const openTag = node.open_tag;
+                const tagName = getTagLocalName(openTag);
+                if (tagName !== "a") {
+                    super.visitHTMLElementNode(node);
+                    return;
+                }
+                this.checkNestedLink(openTag);
+                this.linkStack.push(openTag);
+                super.visitHTMLElementNode(node);
+                this.linkStack.pop();
+                break;
+            }
+            case "AST_HTML_CONDITIONAL_OPEN_TAG_NODE":
+                super.visitHTMLElementNode(node);
+                break;
         }
-        // If we're already inside a link, this is a nested link
-        this.checkNestedLink(openTag);
-        this.linkStack.push(openTag);
-        super.visitHTMLElementNode(node);
-        this.linkStack.pop();
     }
     // Handle self-closing <a> tags (though they're not valid HTML, they might exist)
     visitHTMLOpenTagNode(node) {
-        const tagName = getTagName(node);
+        const tagName = getTagLocalName(node);
         if (tagName === "a" && node.is_void) {
             this.checkNestedLink(node);
         }
@@ -4458,7 +6009,7 @@ class NestedLinkVisitor extends BaseRuleVisitor {
     }
 }
 class HTMLNoNestedLinksRule extends ParserRule {
-    name = "html-no-nested-links";
+    static ruleName = "html-no-nested-links";
     get defaultConfig() {
         return {
             enabled: true,
@@ -4466,7 +6017,7 @@ class HTMLNoNestedLinksRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new NestedLinkVisitor(this.name, context);
+        const visitor = new NestedLinkVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4483,15 +6034,15 @@ class NoPositiveTabIndexVisitor extends AttributeVisitorMixin {
     }
 }
 class HTMLNoPositiveTabIndexRule extends ParserRule {
-    name = "html-no-positive-tab-index";
+    static ruleName = "html-no-positive-tab-index";
     get defaultConfig() {
         return {
             enabled: true,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new NoPositiveTabIndexVisitor(this.name, context);
+        const visitor = new NoPositiveTabIndexVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4499,7 +6050,7 @@ class HTMLNoPositiveTabIndexRule extends ParserRule {
 
 class NoSelfClosingVisitor extends BaseRuleVisitor {
     visitHTMLElementNode(node) {
-        if (getTagName$1(node) === "svg") {
+        if (getTagLocalName(node) === "svg") {
             this.visit(node.open_tag);
         }
         else {
@@ -4508,7 +6059,7 @@ class NoSelfClosingVisitor extends BaseRuleVisitor {
     }
     visitHTMLOpenTagNode(node) {
         if (node.tag_closing?.value === "/>") {
-            const tagName = getTagName$1(node);
+            const tagName = getTagName(node);
             const instead = isVoidElement(tagName) ? `<${tagName}>` : `<${tagName}></${tagName}>`;
             this.addOffense(`Use \`${instead}\` instead of self-closing \`<${tagName} />\` for HTML compatibility.`, node.location, {
                 node,
@@ -4520,7 +6071,7 @@ class NoSelfClosingVisitor extends BaseRuleVisitor {
 }
 class HTMLNoSelfClosingRule extends ParserRule {
     static autocorrectable = true;
-    name = "html-no-self-closing";
+    static ruleName = "html-no-self-closing";
     get defaultConfig() {
         return {
             enabled: true,
@@ -4529,7 +6080,7 @@ class HTMLNoSelfClosingRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new NoSelfClosingVisitor(this.name, context);
+        const visitor = new NoSelfClosingVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4677,7 +6228,7 @@ class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor {
 class HTMLNoSpaceInTagRule extends ParserRule {
     // TODO: enable and fix autofix
     static autocorrectable = false;
-    name = "html-no-space-in-tag";
+    static ruleName = "html-no-space-in-tag";
     get defaultConfig() {
         return {
             enabled: false,
@@ -4685,7 +6236,7 @@ class HTMLNoSpaceInTagRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new HTMLNoSpaceInTagVisitor(this.name, context);
+        const visitor = new HTMLNoSpaceInTagVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4696,9 +6247,7 @@ class HTMLNoSpaceInTagRule extends ParserRule {
         if (!node)
             return null;
         if (isHTMLOpenTagNode(node)) {
-            const token = Token.from({ type: "TOKEN_WHITESPACE", value: " ", range: [0, 0], location: Location.zero });
-            const whitespace = new WhitespaceNode({ type: "AST_WHITESPACE_NODE", value: token, location: Location.zero, errors: [] });
-            node.children.push(whitespace);
+            node.children.push(createWhitespaceNode());
             return result;
         }
         if (!isWhitespaceNode(node))
@@ -4744,7 +6293,7 @@ class NoTitleAttributeVisitor extends BaseRuleVisitor {
         super.visitHTMLOpenTagNode(node);
     }
     checkTitleAttribute(node) {
-        const tagName = getTagName(node);
+        const tagName = getTagLocalName(node);
         if (!tagName || this.ALLOWED_ELEMENTS_WITH_TITLE.has(tagName)) {
             return;
         }
@@ -4754,15 +6303,15 @@ class NoTitleAttributeVisitor extends BaseRuleVisitor {
     }
 }
 class HTMLNoTitleAttributeRule extends ParserRule {
-    name = "html-no-title-attribute";
+    static ruleName = "html-no-title-attribute";
     get defaultConfig() {
         return {
             enabled: false,
-            severity: "error"
+            severity: "warning"
         };
     }
     check(result, context) {
-        const visitor = new NoTitleAttributeVisitor(this.name, context);
+        const visitor = new NoTitleAttributeVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4792,7 +6341,7 @@ class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
     }
 }
 class HTMLNoUnderscoresInAttributeNamesRule extends ParserRule {
-    name = "html-no-underscores-in-attribute-names";
+    static ruleName = "html-no-underscores-in-attribute-names";
     get defaultConfig() {
         return {
             enabled: true,
@@ -4800,7 +6349,34 @@ class HTMLNoUnderscoresInAttributeNamesRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new HTMLNoUnderscoresInAttributeNamesVisitor(this.name, context);
+        const visitor = new HTMLNoUnderscoresInAttributeNamesVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class RequireClosingTagsVisitor extends BaseRuleVisitor {
+    visitHTMLOmittedCloseTagNode(node) {
+        const tagName = node.tag_name?.value;
+        if (!tagName)
+            return;
+        this.addOffense(`Missing explicit closing tag for \`<${tagName}>\`. Use \`</${tagName}>\` instead of relying on implicit tag closing.`, node.location);
+    }
+}
+class HTMLRequireClosingTagsRule extends ParserRule {
+    static autocorrectable = false;
+    static ruleName = "html-require-closing-tags";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error",
+        };
+    }
+    get parserOptions() {
+        return { strict: false };
+    }
+    check(result, context) {
+        const visitor = new RequireClosingTagsVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4819,9 +6395,11 @@ class XMLDeclarationChecker extends BaseRuleVisitor {
 }
 class TagNameLowercaseVisitor extends BaseRuleVisitor {
     visitHTMLElementNode(node) {
-        if (getTagName$1(node).toLowerCase() === "svg") {
-            this.checkTagName(node.open_tag);
-            this.checkTagName(node.close_tag);
+        if (getTagLocalName(node) === "svg") {
+            this.checkTagName(getOpenTag(node));
+            if (node.close_tag && isHTMLCloseTagNode(node.close_tag)) {
+                this.checkTagName(node.close_tag);
+            }
         }
         else {
             super.visitHTMLElementNode(node);
@@ -4836,7 +6414,7 @@ class TagNameLowercaseVisitor extends BaseRuleVisitor {
     checkTagName(node) {
         if (!node)
             return;
-        const tagName = getTagName$1(node);
+        const tagName = getTagName(node);
         if (!tagName)
             return;
         const lowercaseTagName = tagName.toLowerCase();
@@ -4853,7 +6431,7 @@ class TagNameLowercaseVisitor extends BaseRuleVisitor {
 }
 class HTMLTagNameLowercaseRule extends ParserRule {
     static autocorrectable = true;
-    name = "html-tag-name-lowercase";
+    static ruleName = "html-tag-name-lowercase";
     get defaultConfig() {
         return {
             enabled: true,
@@ -4862,12 +6440,12 @@ class HTMLTagNameLowercaseRule extends ParserRule {
         };
     }
     isEnabled(result, _context) {
-        const checker = new XMLDeclarationChecker(this.name);
+        const checker = new XMLDeclarationChecker(this.ruleName);
         checker.visit(result.value);
         return !checker.hasXMLDeclaration;
     }
     check(result, context) {
-        const visitor = new TagNameLowercaseVisitor(this.name, context);
+        const visitor = new TagNameLowercaseVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4889,14 +6467,39 @@ class HTMLTagNameLowercaseRule extends ParserRule {
                 closeTag.tag_name.value = correctedTagName;
                 break;
             case "AST_HTML_CLOSE_TAG_NODE":
-                const openTag = parentElement.open_tag;
-                openTag.tag_name.value = correctedTagName;
+                const openTag = getOpenTag(parentElement);
+                if (openTag?.tag_name) {
+                    openTag.tag_name.value = correctedTagName;
+                }
                 break;
         }
         return result;
     }
 }
 
+class ParserNoErrorsRule extends ParserRule {
+    static ruleName = "parser-no-errors";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result) {
+        return result.recursiveErrors().map(error => this.herbErrorToLintOffense(error));
+    }
+    herbErrorToLintOffense(error) {
+        return {
+            message: `${error.message} (\`${error.type}\`)`,
+            location: error.location,
+            severity: error.severity,
+            rule: this.ruleName,
+            code: this.ruleName,
+            source: "linter"
+        };
+    }
+}
+
 class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
     insideSVG = false;
     visitHTMLElementNode(node) {
@@ -4909,10 +6512,10 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
             return;
         }
         if (this.insideSVG) {
-            if (node.open_tag) {
+            if (isHTMLOpenTagNode(node.open_tag)) {
                 this.checkTagName(node.open_tag);
             }
-            if (node.close_tag) {
+            if (node.close_tag && isHTMLCloseTagNode(node.close_tag)) {
                 this.checkTagName(node.close_tag);
             }
         }
@@ -4928,9 +6531,9 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
         const correctCamelCase = SVG_LOWERCASE_TO_CAMELCASE.get(lowercaseTagName);
         if (correctCamelCase && tagName !== correctCamelCase) {
             let type = node.type;
-            if (node.type === "AST_HTML_OPEN_TAG_NODE")
+            if (isHTMLOpenTagNode(node))
                 type = "Opening";
-            if (node.type === "AST_HTML_CLOSE_TAG_NODE")
+            if (isHTMLCloseTagNode(node))
                 type = "Closing";
             this.addOffense(`${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`, node.tag_name.location, {
                 node,
@@ -4942,7 +6545,7 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
 }
 class SVGTagNameCapitalizationRule extends ParserRule {
     static autocorrectable = true;
-    name = "svg-tag-name-capitalization";
+    static ruleName = "svg-tag-name-capitalization";
     get defaultConfig() {
         return {
             enabled: true,
@@ -4950,7 +6553,7 @@ class SVGTagNameCapitalizationRule extends ParserRule {
         };
     }
     check(result, context) {
-        const visitor = new SVGTagNameCapitalizationVisitor(this.name, context);
+        const visitor = new SVGTagNameCapitalizationVisitor(this.ruleName, context);
         visitor.visit(result.value);
         return visitor.offenses;
     }
@@ -4965,49 +6568,75 @@ class SVGTagNameCapitalizationRule extends ParserRule {
     }
 }
 
-class ParserNoErrorsRule extends ParserRule {
-    name = "parser-no-errors";
+class TurboPermanentRequireIdVisitor extends BaseRuleVisitor {
+    visitHTMLOpenTagNode(node) {
+        this.checkTurboPermanent(node);
+        super.visitHTMLOpenTagNode(node);
+    }
+    checkTurboPermanent(node) {
+        const turboPermanentAttribute = getAttribute(node, "data-turbo-permanent");
+        if (!turboPermanentAttribute) {
+            return;
+        }
+        const idAttribute = getAttribute(node, "id");
+        if (!idAttribute) {
+            this.addOffense("Elements with `data-turbo-permanent` must have an `id` attribute. Without an `id`, Turbo can't track the element across page changes and the permanent behavior won't work as expected.", turboPermanentAttribute.location);
+        }
+    }
+}
+class TurboPermanentRequireIdRule extends ParserRule {
+    static ruleName = "turbo-permanent-require-id";
     get defaultConfig() {
         return {
             enabled: true,
             severity: "error"
         };
     }
-    check(result) {
-        return result.recursiveErrors().map(error => this.herbErrorToLintOffense(error));
-    }
-    herbErrorToLintOffense(error) {
-        return {
-            message: `${error.message} (\`${error.type}\`)`,
-            location: error.location,
-            severity: error.severity,
-            rule: this.name,
-            code: this.name,
-            source: "linter"
-        };
+    check(result, context) {
+        const visitor = new TurboPermanentRequireIdVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
     }
 }
 
 const rules = [
+    ActionViewNoSilentHelperRule,
     ERBCommentSyntax,
     ERBNoCaseNodeChildrenRule,
+    ERBNoConditionalHTMLElementRule,
+    ERBNoConditionalOpenTagRule,
+    ERBNoDuplicateBranchElementsRule,
     ERBNoEmptyTagsRule,
     ERBNoExtraNewLineRule,
     ERBNoExtraWhitespaceRule,
+    ERBNoInlineCaseConditionsRule,
+    ERBNoInstanceVariablesInPartialsRule,
+    ERBNoInterpolatedClassNamesRule,
+    ERBNoJavascriptTagHelperRule,
     ERBNoOutputControlFlowRule,
+    ERBNoOutputInAttributeNameRule,
+    ERBNoOutputInAttributePositionRule,
+    ERBNoRawOutputInAttributeValueRule,
     ERBNoSilentTagInAttributeNameRule,
+    ERBNoStatementInScriptRule,
+    ERBNoThenInControlFlowRule,
+    ERBNoTrailingWhitespaceRule,
+    ERBNoUnsafeJSAttributeRule,
+    ERBNoUnsafeRawRule,
+    ERBNoUnsafeScriptInterpolationRule,
     ERBPreferImageTagHelperRule,
     ERBRequireTrailingNewlineRule,
     ERBRequireWhitespaceRule,
     ERBRightTrimRule,
     ERBStrictLocalsCommentSyntaxRule,
     ERBStrictLocalsRequiredRule,
-    HerbDisableCommentValidRuleNameRule,
-    HerbDisableCommentNoRedundantAllRule,
-    HerbDisableCommentNoDuplicateRulesRule,
-    HerbDisableCommentMissingRulesRule,
     HerbDisableCommentMalformedRule,
+    HerbDisableCommentMissingRulesRule,
+    HerbDisableCommentNoDuplicateRulesRule,
+    HerbDisableCommentNoRedundantAllRule,
     HerbDisableCommentUnnecessaryRule,
+    HerbDisableCommentValidRuleNameRule,
+    HTMLAllowedScriptTypeRule,
     HTMLAnchorRequireHrefRule,
     HTMLAriaAttributeMustBeValid,
     HTMLAriaLabelIsWellFormattedRule,
@@ -5019,12 +6648,15 @@ const rules = [
     HTMLAttributeValuesRequireQuotesRule,
     HTMLAvoidBothDisabledAndAriaDisabledRule,
     HTMLBodyOnlyElementsRule,
+    HTMLDetailsHasSummaryRule,
     HTMLBooleanAttributesNoValueRule,
     HTMLHeadOnlyElementsRule,
     HTMLIframeHasTitleRule,
     HTMLImgRequireAltRule,
     HTMLInputRequireAutocompleteRule,
     HTMLNavigationHasLabelRule,
+    HTMLNoAbstractRolesRule,
+    HTMLNoAriaHiddenOnBodyRule,
     HTMLNoAriaHiddenOnFocusableRule,
     HTMLNoBlockInsideInlineRule,
     HTMLNoDuplicateAttributesRule,
@@ -5038,9 +6670,11 @@ const rules = [
     HTMLNoSpaceInTagRule,
     HTMLNoTitleAttributeRule,
     HTMLNoUnderscoresInAttributeNamesRule,
+    HTMLRequireClosingTagsRule,
     HTMLTagNameLowercaseRule,
-    SVGTagNameCapitalizationRule,
     ParserNoErrorsRule,
+    SVGTagNameCapitalizationRule,
+    TurboPermanentRequireIdRule,
 ];
 
 const HERB_LINTER_PREFIX = "herb:linter";
@@ -5083,10 +6717,39 @@ class LinterIgnoreDetector extends Visitor {
     }
 }
 
+class ParseCache {
+    herb;
+    cache = new Map();
+    constructor(herb) {
+        this.herb = herb;
+    }
+    get(source, parserOptions = {}) {
+        const effectiveOptions = this.resolveOptions(parserOptions);
+        const key = source + JSON.stringify(effectiveOptions);
+        let result = this.cache.get(key);
+        if (!result) {
+            result = this.herb.parse(source, effectiveOptions);
+            this.cache.set(key, result);
+        }
+        return result;
+    }
+    clear() {
+        this.cache.clear();
+    }
+    resolveOptions(parserOptions) {
+        return {
+            ...DEFAULT_PARSER_OPTIONS,
+            ...DEFAULT_LINTER_PARSER_OPTIONS,
+            ...parserOptions
+        };
+    }
+}
+
 class Linter {
     rules;
     allAvailableRules;
     herb;
+    parseCache;
     offenses;
     config;
     /**
@@ -5117,6 +6780,7 @@ class Linter {
      */
     constructor(herb, rules, config, allAvailableRules) {
         this.herb = herb;
+        this.parseCache = new ParseCache(herb);
         this.config = config;
         this.rules = rules !== undefined ? rules : this.getDefaultRules();
         this.allAvailableRules = allAvailableRules !== undefined ? allAvailableRules : this.rules;
@@ -5136,9 +6800,8 @@ class Linter {
     static filterRulesByConfig(allRules, userRulesConfig) {
         return allRules.filter(ruleClass => {
             const instance = new ruleClass();
-            const ruleName = instance.name;
             const defaultEnabled = instance.defaultConfig?.enabled ?? DEFAULT_RULE_CONFIG.enabled;
-            const userRuleConfig = userRulesConfig?.[ruleName];
+            const userRuleConfig = userRulesConfig?.[ruleClass.ruleName];
             if (userRuleConfig !== undefined) {
                 return userRuleConfig.enabled !== false;
             }
@@ -5180,29 +6843,39 @@ class Linter {
     getRuleCount() {
         return this.rules.length;
     }
+    findRuleClass(ruleName) {
+        return this.rules.find(ruleClass => ruleClass.ruleName === ruleName);
+    }
     /**
-     * Type guard to check if a rule is a LexerRule
+     * Type guard to check if a rule class is a LexerRule class
      */
-    isLexerRule(rule) {
-        return rule.constructor.type === "lexer";
+    isLexerRuleClass(ruleClass) {
+        return ruleClass.type === "lexer";
     }
     /**
-     * Type guard to check if a rule is a SourceRule
+     * Type guard to check if a rule class is a SourceRule class
      */
-    isSourceRule(rule) {
-        return rule.constructor.type === "source";
+    isSourceRuleClass(ruleClass) {
+        return ruleClass.type === "source";
+    }
+    /**
+     * Type guard to check if a rule class is a ParserRule class
+     */
+    isParserRuleClass(ruleClass) {
+        return ruleClass.type === "parser" || ruleClass.type === undefined;
     }
     /**
      * Execute a single rule and return its unbound offenses.
      * Handles rule type checking (Lexer/Parser/Source) and isEnabled checks.
      */
-    executeRule(rule, parseResult, lexResult, source, context) {
+    executeRule(ruleClass, rule, parseResult, lexResult, source, context) {
+        const ruleName = rule.ruleName;
         if (this.config && context?.fileName) {
-            if (!this.config.isRuleEnabledForPath(rule.name, context.fileName)) {
+            if (!this.config.isRuleEnabledForPath(ruleName, context.fileName)) {
                 return [];
             }
         }
-        if (context?.fileName && !this.config?.linter?.rules?.[rule.name]?.exclude) {
+        if (context?.fileName && !this.config?.linter?.rules?.[ruleName]?.exclude) {
             const defaultExclude = rule.defaultConfig?.exclude ?? DEFAULT_RULE_CONFIG.exclude;
             if (defaultExclude && defaultExclude.length > 0) {
                 const isExcluded = defaultExclude.some(pattern => picomatch.isMatch(context.fileName, pattern));
@@ -5213,34 +6886,37 @@ class Linter {
         }
         let isEnabled = true;
         let ruleOffenses;
-        if (this.isLexerRule(rule)) {
-            if (rule.isEnabled) {
-                isEnabled = rule.isEnabled(lexResult, context);
+        if (this.isLexerRuleClass(ruleClass)) {
+            const lexerRule = rule;
+            if (lexerRule.isEnabled) {
+                isEnabled = lexerRule.isEnabled(lexResult, context);
             }
             if (isEnabled) {
-                ruleOffenses = rule.check(lexResult, context);
+                ruleOffenses = lexerRule.check(lexResult, context);
             }
             else {
                 ruleOffenses = [];
             }
         }
-        else if (this.isSourceRule(rule)) {
-            if (rule.isEnabled) {
-                isEnabled = rule.isEnabled(source, context);
+        else if (this.isSourceRuleClass(ruleClass)) {
+            const sourceRule = rule;
+            if (sourceRule.isEnabled) {
+                isEnabled = sourceRule.isEnabled(source, context);
             }
             if (isEnabled) {
-                ruleOffenses = rule.check(source, context);
+                ruleOffenses = sourceRule.check(source, context);
             }
             else {
                 ruleOffenses = [];
             }
         }
         else {
-            if (rule.isEnabled) {
-                isEnabled = rule.isEnabled(parseResult, context);
+            const parserRule = rule;
+            if (parserRule.isEnabled) {
+                isEnabled = parserRule.isEnabled(parseResult, context);
             }
             if (isEnabled) {
-                ruleOffenses = rule.check(parseResult, context);
+                ruleOffenses = parserRule.check(parseResult, context);
             }
             else {
                 ruleOffenses = [];
@@ -5292,7 +6968,7 @@ class Linter {
         this.offenses = [];
         let ignoredCount = 0;
         let wouldBeIgnoredCount = 0;
-        const parseResult = this.herb.parse(source, { track_whitespace: true });
+        const parseResult = this.parseCache.get(source);
         // Check for file-level ignore directive using visitor
         if (hasLinterIgnoreDirective(parseResult)) {
             return {
@@ -5310,20 +6986,12 @@ class Linter {
         const ignoredOffensesByLine = new Map();
         const herbDisableCache = new Map();
         if (hasParserErrors) {
-            const hasParserRule = this.rules.find(RuleClass => (new RuleClass()).name === "parser-no-errors");
+            const hasParserRule = this.findRuleClass("parser-no-errors");
             if (hasParserRule) {
                 const rule = new ParserNoErrorsRule();
                 const offenses = rule.check(parseResult);
                 this.offenses.push(...offenses);
             }
-            return {
-                offenses: this.offenses,
-                errors: this.offenses.filter(o => o.severity === "error").length,
-                warnings: this.offenses.filter(o => o.severity === "warning").length,
-                info: this.offenses.filter(o => o.severity === "info").length,
-                hints: this.offenses.filter(o => o.severity === "hint").length,
-                ignored: 0
-            };
         }
         for (let i = 0; i < sourceLines.length; i++) {
             const line = sourceLines[i];
@@ -5334,30 +7002,36 @@ class Linter {
         }
         context = {
             ...context,
-            validRuleNames: this.getAvailableRules().map(RuleClass => new RuleClass().name),
+            validRuleNames: this.getAvailableRules().map(ruleClass => ruleClass.ruleName),
             ignoredOffensesByLine
         };
-        const regularRules = this.rules.filter(RuleClass => {
-            const rule = new RuleClass();
-            return rule.name !== "herb-disable-comment-unnecessary";
-        });
-        for (const RuleClass of regularRules) {
-            const rule = new RuleClass();
-            const unboundOffenses = this.executeRule(rule, parseResult, lexResult, source, context);
-            const boundOffenses = this.bindSeverity(unboundOffenses, rule.name);
-            const { kept, ignored, wouldBeIgnored } = this.filterOffenses(boundOffenses, rule.name, ignoredOffensesByLine, herbDisableCache, context?.ignoreDisableComments);
+        const regularRules = this.rules.filter(ruleClass => ruleClass.ruleName !== "herb-disable-comment-unnecessary");
+        for (const ruleClass of regularRules) {
+            const rule = new ruleClass();
+            const parserOptions = this.isParserRuleClass(ruleClass) ? rule.parserOptions : {};
+            const parseResult = this.parseCache.get(source, parserOptions);
+            // Skip parser rules whose parse result has errors (parser-no-errors handled above)
+            // Skip lexer/source rules when the default parse has errors
+            if (this.isParserRuleClass(ruleClass)) {
+                if (parseResult.recursiveErrors().length > 0)
+                    continue;
+            }
+            else if (hasParserErrors) {
+                continue;
+            }
+            const unboundOffenses = this.executeRule(ruleClass, rule, parseResult, lexResult, source, context);
+            const boundOffenses = this.bindSeverity(unboundOffenses, ruleClass.ruleName);
+            const { kept, ignored, wouldBeIgnored } = this.filterOffenses(boundOffenses, ruleClass.ruleName, ignoredOffensesByLine, herbDisableCache, context?.ignoreDisableComments);
             ignoredCount += ignored.length;
             wouldBeIgnoredCount += wouldBeIgnored.length;
             this.offenses.push(...kept);
         }
-        const unnecessaryRuleClass = this.rules.find(RuleClass => {
-            const rule = new RuleClass();
-            return rule.name === "herb-disable-comment-unnecessary";
-        });
+        const unnecessaryRuleClass = this.findRuleClass("herb-disable-comment-unnecessary");
         if (unnecessaryRuleClass) {
             const unnecessaryRule = new unnecessaryRuleClass();
+            const parseResult = this.parseCache.get(source, unnecessaryRule.parserOptions);
             const unboundOffenses = unnecessaryRule.check(parseResult, context);
-            const boundOffenses = this.bindSeverity(unboundOffenses, unnecessaryRule.name);
+            const boundOffenses = this.bindSeverity(unboundOffenses, unnecessaryRuleClass.ruleName);
             this.offenses.push(...boundOffenses);
         }
         const finalOffenses = this.offenses;
@@ -5390,23 +7064,20 @@ class Linter {
      * @returns Array of offenses with severity bound
      */
     bindSeverity(unboundOffenses, ruleName) {
-        const RuleClass = this.rules.find(rule => {
-            const instance = new rule();
-            return instance.name === ruleName;
-        });
-        if (!RuleClass) {
+        const ruleClass = this.findRuleClass(ruleName);
+        if (!ruleClass) {
             return unboundOffenses.map(offense => ({
                 ...offense,
                 severity: "error"
             }));
         }
-        const ruleInstance = new RuleClass();
+        const ruleInstance = new ruleClass();
         const defaultSeverity = ruleInstance.defaultConfig?.severity ?? DEFAULT_RULE_CONFIG.severity;
         const userRuleConfig = this.config?.linter?.rules?.[ruleName];
         const severity = userRuleConfig?.severity ?? defaultSeverity;
         return unboundOffenses.map(offense => ({
             ...offense,
-            severity
+            severity: offense.severity ?? severity
         }));
     }
     /**
@@ -5425,14 +7096,11 @@ class Linter {
         const parserOffenses = [];
         const sourceOffenses = [];
         for (const offense of lintResult.offenses) {
-            const RuleClass = this.rules.find(rule => {
-                const instance = new rule();
-                return instance.name === offense.rule;
-            });
-            if (!RuleClass)
+            const ruleClass = this.findRuleClass(offense.rule);
+            if (!ruleClass)
                 continue;
-            if (RuleClass.type === "lexer") ;
-            else if (RuleClass.type === "source") {
+            if (this.isLexerRuleClass(ruleClass)) ;
+            else if (this.isSourceRuleClass(ruleClass)) {
                 sourceOffenses.push(offense);
             }
             else {
@@ -5443,15 +7111,16 @@ class Linter {
         const fixed = [];
         const unfixed = [];
         if (parserOffenses.length > 0) {
-            const parseResult = this.herb.parse(currentSource, { track_whitespace: true });
+            const parseResult = this.parseCache.get(currentSource);
+            let needsReindent = false;
             for (const offense of parserOffenses) {
-                const RuleClass = this.rules.find(rule => new rule().name === offense.rule);
-                if (!RuleClass) {
+                const ruleClass = this.findRuleClass(offense.rule);
+                if (!ruleClass) {
                     unfixed.push(offense);
                     continue;
                 }
-                const rule = new RuleClass();
-                const isUnsafe = RuleClass.unsafeAutocorrectable === true;
+                const rule = new ruleClass();
+                const isUnsafe = ruleClass.unsafeAutocorrectable === true || offense.autofixContext?.unsafe === true;
                 if (!rule.autofix) {
                     unfixed.push(offense);
                     continue;
@@ -5475,14 +7144,21 @@ class Linter {
                 const fixedResult = rule.autofix(offense, parseResult, context);
                 if (fixedResult) {
                     fixed.push(offense);
+                    if (this.isParserRuleClass(ruleClass) && ruleClass.reindentAfterAutofix === true) {
+                        needsReindent = true;
+                    }
                 }
                 else {
                     unfixed.push(offense);
                 }
             }
             if (fixed.length > 0) {
-                const printer = new IdentityPrinter();
-                currentSource = printer.print(parseResult.value);
+                if (needsReindent) {
+                    currentSource = new IndentPrinter().print(parseResult.value);
+                }
+                else {
+                    currentSource = new IdentityPrinter().print(parseResult.value);
+                }
             }
         }
         if (sourceOffenses.length > 0) {
@@ -5493,13 +7169,13 @@ class Linter {
                 return b.location.start.column - a.location.start.column;
             });
             for (const offense of sortedSourceOffenses) {
-                const RuleClass = this.rules.find(rule => new rule().name === offense.rule);
-                if (!RuleClass) {
+                const ruleClass = this.findRuleClass(offense.rule);
+                if (!ruleClass) {
                     unfixed.push(offense);
                     continue;
                 }
-                const rule = new RuleClass();
-                const isUnsafe = RuleClass.unsafeAutocorrectable === true;
+                const rule = new ruleClass();
+                const isUnsafe = ruleClass.unsafeAutocorrectable === true || offense.autofixContext?.unsafe === true;
                 if (!rule.autofix) {
                     unfixed.push(offense);
                     continue;
@@ -5526,5 +7202,10 @@ class Linter {
     }
 }
 
-export { ARIA_ATTRIBUTES, AttributeVisitorMixin, BaseLexerRuleVisitor, BaseRuleVisitor, BaseSourceRuleVisitor, ControlFlowTrackingVisitor, ControlFlowType, DEFAULT_LINT_CONTEXT, DEFAULT_RULE_CONFIG, DOCUMENT_ONLY_TAG_NAMES, ERBCommentSyntax, ERBNoCaseNodeChildrenRule, ERBNoEmptyTagsRule, ERBNoExtraNewLineRule, ERBNoExtraWhitespaceRule, ERBNoOutputControlFlowRule, ERBNoSilentTagInAttributeNameRule, ERBPreferImageTagHelperRule, ERBRequireTrailingNewlineRule, ERBRequireWhitespaceRule, ERBRightTrimRule, ERBStrictLocalsCommentSyntaxRule, ERBStrictLocalsRequiredRule, HEADING_TAGS, HEAD_AND_BODY_TAG_NAMES, HEAD_ONLY_TAG_NAMES, HTMLAnchorRequireHrefRule, HTMLAriaLabelIsWellFormattedRule, HTMLAriaLevelMustBeValidRule, HTMLAriaRoleHeadingRequiresLevelRule, HTMLAriaRoleMustBeValidRule, HTMLAttributeDoubleQuotesRule, HTMLAttributeEqualsSpacingRule, HTMLAttributeValuesRequireQuotesRule, HTMLAvoidBothDisabledAndAriaDisabledRule, HTMLBodyOnlyElementsRule, HTMLBooleanAttributesNoValueRule, HTMLHeadOnlyElementsRule, HTMLIframeHasTitleRule, HTMLImgRequireAltRule, HTMLInputRequireAutocompleteRule, HTMLNavigationHasLabelRule, HTMLNoAriaHiddenOnFocusableRule, HTMLNoBlockInsideInlineRule, HTMLNoDuplicateAttributesRule, HTMLNoDuplicateIdsRule, HTMLNoDuplicateMetaNamesRule, HTMLNoEmptyAttributesRule, HTMLNoEmptyHeadingsRule, HTMLNoNestedLinksRule, HTMLNoPositiveTabIndexRule, HTMLNoSelfClosingRule, HTMLNoSpaceInTagRule, HTMLNoTitleAttributeRule, HTMLNoUnderscoresInAttributeNamesRule, HTMLTagNameLowercaseRule, HTML_BLOCK_ELEMENTS, HTML_BOOLEAN_ATTRIBUTES, HTML_INLINE_ELEMENTS, HTML_ONLY_TAG_NAMES, HTML_VOID_ELEMENTS, HerbDisableCommentBaseVisitor, HerbDisableCommentMalformedRule, HerbDisableCommentMissingRulesRule, HerbDisableCommentNoDuplicateRulesRule, HerbDisableCommentNoRedundantAllRule, HerbDisableCommentParsedVisitor, HerbDisableCommentUnnecessaryRule, HerbDisableCommentValidRuleNameRule, LexerRule, Linter, ParserRule, STRICT_LOCALS_PATTERN, SVGTagNameCapitalizationRule, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE, SourceRule, VALID_ARIA_ROLES, createEndOfFileLocation, findAttributeByName, findNodeByLocation, findParent, forEachAttribute, getAttribute, getAttributeName, getAttributeValue, getAttributeValueNodes, getAttributeValueQuoteType, getAttributes, getBasename, getCombinedAttributeNameString, getStaticAttributeValue, getStaticAttributeValueContent, getTagName, hasAttribute, hasAttributeValue, hasBalancedParentheses, hasDynamicAttributeName, hasDynamicAttributeValue, hasStaticAttributeValue, hasStaticAttributeValueContent, isAttributeValueQuoted, isBlockElement, isBodyOnlyTag, isBodyTag, isBooleanAttribute, isDocumentOnlyTag, isHeadAndBodyTag, isHeadOnlyTag, isHeadTag, isHtmlOnlyTag, isInlineElement, isPartialFile, isVoidElement, locationsEqual, rules, splitByTopLevelComma };
+const DOCS_BASE_URL = "https://herb-tools.dev/linter/rules";
+function ruleDocumentationUrl(ruleId) {
+    return `${DOCS_BASE_URL}/${ruleId}`;
+}
+
+export { ABSTRACT_ARIA_ROLES, ARIA_ATTRIBUTES, AttributeVisitorMixin, BaseLexerRuleVisitor, BaseRuleVisitor, BaseSourceRuleVisitor, ControlFlowTrackingVisitor, ControlFlowType, DEFAULT_LINTER_PARSER_OPTIONS, DEFAULT_LINT_CONTEXT, DEFAULT_RULE_CONFIG, DOCUMENT_ONLY_TAG_NAMES, ERBCommentSyntax, ERBNoCaseNodeChildrenRule, ERBNoConditionalOpenTagRule, ERBNoDuplicateBranchElementsRule, ERBNoEmptyTagsRule, ERBNoExtraNewLineRule, ERBNoExtraWhitespaceRule, ERBNoInlineCaseConditionsRule, ERBNoInstanceVariablesInPartialsRule, ERBNoJavascriptTagHelperRule, ERBNoOutputControlFlowRule, ERBNoOutputInAttributeNameRule, ERBNoOutputInAttributePositionRule, ERBNoRawOutputInAttributeValueRule, ERBNoSilentTagInAttributeNameRule, ERBNoStatementInScriptRule, ERBNoThenInControlFlowRule, ERBNoTrailingWhitespaceRule, ERBNoUnsafeJSAttributeRule, ERBNoUnsafeRawRule, ERBNoUnsafeScriptInterpolationRule, ERBPreferImageTagHelperRule, ERBRequireTrailingNewlineRule, ERBRequireWhitespaceRule, ERBRightTrimRule, ERBStrictLocalsCommentSyntaxRule, ERBStrictLocalsRequiredRule, HEADING_TAGS, HEAD_AND_BODY_TAG_NAMES, HEAD_ONLY_TAG_NAMES, HTMLAllowedScriptTypeRule, HTMLAnchorRequireHrefRule, HTMLAriaLabelIsWellFormattedRule, HTMLAriaLevelMustBeValidRule, HTMLAriaRoleHeadingRequiresLevelRule, HTMLAriaRoleMustBeValidRule, HTMLAttributeDoubleQuotesRule, HTMLAttributeEqualsSpacingRule, HTMLAttributeValuesRequireQuotesRule, HTMLAvoidBothDisabledAndAriaDisabledRule, HTMLBodyOnlyElementsRule, HTMLBooleanAttributesNoValueRule, HTMLDetailsHasSummaryRule, HTMLHeadOnlyElementsRule, HTMLIframeHasTitleRule, HTMLImgRequireAltRule, HTMLInputRequireAutocompleteRule, HTMLNavigationHasLabelRule, HTMLNoAbstractRolesRule, HTMLNoAriaHiddenOnBodyRule, HTMLNoAriaHiddenOnFocusableRule, HTMLNoBlockInsideInlineRule, HTMLNoDuplicateAttributesRule, HTMLNoDuplicateIdsRule, HTMLNoDuplicateMetaNamesRule, HTMLNoEmptyAttributesRule, HTMLNoEmptyHeadingsRule, HTMLNoNestedLinksRule, HTMLNoPositiveTabIndexRule, HTMLNoSelfClosingRule, HTMLNoSpaceInTagRule, HTMLNoTitleAttributeRule, HTMLNoUnderscoresInAttributeNamesRule, HTMLRequireClosingTagsRule, HTMLTagNameLowercaseRule, HTML_BLOCK_ELEMENTS, HTML_BOOLEAN_ATTRIBUTES, HTML_INLINE_ELEMENTS, HTML_ONLY_TAG_NAMES, HTML_VOID_ELEMENTS, HerbDisableCommentBaseVisitor, HerbDisableCommentMalformedRule, HerbDisableCommentMissingRulesRule, HerbDisableCommentNoDuplicateRulesRule, HerbDisableCommentNoRedundantAllRule, HerbDisableCommentParsedVisitor, HerbDisableCommentUnnecessaryRule, HerbDisableCommentValidRuleNameRule, LexerRule, Linter, ParserRule, STRICT_LOCALS_PATTERN, SVGTagNameCapitalizationRule, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE, SourceRule, VALID_ARIA_ROLES, createEndOfFileLocation, findNodeAtPosition, findNodeByLocation, findParent, getBasename, hasBalancedParentheses, isBlockElement, isBodyOnlyTag, isBodyTag, isBooleanAttribute, isDocumentOnlyTag, isHeadAndBodyTag, isHeadOnlyTag, isHeadTag, isHtmlOnlyTag, isInlineElement, isPartialFile, isVoidElement, locationFromOffset, locationsEqual, positionFromOffset, ruleDocumentationUrl, rules, splitByTopLevelComma };
 //# sourceMappingURL=index.js.map