@herb-tools/linter 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -18,6 +18,11 @@ class SourceRule {
     static type = "source";
 }
 
+exports.ControlFlowType = void 0;
+(function (ControlFlowType) {
+    ControlFlowType[ControlFlowType["CONDITIONAL"] = 0] = "CONDITIONAL";
+    ControlFlowType[ControlFlowType["LOOP"] = 1] = "LOOP";
+})(exports.ControlFlowType || (exports.ControlFlowType = {}));
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
@@ -50,6 +55,70 @@ class BaseRuleVisitor extends core.Visitor {
         this.offenses.push(this.createOffense(message, location, severity));
     }
 }
+/**
+ * Mixin that adds control flow tracking capabilities to rule visitors
+ * This allows rules to track state across different control flow structures
+ * like if/else branches, loops, etc.
+ *
+ * @template TControlFlowState - Type for state passed between onEnterControlFlow and onExitControlFlow
+ * @template TBranchState - Type for state passed between onEnterBranch and onExitBranch
+ */
+class ControlFlowTrackingVisitor extends BaseRuleVisitor {
+    isInControlFlow = false;
+    currentControlFlowType = null;
+    /**
+     * Handle visiting a control flow node with proper scope management
+     */
+    handleControlFlowNode(node, controlFlowType, visitChildren) {
+        const wasInControlFlow = this.isInControlFlow;
+        const previousControlFlowType = this.currentControlFlowType;
+        this.isInControlFlow = true;
+        this.currentControlFlowType = controlFlowType;
+        const stateToRestore = this.onEnterControlFlow(controlFlowType, wasInControlFlow);
+        visitChildren();
+        this.onExitControlFlow(controlFlowType, wasInControlFlow, stateToRestore);
+        this.isInControlFlow = wasInControlFlow;
+        this.currentControlFlowType = previousControlFlowType;
+    }
+    /**
+     * Handle visiting a branch node (like else, when) with proper scope management
+     */
+    startNewBranch(visitChildren) {
+        const stateToRestore = this.onEnterBranch();
+        visitChildren();
+        this.onExitBranch(stateToRestore);
+    }
+    visitERBIfNode(node) {
+        this.handleControlFlowNode(node, exports.ControlFlowType.CONDITIONAL, () => super.visitERBIfNode(node));
+    }
+    visitERBUnlessNode(node) {
+        this.handleControlFlowNode(node, exports.ControlFlowType.CONDITIONAL, () => super.visitERBUnlessNode(node));
+    }
+    visitERBCaseNode(node) {
+        this.handleControlFlowNode(node, exports.ControlFlowType.CONDITIONAL, () => super.visitERBCaseNode(node));
+    }
+    visitERBCaseMatchNode(node) {
+        this.handleControlFlowNode(node, exports.ControlFlowType.CONDITIONAL, () => super.visitERBCaseMatchNode(node));
+    }
+    visitERBWhileNode(node) {
+        this.handleControlFlowNode(node, exports.ControlFlowType.LOOP, () => super.visitERBWhileNode(node));
+    }
+    visitERBForNode(node) {
+        this.handleControlFlowNode(node, exports.ControlFlowType.LOOP, () => super.visitERBForNode(node));
+    }
+    visitERBUntilNode(node) {
+        this.handleControlFlowNode(node, exports.ControlFlowType.LOOP, () => super.visitERBUntilNode(node));
+    }
+    visitERBBlockNode(node) {
+        this.handleControlFlowNode(node, exports.ControlFlowType.CONDITIONAL, () => super.visitERBBlockNode(node));
+    }
+    visitERBElseNode(node) {
+        this.startNewBranch(() => super.visitERBElseNode(node));
+    }
+    visitERBWhenNode(node) {
+        this.startNewBranch(() => super.visitERBWhenNode(node));
+    }
+}
 /**
  * Gets attributes from an HTMLOpenTagNode
  */
@@ -66,10 +135,12 @@ function getTagName(node) {
  * Gets the attribute name from an HTMLAttributeNode (lowercased)
  * Returns null if the attribute name contains dynamic content (ERB)
  */
-function getAttributeName(attributeNode) {
+function getAttributeName(attributeNode, lowercase = true) {
     if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
         const nameNode = attributeNode.name;
         const staticName = core.getStaticAttributeName(nameNode);
+        if (!lowercase)
+            return staticName;
         return staticName ? staticName.toLowerCase() : null;
     }
     return null;
@@ -104,6 +175,15 @@ function hasStaticAttributeValue(attributeNode) {
         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)
  */
@@ -124,6 +204,21 @@ 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 core.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 core.getStaticContentFromNodes(valueNodes);
+}
 /**
  * Gets the attribute value content from an HTMLAttributeValueNode
  */
@@ -398,6 +493,7 @@ class AttributeVisitorMixin extends BaseRuleVisitor {
     checkAttributesOnNode(node) {
         forEachAttribute(node, (attributeNode) => {
             const staticAttributeName = getAttributeName(attributeNode);
+            const originalAttributeName = getAttributeName(attributeNode, false) || "";
             const isDynamicName = hasDynamicAttributeName(attributeNode);
             const staticAttributeValue = getStaticAttributeValue(attributeNode);
             const valueNodes = getAttributeValueNodes(attributeNode);
@@ -408,16 +504,17 @@ class AttributeVisitorMixin extends BaseRuleVisitor {
                     attributeName: staticAttributeName,
                     attributeValue: staticAttributeValue,
                     attributeNode,
+                    originalAttributeName,
                     parentNode: node
                 });
             }
             else if (staticAttributeName && isEffectivelyStaticValue && !hasOutputERB) {
                 const validatableContent = core.getValidatableStaticContent(valueNodes) || "";
-                this.checkStaticAttributeStaticValue({ attributeName: staticAttributeName, attributeValue: validatableContent, attributeNode, parentNode: node });
+                this.checkStaticAttributeStaticValue({ attributeName: staticAttributeName, attributeValue: validatableContent, attributeNode, originalAttributeName, parentNode: node });
             }
             else if (staticAttributeName && hasOutputERB) {
                 const combinedValue = getAttributeValue(attributeNode);
-                this.checkStaticAttributeDynamicValue({ attributeName: staticAttributeName, valueNodes, attributeNode, parentNode: node, combinedValue });
+                this.checkStaticAttributeDynamicValue({ attributeName: staticAttributeName, valueNodes, attributeNode, parentNode: node, originalAttributeName, combinedValue });
             }
             else if (isDynamicName && staticAttributeValue !== null) {
                 const nameNode = attributeNode.name;
@@ -437,28 +534,38 @@ class AttributeVisitorMixin extends BaseRuleVisitor {
     /**
      * Static attribute name with static value: class="container"
      */
-    checkStaticAttributeStaticValue(params) {
+    checkStaticAttributeStaticValue(_params) {
         // Default implementation does nothing
     }
     /**
      * Static attribute name with dynamic value: class="<%= css_class %>"
      */
-    checkStaticAttributeDynamicValue(params) {
+    checkStaticAttributeDynamicValue(_params) {
         // Default implementation does nothing
     }
     /**
      * Dynamic attribute name with static value: data-<%= key %>="foo"
      */
-    checkDynamicAttributeStaticValue(params) {
+    checkDynamicAttributeStaticValue(_params) {
         // Default implementation does nothing
     }
     /**
      * Dynamic attribute name with dynamic value: data-<%= key %>="<%= value %>"
      */
-    checkDynamicAttributeDynamicValue(params) {
+    checkDynamicAttributeDynamicValue(_params) {
         // 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
  */
@@ -470,6 +577,60 @@ function forEachAttribute(node, callback) {
         }
     }
 }
+/**
+ * Base lexer visitor class that provides common functionality for lexer-based rule visitors
+ */
+class BaseLexerRuleVisitor {
+    offenses = [];
+    ruleName;
+    context;
+    constructor(ruleName, context) {
+        this.ruleName = ruleName;
+        this.context = { ...DEFAULT_LINT_CONTEXT, ...context };
+    }
+    /**
+     * Helper method to create a lint offense for lexer rules
+     */
+    createOffense(message, location, severity = "error") {
+        return {
+            rule: this.ruleName,
+            code: this.ruleName,
+            source: "Herb Linter",
+            message,
+            location,
+            severity,
+        };
+    }
+    /**
+     * Helper method to add an offense to the offenses array
+     */
+    addOffense(message, location, severity = "error") {
+        this.offenses.push(this.createOffense(message, location, severity));
+    }
+    /**
+     * Main entry point for lexer rule visitors
+     * @param lexResult - The lexer result containing tokens and source
+     */
+    visit(lexResult) {
+        this.visitTokens(lexResult.value.tokens);
+    }
+    /**
+     * Visit all tokens
+     * Override this method to implement token-level checks
+     */
+    visitTokens(tokens) {
+        for (const token of tokens) {
+            this.visitToken(token);
+        }
+    }
+    /**
+     * Visit individual tokens
+     * Override this method to implement per-token checks
+     */
+    visitToken(_token) {
+        // Default implementation does nothing
+    }
+}
 /**
  * Base source visitor class that provides common functionality for source-based rule visitors
  */
@@ -612,82 +773,734 @@ class ERBNoSilentTagInAttributeNameRule extends ParserRule {
     }
 }
 
+class PrintContext {
+    output = "";
+    indentLevel = 0;
+    currentColumn = 0;
+    preserveStack = [];
+    /**
+     * Write text to the output
+     */
+    write(text) {
+        this.output += text;
+        this.currentColumn += text.length;
+    }
+    /**
+     * Write text and update column tracking for newlines
+     */
+    writeWithColumnTracking(text) {
+        this.output += text;
+        const lines = text.split('\n');
+        if (lines.length > 1) {
+            this.currentColumn = lines[lines.length - 1].length;
+        }
+        else {
+            this.currentColumn += text.length;
+        }
+    }
+    /**
+     * Increase indentation level
+     */
+    indent() {
+        this.indentLevel++;
+    }
+    /**
+     * Decrease indentation level
+     */
+    dedent() {
+        if (this.indentLevel > 0) {
+            this.indentLevel--;
+        }
+    }
+    /**
+     * Enter a tag that may preserve whitespace
+     */
+    enterTag(tagName) {
+        this.preserveStack.push(tagName.toLowerCase());
+    }
+    /**
+     * Exit the current tag
+     */
+    exitTag() {
+        this.preserveStack.pop();
+    }
+    /**
+     * Check if we're at the start of a line
+     */
+    isAtStartOfLine() {
+        return this.currentColumn === 0;
+    }
+    /**
+     * Get current indentation level
+     */
+    getCurrentIndentLevel() {
+        return this.indentLevel;
+    }
+    /**
+     * Get current column position
+     */
+    getCurrentColumn() {
+        return this.currentColumn;
+    }
+    /**
+     * Get the current tag stack (for debugging)
+     */
+    getTagStack() {
+        return [...this.preserveStack];
+    }
+    /**
+     * Get the complete output string
+     */
+    getOutput() {
+        return this.output;
+    }
+    /**
+     * Reset the context for reuse
+     */
+    reset() {
+        this.output = "";
+        this.indentLevel = 0;
+        this.currentColumn = 0;
+        this.preserveStack = [];
+    }
+}
+
+/**
+ * Default print options used when none are provided
+ */
+const DEFAULT_PRINT_OPTIONS = {
+    ignoreErrors: false
+};
+class Printer extends core.Visitor {
+    context = new PrintContext();
+    /**
+     * Static method to print a node without creating an instance
+     *
+     * @param input - The AST Node, Token, or ParseResult to print
+     * @param options - Print options to control behavior
+     * @returns The printed string representation of the input
+     * @throws {Error} When node has parse errors and ignoreErrors is false
+     */
+    static print(input, options = DEFAULT_PRINT_OPTIONS) {
+        const printer = new this();
+        return printer.print(input, options);
+    }
+    /**
+     * Print a node, token, or parse result to a string
+     *
+     * @param input - The AST Node, Token, or ParseResult to print
+     * @param options - Print options to control behavior
+     * @returns The printed string representation of the input
+     * @throws {Error} When node has parse errors and ignoreErrors is false
+     */
+    print(input, options = DEFAULT_PRINT_OPTIONS) {
+        if (!input)
+            return "";
+        if (core.isToken(input)) {
+            return input.value;
+        }
+        if (Array.isArray(input)) {
+            this.context.reset();
+            input.forEach(node => this.visit(node));
+            return this.context.getOutput();
+        }
+        const node = core.isParseResult(input) ? input.value : input;
+        if (options.ignoreErrors === false && node.recursiveErrors().length > 0) {
+            throw new Error(`Cannot print the node (${node.type}) since it or any of its children has parse errors. Either pass in a valid Node or call \`print()\` using \`print(node, { ignoreErrors: true })\``);
+        }
+        this.context.reset();
+        this.visit(node);
+        return this.context.getOutput();
+    }
+    write(content) {
+        this.context.write(content);
+    }
+}
+
+/**
+ * IdentityPrinter - Provides lossless reconstruction of the original source
+ *
+ * This printer aims to reconstruct the original input as faithfully as possible,
+ * preserving all whitespace, formatting, and structure. It's useful for:
+ * - Testing parser accuracy (input should equal output)
+ * - Baseline printing before applying transformations
+ * - Verifying AST round-trip fidelity
+ */
+class IdentityPrinter extends Printer {
+    visitLiteralNode(node) {
+        this.write(node.content);
+    }
+    visitHTMLTextNode(node) {
+        this.write(node.content);
+    }
+    visitWhitespaceNode(node) {
+        if (node.value) {
+            this.write(node.value.value);
+        }
+    }
+    visitHTMLOpenTagNode(node) {
+        if (node.tag_opening) {
+            this.write(node.tag_opening.value);
+        }
+        if (node.tag_name) {
+            this.write(node.tag_name.value);
+        }
+        this.visitChildNodes(node);
+        if (node.tag_closing) {
+            this.write(node.tag_closing.value);
+        }
+    }
+    visitHTMLCloseTagNode(node) {
+        if (node.tag_opening) {
+            this.write(node.tag_opening.value);
+        }
+        if (node.tag_name) {
+            const before = core.getNodesBeforePosition(node.children, node.tag_name.location.start, true);
+            const after = core.getNodesAfterPosition(node.children, node.tag_name.location.end);
+            this.visitAll(before);
+            this.write(node.tag_name.value);
+            this.visitAll(after);
+        }
+        else {
+            this.visitAll(node.children);
+        }
+        if (node.tag_closing) {
+            this.write(node.tag_closing.value);
+        }
+    }
+    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) {
+            node.body.forEach(child => this.visit(child));
+        }
+        if (node.close_tag) {
+            this.visit(node.close_tag);
+        }
+        if (tagName) {
+            this.context.exitTag();
+        }
+    }
+    visitHTMLAttributeNode(node) {
+        if (node.name) {
+            this.visit(node.name);
+        }
+        if (node.equals) {
+            this.write(node.equals.value);
+        }
+        if (node.equals && node.value) {
+            this.visit(node.value);
+        }
+    }
+    visitHTMLAttributeNameNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLAttributeValueNode(node) {
+        if (node.quoted && node.open_quote) {
+            this.write(node.open_quote.value);
+        }
+        this.visitChildNodes(node);
+        if (node.quoted && node.close_quote) {
+            this.write(node.close_quote.value);
+        }
+    }
+    visitHTMLCommentNode(node) {
+        if (node.comment_start) {
+            this.write(node.comment_start.value);
+        }
+        this.visitChildNodes(node);
+        if (node.comment_end) {
+            this.write(node.comment_end.value);
+        }
+    }
+    visitHTMLDoctypeNode(node) {
+        if (node.tag_opening) {
+            this.write(node.tag_opening.value);
+        }
+        this.visitChildNodes(node);
+        if (node.tag_closing) {
+            this.write(node.tag_closing.value);
+        }
+    }
+    visitXMLDeclarationNode(node) {
+        if (node.tag_opening) {
+            this.write(node.tag_opening.value);
+        }
+        this.visitChildNodes(node);
+        if (node.tag_closing) {
+            this.write(node.tag_closing.value);
+        }
+    }
+    visitCDATANode(node) {
+        if (node.tag_opening) {
+            this.write(node.tag_opening.value);
+        }
+        this.visitChildNodes(node);
+        if (node.tag_closing) {
+            this.write(node.tag_closing.value);
+        }
+    }
+    visitERBContentNode(node) {
+        this.printERBNode(node);
+    }
+    visitERBIfNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.subsequent) {
+            this.visit(node.subsequent);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBElseNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+    }
+    visitERBEndNode(node) {
+        this.printERBNode(node);
+    }
+    visitERBBlockNode(node) {
+        this.printERBNode(node);
+        if (node.body) {
+            node.body.forEach(child => this.visit(child));
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBCaseNode(node) {
+        this.printERBNode(node);
+        if (node.children) {
+            node.children.forEach(child => this.visit(child));
+        }
+        if (node.conditions) {
+            node.conditions.forEach(condition => this.visit(condition));
+        }
+        if (node.else_clause) {
+            this.visit(node.else_clause);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBWhenNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+    }
+    visitERBWhileNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBUntilNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBForNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBBeginNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        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) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.subsequent) {
+            this.visit(node.subsequent);
+        }
+    }
+    visitERBEnsureNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+    }
+    visitERBUnlessNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.else_clause) {
+            this.visit(node.else_clause);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBYieldNode(node) {
+        this.printERBNode(node);
+    }
+    visitERBInNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+    }
+    visitERBCaseMatchNode(node) {
+        this.printERBNode(node);
+        if (node.children) {
+            node.children.forEach(child => this.visit(child));
+        }
+        if (node.conditions) {
+            node.conditions.forEach(condition => this.visit(condition));
+        }
+        if (node.else_clause) {
+            this.visit(node.else_clause);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    /**
+     * Print ERB node tags and content
+     */
+    printERBNode(node) {
+        if (node.tag_opening) {
+            this.write(node.tag_opening.value);
+        }
+        if (node.content) {
+            this.write(node.content.value);
+        }
+        if (node.tag_closing) {
+            this.write(node.tag_closing.value);
+        }
+    }
+}
+
+const DEFAULT_ERB_TO_RUBY_STRING_OPTIONS = {
+    ...DEFAULT_PRINT_OPTIONS,
+    forceQuotes: false
+};
+/**
+ * ERBToRubyStringPrinter - Converts ERB snippets to Ruby strings with interpolation
+ *
+ * This printer transforms ERB templates into Ruby strings by:
+ * - Converting literal text to string content
+ * - Converting <%= %> tags to #{} interpolation
+ * - Converting simple if/else blocks to ternary operators
+ * - Ignoring <% %> tags (they don't produce output)
+ *
+ * Examples:
+ * - `hello world <%= hello %>` => `"hello world #{hello}"`
+ * - `hello world <% hello %>` => `"hello world "`
+ * - `Welcome <%= user.name %>!` => `"Welcome #{user.name}!"`
+ * - `<% if logged_in? %>Welcome<% else %>Login<% end %>` => `"logged_in? ? "Welcome" : "Login"`
+ * - `<% 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 = core.filterNodes([node], core.ERBContentNode);
+        if (erbNodes.length === 1 && core.isERBOutputNode(erbNodes[0]) && !options.forceQuotes) {
+            return (erbNodes[0].content?.value || "").trim();
+        }
+        if ('children' in node && Array.isArray(node.children)) {
+            const childErbNodes = core.filterNodes(node.children, core.ERBContentNode);
+            const hasOnlyERBContent = node.children.length > 0 && node.children.length === childErbNodes.length;
+            if (hasOnlyERBContent && childErbNodes.length === 1 && core.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 printer = new ERBToRubyStringPrinter();
+                if (printer.canConvertToTernary(ifNode)) {
+                    printer.convertToTernaryWithoutWrapper(ifNode);
+                    return printer.context.getOutput();
+                }
+            }
+            if (node.children.length === 1 && node.children[0].type === "AST_ERB_UNLESS_NODE" && !options.forceQuotes) {
+                const unlessNode = node.children[0];
+                const printer = new ERBToRubyStringPrinter();
+                if (printer.canConvertUnlessToTernary(unlessNode)) {
+                    printer.convertUnlessToTernaryWithoutWrapper(unlessNode);
+                    return printer.context.getOutput();
+                }
+            }
+        }
+        const printer = new ERBToRubyStringPrinter();
+        printer.context.write('"');
+        printer.visit(node);
+        printer.context.write('"');
+        return printer.context.getOutput();
+    }
+    visitHTMLTextNode(node) {
+        if (node.content) {
+            const escapedContent = node.content.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+            this.context.write(escapedContent);
+        }
+    }
+    visitERBContentNode(node) {
+        if (core.isERBOutputNode(node)) {
+            this.context.write("#{");
+            if (node.content?.value) {
+                this.context.write(node.content.value.trim());
+            }
+            this.context.write("}");
+        }
+    }
+    visitERBIfNode(node) {
+        if (this.canConvertToTernary(node)) {
+            this.convertToTernary(node);
+        }
+    }
+    visitERBUnlessNode(node) {
+        if (this.canConvertUnlessToTernary(node)) {
+            this.convertUnlessToTernary(node);
+        }
+    }
+    visitHTMLAttributeValueNode(node) {
+        this.visitChildNodes(node);
+    }
+    canConvertToTernary(node) {
+        if (node.subsequent && node.subsequent.type !== "AST_ERB_ELSE_NODE") {
+            return false;
+        }
+        const ifOnlyText = node.statements ? node.statements.every(statement => statement.type === "AST_HTML_TEXT_NODE") : true;
+        if (!ifOnlyText)
+            return false;
+        if (node.subsequent && node.subsequent.type === "AST_ERB_ELSE_NODE") {
+            return node.subsequent.statements
+                ? node.subsequent.statements.every(statement => statement.type === "AST_HTML_TEXT_NODE")
+                : true;
+        }
+        return true;
+    }
+    convertToTernary(node) {
+        this.context.write("#{");
+        if (node.content?.value) {
+            const condition = node.content.value.trim();
+            const cleanCondition = condition.replace(/^if\s+/, '');
+            const needsParentheses = cleanCondition.includes(' ');
+            if (needsParentheses) {
+                this.context.write("(");
+            }
+            this.context.write(cleanCondition);
+            if (needsParentheses) {
+                this.context.write(")");
+            }
+        }
+        this.context.write(" ? ");
+        this.context.write('"');
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        this.context.write('"');
+        this.context.write(" : ");
+        this.context.write('"');
+        if (node.subsequent && node.subsequent.type === "AST_ERB_ELSE_NODE" && 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") {
+            return false;
+        }
+        if (node.content?.value) {
+            const condition = node.content.value.trim();
+            const cleanCondition = condition.replace(/^if\s+/, '');
+            const needsParentheses = cleanCondition.includes(' ');
+            if (needsParentheses) {
+                this.context.write("(");
+            }
+            this.context.write(cleanCondition);
+            if (needsParentheses) {
+                this.context.write(")");
+            }
+        }
+        this.context.write(" ? ");
+        this.context.write('"');
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        this.context.write('"');
+        this.context.write(" : ");
+        this.context.write('"');
+        if (node.subsequent && node.subsequent.type === "AST_ERB_ELSE_NODE" && 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;
+        if (!unlessOnlyText)
+            return false;
+        if (node.else_clause && node.else_clause.type === "AST_ERB_ELSE_NODE") {
+            return node.else_clause.statements
+                ? node.else_clause.statements.every(statement => statement.type === "AST_HTML_TEXT_NODE")
+                : true;
+        }
+        return true;
+    }
+    convertUnlessToTernary(node) {
+        this.context.write("#{");
+        if (node.content?.value) {
+            const condition = node.content.value.trim();
+            const cleanCondition = condition.replace(/^unless\s+/, '');
+            const needsParentheses = cleanCondition.includes(' ');
+            this.context.write("!(");
+            if (needsParentheses) {
+                this.context.write("(");
+            }
+            this.context.write(cleanCondition);
+            if (needsParentheses) {
+                this.context.write(")");
+            }
+            this.context.write(")");
+        }
+        this.context.write(" ? ");
+        this.context.write('"');
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        this.context.write('"');
+        this.context.write(" : ");
+        this.context.write('"');
+        if (node.else_clause && node.else_clause.type === "AST_ERB_ELSE_NODE") {
+            node.else_clause.statements.forEach(statement => this.visit(statement));
+        }
+        this.context.write('"');
+        this.context.write("}");
+    }
+    convertUnlessToTernaryWithoutWrapper(node) {
+        if (node.content?.value) {
+            const condition = node.content.value.trim();
+            const cleanCondition = condition.replace(/^unless\s+/, '');
+            const needsParentheses = cleanCondition.includes(' ');
+            this.context.write("!(");
+            if (needsParentheses) {
+                this.context.write("(");
+            }
+            this.context.write(cleanCondition);
+            if (needsParentheses) {
+                this.context.write(")");
+            }
+            this.context.write(")");
+        }
+        this.context.write(" ? ");
+        this.context.write('"');
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        this.context.write('"');
+        this.context.write(" : ");
+        this.context.write('"');
+        if (node.else_clause && node.else_clause.type === "AST_ERB_ELSE_NODE") {
+            node.else_clause.statements.forEach(statement => this.visit(statement));
+        }
+        this.context.write('"');
+    }
+}
+
 class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
     visitHTMLOpenTagNode(node) {
         this.checkImgTag(node);
         super.visitHTMLOpenTagNode(node);
     }
-    checkImgTag(node) {
-        const tagName = getTagName(node);
-        if (tagName !== "img") {
+    checkImgTag(openTag) {
+        const tagName = getTagName(openTag);
+        if (tagName !== "img")
             return;
-        }
-        const attributes = getAttributes(node);
+        const attributes = getAttributes(openTag);
         const srcAttribute = findAttributeByName(attributes, "src");
-        if (!srcAttribute) {
+        if (!srcAttribute)
             return;
-        }
-        if (!srcAttribute.value) {
+        if (!srcAttribute.value)
             return;
-        }
-        const valueNode = srcAttribute.value;
-        const hasERBContent = this.containsERBContent(valueNode);
+        const node = srcAttribute.value;
+        const hasERBContent = this.containsERBContent(node);
         if (hasERBContent) {
-            const suggestedExpression = this.buildSuggestedExpression(valueNode);
-            this.addOffense(`Prefer \`image_tag\` helper over manual \`<img>\` with dynamic ERB expressions. Use \`<%= image_tag ${suggestedExpression}, alt: "..." %>\` instead.`, srcAttribute.location, "warning");
+            if (this.isDataUri(node))
+                return;
+            if (this.shouldFlagAsImageTagCandidate(node)) {
+                const suggestedExpression = this.buildSuggestedExpression(node);
+                this.addOffense(`Prefer \`image_tag\` helper over manual \`<img>\` with dynamic ERB expressions. Use \`<%= image_tag ${suggestedExpression}, alt: "..." %>\` instead.`, srcAttribute.location, "warning");
+            }
+        }
+    }
+    containsERBContent(node) {
+        return core.filterNodes(node.children, core.ERBContentNode).length > 0;
+    }
+    isOnlyERBContent(node) {
+        return node.children.length > 0 && node.children.length === core.filterNodes(node.children, core.ERBContentNode).length;
+    }
+    getContentofFirstChild(node) {
+        if (!node.children || node.children.length === 0)
+            return "";
+        const firstChild = node.children[0];
+        if (core.isNode(firstChild, core.LiteralNode)) {
+            return (firstChild.content || "").trim();
         }
+        return "";
     }
-    containsERBContent(valueNode) {
-        if (!valueNode.children)
+    isDataUri(node) {
+        return this.getContentofFirstChild(node).startsWith("data:");
+    }
+    isFullUrl(node) {
+        const content = this.getContentofFirstChild(node);
+        return content.startsWith("http://") || content.startsWith("https://");
+    }
+    shouldFlagAsImageTagCandidate(node) {
+        if (this.isOnlyERBContent(node))
+            return true;
+        if (this.isFullUrl(node))
             return false;
-        return valueNode.children.some(child => child.type === "AST_ERB_CONTENT_NODE");
+        return true;
     }
-    buildSuggestedExpression(valueNode) {
-        if (!valueNode.children)
+    buildSuggestedExpression(node) {
+        if (!node.children)
             return "expression";
-        let hasText = false;
-        let hasERB = false;
-        for (const child of valueNode.children) {
-            if (child.type === "AST_ERB_CONTENT_NODE") {
-                hasERB = true;
-            }
-            else if (child.type === "AST_LITERAL_NODE") {
-                const literalNode = child;
-                if (literalNode.content && literalNode.content.trim()) {
-                    hasText = true;
-                }
-            }
-        }
-        if (hasText && hasERB) {
-            let result = '"';
-            for (const child of valueNode.children) {
-                if (child.type === "AST_ERB_CONTENT_NODE") {
-                    const erbNode = child;
-                    result += `#{${(erbNode.content?.value || "").trim()}}`;
-                }
-                else if (child.type === "AST_LITERAL_NODE") {
-                    const literalNode = child;
-                    result += literalNode.content || "";
-                }
-            }
-            result += '"';
-            return result;
+        try {
+            return ERBToRubyStringPrinter.print(node, { ignoreErrors: false });
         }
-        if (hasERB && !hasText) {
-            const erbNodes = valueNode.children.filter(child => child.type === "AST_ERB_CONTENT_NODE");
-            if (erbNodes.length === 1) {
-                return (erbNodes[0].content?.value || "").trim();
-            }
-            else if (erbNodes.length > 1) {
-                let result = '"';
-                for (const erbNode of erbNodes) {
-                    result += `#{${(erbNode.content?.value || "").trim()}}`;
-                }
-                result += '"';
-                return result;
-            }
+        catch {
+            return "expression";
         }
-        return "expression";
     }
 }
 class ERBPreferImageTagHelperRule extends ParserRule {
@@ -1069,19 +1882,18 @@ class HTMLAvoidBothDisabledAndAriaDisabledRule extends ParserRule {
 }
 
 class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
-    checkStaticAttributeStaticValue({ attributeName, attributeNode }) {
-        if (!isBooleanAttribute(attributeName))
-            return;
-        if (!hasAttributeValue(attributeNode))
-            return;
-        this.addOffense(`Boolean attribute \`${attributeName}\` should not have a value. Use \`${attributeName}\` instead of \`${attributeName}="${attributeName}"\`.`, attributeNode.value.location, "error");
+    checkStaticAttributeStaticValue({ originalAttributeName, attributeNode }) {
+        this.checkAttribute(originalAttributeName, attributeNode);
     }
-    checkStaticAttributeDynamicValue({ attributeName, attributeNode, combinedValue }) {
+    checkStaticAttributeDynamicValue({ originalAttributeName, attributeNode }) {
+        this.checkAttribute(originalAttributeName, attributeNode);
+    }
+    checkAttribute(attributeName, attributeNode) {
         if (!isBooleanAttribute(attributeName))
             return;
         if (!hasAttributeValue(attributeNode))
             return;
-        this.addOffense(`Boolean attribute \`${attributeName}\` should not have a value. Use \`${attributeName}\` instead of \`${attributeName}="${combinedValue}"\`.`, attributeNode.value.location, "error");
+        this.addOffense(`Boolean attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not have a value. Use \`${attributeName.toLowerCase()}\` instead of \`${IdentityPrinter.print(attributeNode)}\`.`, attributeNode.value.location, "error");
     }
 }
 class HTMLBooleanAttributesNoValueRule extends ParserRule {
@@ -1154,47 +1966,6 @@ class HTMLImgRequireAltRule extends ParserRule {
     }
 }
 
-class NavigationHasLabelVisitor extends BaseRuleVisitor {
-    visitHTMLOpenTagNode(node) {
-        this.checkNavigationElement(node);
-        super.visitHTMLOpenTagNode(node);
-    }
-    checkNavigationElement(node) {
-        const tagName = getTagName(node);
-        const isNavElement = tagName === "nav";
-        const hasNavigationRole = this.hasRoleNavigation(node);
-        if (!isNavElement && !hasNavigationRole) {
-            return;
-        }
-        const hasAriaLabel = hasAttribute(node, "aria-label");
-        const hasAriaLabelledby = hasAttribute(node, "aria-labelledby");
-        if (!hasAriaLabel && !hasAriaLabelledby) {
-            let message = `The navigation landmark should have a unique accessible name via \`aria-label\` or \`aria-labelledby\`. Remember that the name does not need to include "navigation" or "nav" since it will already be announced.`;
-            if (hasNavigationRole && !isNavElement) {
-                message += ` Additionally, you can safely drop the \`role="navigation"\` and replace it with the native HTML \`<nav>\` element.`;
-            }
-            this.addOffense(message, node.tag_name.location, "error");
-        }
-    }
-    hasRoleNavigation(node) {
-        const attributes = getAttributes(node);
-        const roleAttribute = findAttributeByName(attributes, "role");
-        if (!roleAttribute) {
-            return false;
-        }
-        const roleValue = getAttributeValue(roleAttribute);
-        return roleValue === "navigation";
-    }
-}
-class HTMLNavigationHasLabelRule extends ParserRule {
-    name = "html-navigation-has-label";
-    check(result, context) {
-        const visitor = new NavigationHasLabelVisitor(this.name, context);
-        visitor.visit(result.value);
-        return visitor.offenses;
-    }
-}
-
 const INTERACTIVE_ELEMENTS = new Set([
     "button", "summary", "input", "select", "textarea", "a"
 ]);
@@ -1299,19 +2070,141 @@ class HTMLNoDuplicateAttributesRule extends ParserRule {
     }
 }
 
-class NoDuplicateIdsVisitor extends AttributeVisitorMixin {
+class OutputPrinter extends Printer {
+    visitLiteralNode(node) {
+        this.write(IdentityPrinter.print(node));
+    }
+    visitERBContentNode(node) {
+        if (core.isERBOutputNode(node)) {
+            this.write(IdentityPrinter.print(node));
+        }
+    }
+}
+class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor {
     documentIds = new Set();
-    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }) {
-        if (attributeName.toLowerCase() !== "id")
+    currentBranchIds = new Set();
+    controlFlowIds = new Set();
+    visitHTMLAttributeNode(node) {
+        this.checkAttribute(node);
+    }
+    onEnterControlFlow(_controlFlowType, wasAlreadyInControlFlow) {
+        const stateToRestore = {
+            previousBranchIds: this.currentBranchIds,
+            previousControlFlowIds: this.controlFlowIds
+        };
+        this.currentBranchIds = new Set();
+        if (!wasAlreadyInControlFlow) {
+            this.controlFlowIds = new Set();
+        }
+        return stateToRestore;
+    }
+    onExitControlFlow(controlFlowType, wasAlreadyInControlFlow, stateToRestore) {
+        if (controlFlowType === exports.ControlFlowType.CONDITIONAL && !wasAlreadyInControlFlow) {
+            this.controlFlowIds.forEach(id => this.documentIds.add(id));
+        }
+        this.currentBranchIds = stateToRestore.previousBranchIds;
+        this.controlFlowIds = stateToRestore.previousControlFlowIds;
+    }
+    onEnterBranch() {
+        const stateToRestore = {
+            previousBranchIds: this.currentBranchIds
+        };
+        if (this.isInControlFlow) {
+            this.currentBranchIds = new Set();
+        }
+        return stateToRestore;
+    }
+    onExitBranch(_stateToRestore) { }
+    checkAttribute(attributeNode) {
+        if (!this.isIdAttribute(attributeNode))
             return;
-        if (!attributeValue)
+        const idValue = this.extractIdValue(attributeNode);
+        if (!idValue)
+            return;
+        if (this.isWhitespaceOnlyId(idValue.identifier))
+            return;
+        this.processIdDuplicate(idValue, attributeNode);
+    }
+    isIdAttribute(attributeNode) {
+        if (!attributeNode.name?.children || !attributeNode.value)
+            return false;
+        return core.getStaticAttributeName(attributeNode.name) === "id";
+    }
+    extractIdValue(attributeNode) {
+        const valueNodes = attributeNode.value?.children || [];
+        if (core.hasERBOutput(valueNodes) && this.isInControlFlow && this.currentControlFlowType === exports.ControlFlowType.LOOP) {
+            return null;
+        }
+        const identifier = core.isEffectivelyStatic(valueNodes) ? core.getValidatableStaticContent(valueNodes) : OutputPrinter.print(valueNodes);
+        if (!identifier)
+            return null;
+        return { identifier, shouldTrackDuplicates: true };
+    }
+    isWhitespaceOnlyId(identifier) {
+        return identifier !== '' && identifier.trim() === '';
+    }
+    processIdDuplicate(idValue, attributeNode) {
+        const { identifier, shouldTrackDuplicates } = idValue;
+        if (!shouldTrackDuplicates)
             return;
-        const id = attributeValue.trim();
-        if (this.documentIds.has(id)) {
-            this.addOffense(`Duplicate ID \`${id}\` found. IDs must be unique within a document.`, attributeNode.location, "error");
+        if (this.isInControlFlow) {
+            this.handleControlFlowId(identifier, attributeNode);
+        }
+        else {
+            this.handleGlobalId(identifier, attributeNode);
+        }
+    }
+    handleControlFlowId(identifier, attributeNode) {
+        if (this.currentControlFlowType === exports.ControlFlowType.LOOP) {
+            this.handleLoopId(identifier, attributeNode);
+        }
+        else {
+            this.handleConditionalId(identifier, attributeNode);
+        }
+        this.currentBranchIds.add(identifier);
+    }
+    handleLoopId(identifier, attributeNode) {
+        const isStaticId = this.isStaticId(attributeNode);
+        if (isStaticId) {
+            this.addDuplicateIdOffense(identifier, attributeNode.location);
+            return;
+        }
+        if (this.currentBranchIds.has(identifier)) {
+            this.addSameLoopIterationOffense(identifier, attributeNode.location);
+        }
+    }
+    handleConditionalId(identifier, attributeNode) {
+        if (this.currentBranchIds.has(identifier)) {
+            this.addSameBranchOffense(identifier, attributeNode.location);
+            return;
+        }
+        if (this.documentIds.has(identifier)) {
+            this.addDuplicateIdOffense(identifier, attributeNode.location);
+            return;
+        }
+        this.controlFlowIds.add(identifier);
+    }
+    handleGlobalId(identifier, attributeNode) {
+        if (this.documentIds.has(identifier)) {
+            this.addDuplicateIdOffense(identifier, attributeNode.location);
             return;
         }
-        this.documentIds.add(id);
+        this.documentIds.add(identifier);
+    }
+    isStaticId(attributeNode) {
+        const valueNodes = attributeNode.value.children;
+        const isCompletelyStatic = valueNodes.every(child => core.isNode(child, core.LiteralNode));
+        const isEffectivelyStaticValue = core.isEffectivelyStatic(valueNodes);
+        return isCompletelyStatic || isEffectivelyStaticValue;
+    }
+    addDuplicateIdOffense(identifier, location) {
+        this.addOffense(`Duplicate ID \`${identifier}\` found. IDs must be unique within a document.`, location, "error");
+    }
+    addSameLoopIterationOffense(identifier, location) {
+        this.addOffense(`Duplicate ID \`${identifier}\` found within the same loop iteration. IDs must be unique within the same loop iteration.`, location, "error");
+    }
+    addSameBranchOffense(identifier, location) {
+        this.addOffense(`Duplicate ID \`${identifier}\` found within the same control flow branch. IDs must be unique within the same control flow branch.`, location, "error");
     }
 }
 class HTMLNoDuplicateIdsRule extends ParserRule {
@@ -1323,6 +2216,60 @@ class HTMLNoDuplicateIdsRule extends ParserRule {
     }
 }
 
+// Attributes that must not have empty values
+const RESTRICTED_ATTRIBUTES = new Set([
+    'id',
+    'class',
+    'name',
+    'for',
+    'src',
+    'href',
+    'title',
+    'data',
+    'role'
+]);
+// Check if attribute name matches any restricted patterns
+function isRestrictedAttribute(attributeName) {
+    // Check direct matches
+    if (RESTRICTED_ATTRIBUTES.has(attributeName)) {
+        return true;
+    }
+    // Check for data-* attributes
+    if (attributeName.startsWith('data-')) {
+        return true;
+    }
+    // Check for aria-* attributes
+    if (attributeName.startsWith('aria-')) {
+        return true;
+    }
+    return false;
+}
+class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
+    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }) {
+        if (!isRestrictedAttribute(attributeName))
+            return;
+        if (attributeValue.trim() !== "")
+            return;
+        this.addOffense(`Attribute \`${attributeName}\` must not be empty. Either provide a meaningful value or remove the attribute entirely.`, attributeNode.name.location, "warning");
+    }
+    checkDynamicAttributeStaticValue({ combinedName, attributeValue, attributeNode }) {
+        const name = (combinedName || "").toLowerCase();
+        if (!isRestrictedAttribute(name))
+            return;
+        if (attributeValue.trim() !== "")
+            return;
+        this.addOffense(`Attribute \`${combinedName}\` must not be empty. Either provide a meaningful value or remove the attribute entirely.`, attributeNode.name.location, "warning");
+    }
+}
+class HTMLNoEmptyAttributesRule extends ParserRule {
+    name = "html-no-empty-attributes";
+    check(result, context) {
+        const visitor = new NoEmptyAttributesVisitor(this.name, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
 class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
     visitHTMLElementNode(node) {
         this.checkHeadingElement(node);
@@ -1499,7 +2446,7 @@ class NoPositiveTabIndexVisitor extends AttributeVisitorMixin {
             return;
         const tabIndexValue = parseInt(attributeValue, 10);
         if (!isNaN(tabIndexValue) && tabIndexValue > 0) {
-            this.addOffense(`Do not use positive \`tabindex\` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use \`tabindex="0"\` to make an element focusable or \`tabindex=\"-1\"\` to remove it from the tab sequence.`, attributeNode.location, "error");
+            this.addOffense(`Do not use positive \`tabindex\` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use \`tabindex="0"\` to make an element focusable or \`tabindex="-1"\` to remove it from the tab sequence.`, attributeNode.location, "error");
         }
     }
 }
@@ -1513,14 +2460,20 @@ class HTMLNoPositiveTabIndexRule extends ParserRule {
 }
 
 class NoSelfClosingVisitor extends BaseRuleVisitor {
+    visitHTMLElementNode(node) {
+        if (core.getTagName(node) === "svg") {
+            this.visit(node.open_tag);
+        }
+        else {
+            this.visitChildNodes(node);
+        }
+    }
     visitHTMLOpenTagNode(node) {
         if (node.tag_closing?.value === "/>") {
-            const tagName = getTagName(node);
-            const shouldBeVoid = tagName ? isVoidElement(tagName) : false;
-            const instead = shouldBeVoid ? `Use \`<${tagName}>\` instead.` : `Use \`<${tagName}></${tagName}>\` instead.`;
-            this.addOffense(`Self-closing syntax \`<${tagName} />\` is not allowed in HTML. ${instead}`, node.location, "error");
+            const tagName = core.getTagName(node);
+            const instead = isVoidElement(tagName) ? `<${tagName}>` : `<${tagName}></${tagName}>`;
+            this.addOffense(`Use \`${instead}\` instead of self-closing \`<${tagName} />\` for HTML compatibility.`, node.location, "error");
         }
-        super.visitHTMLOpenTagNode(node);
     }
 }
 class HTMLNoSelfClosingRule extends ParserRule {
@@ -1532,31 +2485,6 @@ class HTMLNoSelfClosingRule extends ParserRule {
     }
 }
 
-class NoTitleAttributeVisitor extends BaseRuleVisitor {
-    ALLOWED_ELEMENTS_WITH_TITLE = new Set(["iframe", "link"]);
-    visitHTMLOpenTagNode(node) {
-        this.checkTitleAttribute(node);
-        super.visitHTMLOpenTagNode(node);
-    }
-    checkTitleAttribute(node) {
-        const tagName = getTagName(node);
-        if (!tagName || this.ALLOWED_ELEMENTS_WITH_TITLE.has(tagName)) {
-            return;
-        }
-        if (hasAttribute(node, "title")) {
-            this.addOffense("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.", node.tag_name.location, "error");
-        }
-    }
-}
-class HTMLNoTitleAttributeRule extends ParserRule {
-    name = "html-no-title-attribute";
-    check(result, context) {
-        const visitor = new NoTitleAttributeVisitor(this.name, context);
-        visitor.visit(result.value);
-        return visitor.offenses;
-    }
-}
-
 class XMLDeclarationChecker extends BaseRuleVisitor {
     hasXMLDeclaration = false;
     visitXMLDeclarationNode(_node) {
@@ -1663,9 +2591,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 (node.type === "AST_HTML_OPEN_TAG_NODE")
                 type = "Opening";
-            if (node.type == "AST_HTML_CLOSE_TAG_NODE")
+            if (node.type === "AST_HTML_CLOSE_TAG_NODE")
                 type = "Closing";
             this.addOffense(`${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`, node.tag_name.location, "error");
         }
@@ -1680,6 +2608,38 @@ class SVGTagNameCapitalizationRule extends ParserRule {
     }
 }
 
+class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
+    checkStaticAttributeStaticValue({ attributeName, attributeNode }) {
+        this.check(attributeName, attributeNode);
+    }
+    checkStaticAttributeDynamicValue({ attributeName, attributeNode }) {
+        this.check(attributeName, attributeNode);
+    }
+    checkDynamicAttributeStaticValue({ nameNodes, attributeNode }) {
+        const attributeName = core.getStaticContentFromNodes(nameNodes);
+        this.check(attributeName, attributeNode);
+    }
+    checkDynamicAttributeDynamicValue({ nameNodes, attributeNode }) {
+        const attributeName = core.getStaticContentFromNodes(nameNodes);
+        this.check(attributeName, attributeNode);
+    }
+    check(attributeName, attributeNode) {
+        if (!attributeName)
+            return;
+        if (attributeName.includes("_")) {
+            this.addOffense(`Attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not contain underscores. Use hyphens (-) instead.`, attributeNode.value.location, "warning");
+        }
+    }
+}
+class HTMLNoUnderscoresInAttributeNamesRule extends ParserRule {
+    name = "html-no-underscores-in-attribute-names";
+    check(result, context) {
+        const visitor = new HTMLNoUnderscoresInAttributeNamesVisitor(this.name, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
 const defaultRules = [
     ERBNoEmptyTagsRule,
     ERBNoOutputControlFlowRule,
@@ -1700,19 +2660,21 @@ const defaultRules = [
     HTMLBooleanAttributesNoValueRule,
     HTMLIframeHasTitleRule,
     HTMLImgRequireAltRule,
-    HTMLNavigationHasLabelRule,
+    // HTMLNavigationHasLabelRule,
     HTMLNoAriaHiddenOnFocusableRule,
     // HTMLNoBlockInsideInlineRule,
     HTMLNoDuplicateAttributesRule,
     HTMLNoDuplicateIdsRule,
+    HTMLNoEmptyAttributesRule,
     HTMLNoEmptyHeadingsRule,
     HTMLNoNestedLinksRule,
     HTMLNoPositiveTabIndexRule,
     HTMLNoSelfClosingRule,
-    HTMLNoTitleAttributeRule,
+    // HTMLNoTitleAttributeRule,
     HTMLTagNameLowercaseRule,
     ParserNoErrorsRule,
     SVGTagNameCapitalizationRule,
+    HTMLNoUnderscoresInAttributeNamesRule,
 ];
 
 class Linter {
@@ -1809,6 +2771,47 @@ class Linter {
     }
 }
 
+class NavigationHasLabelVisitor extends BaseRuleVisitor {
+    visitHTMLOpenTagNode(node) {
+        this.checkNavigationElement(node);
+        super.visitHTMLOpenTagNode(node);
+    }
+    checkNavigationElement(node) {
+        const tagName = getTagName(node);
+        const isNavElement = tagName === "nav";
+        const hasNavigationRole = this.hasRoleNavigation(node);
+        if (!isNavElement && !hasNavigationRole) {
+            return;
+        }
+        const hasAriaLabel = hasAttribute(node, "aria-label");
+        const hasAriaLabelledby = hasAttribute(node, "aria-labelledby");
+        if (!hasAriaLabel && !hasAriaLabelledby) {
+            let message = `The navigation landmark should have a unique accessible name via \`aria-label\` or \`aria-labelledby\`. Remember that the name does not need to include "navigation" or "nav" since it will already be announced.`;
+            if (hasNavigationRole && !isNavElement) {
+                message += ` Additionally, you can safely drop the \`role="navigation"\` and replace it with the native HTML \`<nav>\` element.`;
+            }
+            this.addOffense(message, node.tag_name.location, "error");
+        }
+    }
+    hasRoleNavigation(node) {
+        const attributes = getAttributes(node);
+        const roleAttribute = findAttributeByName(attributes, "role");
+        if (!roleAttribute) {
+            return false;
+        }
+        const roleValue = getAttributeValue(roleAttribute);
+        return roleValue === "navigation";
+    }
+}
+class HTMLNavigationHasLabelRule extends ParserRule {
+    name = "html-navigation-has-label";
+    check(result, context) {
+        const visitor = new NavigationHasLabelVisitor(this.name, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
 class BlockInsideInlineVisitor extends BaseRuleVisitor {
     inlineStack = [];
     isValidHTMLOpenTag(node) {
@@ -1867,12 +2870,44 @@ class HTMLNoBlockInsideInlineRule extends ParserRule {
     }
 }
 
+class NoTitleAttributeVisitor extends BaseRuleVisitor {
+    ALLOWED_ELEMENTS_WITH_TITLE = new Set(["iframe", "link"]);
+    visitHTMLOpenTagNode(node) {
+        this.checkTitleAttribute(node);
+        super.visitHTMLOpenTagNode(node);
+    }
+    checkTitleAttribute(node) {
+        const tagName = getTagName(node);
+        if (!tagName || this.ALLOWED_ELEMENTS_WITH_TITLE.has(tagName)) {
+            return;
+        }
+        if (hasAttribute(node, "title")) {
+            this.addOffense("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.", node.tag_name.location, "error");
+        }
+    }
+}
+class HTMLNoTitleAttributeRule extends ParserRule {
+    name = "html-no-title-attribute";
+    check(result, context) {
+        const visitor = new NoTitleAttributeVisitor(this.name, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+exports.ARIA_ATTRIBUTES = ARIA_ATTRIBUTES;
+exports.AttributeVisitorMixin = AttributeVisitorMixin;
+exports.BaseLexerRuleVisitor = BaseLexerRuleVisitor;
+exports.BaseRuleVisitor = BaseRuleVisitor;
+exports.BaseSourceRuleVisitor = BaseSourceRuleVisitor;
+exports.ControlFlowTrackingVisitor = ControlFlowTrackingVisitor;
 exports.DEFAULT_LINT_CONTEXT = DEFAULT_LINT_CONTEXT;
 exports.ERBNoEmptyTagsRule = ERBNoEmptyTagsRule;
 exports.ERBNoOutputControlFlowRule = ERBNoOutputControlFlowRule;
 exports.ERBNoSilentTagInAttributeNameRule = ERBNoSilentTagInAttributeNameRule;
 exports.ERBPreferImageTagHelperRule = ERBPreferImageTagHelperRule;
 exports.ERBRequiresTrailingNewlineRule = ERBRequiresTrailingNewlineRule;
+exports.HEADING_TAGS = HEADING_TAGS;
 exports.HTMLAnchorRequireHrefRule = HTMLAnchorRequireHrefRule;
 exports.HTMLAriaLabelIsWellFormattedRule = HTMLAriaLabelIsWellFormattedRule;
 exports.HTMLAriaLevelMustBeValidRule = HTMLAriaLevelMustBeValidRule;
@@ -1890,15 +2925,48 @@ exports.HTMLNoAriaHiddenOnFocusableRule = HTMLNoAriaHiddenOnFocusableRule;
 exports.HTMLNoBlockInsideInlineRule = HTMLNoBlockInsideInlineRule;
 exports.HTMLNoDuplicateAttributesRule = HTMLNoDuplicateAttributesRule;
 exports.HTMLNoDuplicateIdsRule = HTMLNoDuplicateIdsRule;
+exports.HTMLNoEmptyAttributesRule = HTMLNoEmptyAttributesRule;
 exports.HTMLNoEmptyHeadingsRule = HTMLNoEmptyHeadingsRule;
 exports.HTMLNoNestedLinksRule = HTMLNoNestedLinksRule;
 exports.HTMLNoPositiveTabIndexRule = HTMLNoPositiveTabIndexRule;
 exports.HTMLNoSelfClosingRule = HTMLNoSelfClosingRule;
 exports.HTMLNoTitleAttributeRule = HTMLNoTitleAttributeRule;
+exports.HTMLNoUnderscoresInAttributeNamesRule = HTMLNoUnderscoresInAttributeNamesRule;
 exports.HTMLTagNameLowercaseRule = HTMLTagNameLowercaseRule;
+exports.HTML_BLOCK_ELEMENTS = HTML_BLOCK_ELEMENTS;
+exports.HTML_BOOLEAN_ATTRIBUTES = HTML_BOOLEAN_ATTRIBUTES;
+exports.HTML_INLINE_ELEMENTS = HTML_INLINE_ELEMENTS;
+exports.HTML_VOID_ELEMENTS = HTML_VOID_ELEMENTS;
 exports.LexerRule = LexerRule;
 exports.Linter = Linter;
 exports.ParserRule = ParserRule;
 exports.SVGTagNameCapitalizationRule = SVGTagNameCapitalizationRule;
+exports.SVG_CAMEL_CASE_ELEMENTS = SVG_CAMEL_CASE_ELEMENTS;
+exports.SVG_LOWERCASE_TO_CAMELCASE = SVG_LOWERCASE_TO_CAMELCASE;
 exports.SourceRule = SourceRule;
+exports.VALID_ARIA_ROLES = VALID_ARIA_ROLES;
+exports.createEndOfFileLocation = createEndOfFileLocation;
+exports.findAttributeByName = findAttributeByName;
+exports.forEachAttribute = forEachAttribute;
+exports.getAttribute = getAttribute;
+exports.getAttributeName = getAttributeName;
+exports.getAttributeValue = getAttributeValue;
+exports.getAttributeValueNodes = getAttributeValueNodes;
+exports.getAttributeValueQuoteType = getAttributeValueQuoteType;
+exports.getAttributes = getAttributes;
+exports.getCombinedAttributeNameString = getCombinedAttributeNameString;
+exports.getStaticAttributeValue = getStaticAttributeValue;
+exports.getStaticAttributeValueContent = getStaticAttributeValueContent;
+exports.getTagName = getTagName;
+exports.hasAttribute = hasAttribute;
+exports.hasAttributeValue = hasAttributeValue;
+exports.hasDynamicAttributeName = hasDynamicAttributeName;
+exports.hasDynamicAttributeValue = hasDynamicAttributeValue;
+exports.hasStaticAttributeValue = hasStaticAttributeValue;
+exports.hasStaticAttributeValueContent = hasStaticAttributeValueContent;
+exports.isAttributeValueQuoted = isAttributeValueQuoted;
+exports.isBlockElement = isBlockElement;
+exports.isBooleanAttribute = isBooleanAttribute;
+exports.isInlineElement = isInlineElement;
+exports.isVoidElement = isVoidElement;
 //# sourceMappingURL=index.cjs.map