@herb-tools/linter 0.4.3 → 0.6.0

package/dist/index.cjs

@@ -51,12 +51,10 @@ class BaseRuleVisitor extends core.Visitor {
     }
 }
 /**
- * Gets attributes from either an HTMLOpenTagNode or HTMLSelfCloseTagNode
+ * Gets attributes from an HTMLOpenTagNode
  */
 function getAttributes(node) {
-    return node.type === "AST_HTML_SELF_CLOSE_TAG_NODE"
-        ? node.attributes
-        : node.children;
+    return node.children.filter(node => node.type === "AST_HTML_ATTRIBUTE_NODE");
 }
 /**
  * Gets the tag name from an HTML tag node (lowercased)
@@ -66,14 +64,66 @@ function getTagName(node) {
 }
 /**
  * Gets the attribute name from an HTMLAttributeNode (lowercased)
+ * Returns null if the attribute name contains dynamic content (ERB)
  */
 function getAttributeName(attributeNode) {
     if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
         const nameNode = attributeNode.name;
-        return nameNode.name?.value.toLowerCase() || null;
+        const staticName = core.getStaticAttributeName(nameNode);
+        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 core.hasDynamicAttributeName(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 core.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");
+}
+/**
+ * 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 || [];
+}
 /**
  * Gets the attribute value content from an HTMLAttributeValueNode
  */
@@ -111,9 +161,18 @@ function hasAttributeValue(attributeNode) {
 /**
  * Gets the quote type used for an attribute value
  */
-function getAttributeValueQuoteType(attributeNode) {
-    if (attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
-        const valueNode = attributeNode.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";
         }
@@ -140,8 +199,14 @@ function findAttributeByName(attributes, attributeName) {
  * Checks if a tag has a specific attribute
  */
 function hasAttribute(node, attributeName) {
+    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) !== null;
+    return findAttributeByName(attributes, attributeName);
 }
 /**
  * Common HTML element categorization
@@ -158,6 +223,10 @@ const HTML_BLOCK_ELEMENTS = new Set([
     "h3", "h4", "h5", "h6", "header", "hr", "li", "main", "nav", "noscript",
     "ol", "p", "pre", "section", "table", "tfoot", "ul", "video"
 ]);
+const HTML_VOID_ELEMENTS = new Set([
+    "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta",
+    "param", "source", "track", "wbr",
+]);
 const HTML_BOOLEAN_ATTRIBUTES = new Set([
     "autofocus", "autoplay", "checked", "controls", "defer", "disabled", "hidden",
     "loop", "multiple", "muted", "readonly", "required", "reversed", "selected",
@@ -296,6 +365,12 @@ function isInlineElement(tagName) {
 function isBlockElement(tagName) {
     return HTML_BLOCK_ELEMENTS.has(tagName.toLowerCase());
 }
+/**
+ * Checks if an element is a void element
+ */
+function isVoidElement(tagName) {
+    return HTML_VOID_ELEMENTS.has(tagName.toLowerCase());
+}
 /**
  * Checks if an attribute is a boolean attribute
  */
@@ -303,9 +378,14 @@ function isBooleanAttribute(attributeName) {
     return HTML_BOOLEAN_ATTRIBUTES.has(attributeName.toLowerCase());
 }
 /**
- * Abstract base class for rules that need to check individual attributes on HTML tags
- * Eliminates duplication of visitHTMLOpenTagNode/visitHTMLSelfCloseTagNode patterns
- * and attribute iteration logic. Provides simplified interface with extracted attribute info.
+ * Attribute visitor that provides granular processing based on both
+ * attribute name type (static/dynamic) and value type (static/dynamic)
+ *
+ * This gives you 4 distinct methods to override:
+ * - checkStaticAttributeStaticValue()   - name="class" value="foo"
+ * - checkStaticAttributeDynamicValue()  - name="class" value="<%= css_class %>"
+ * - checkDynamicAttributeStaticValue()  - name="data-<%= key %>" value="foo"
+ * - checkDynamicAttributeDynamicValue() - name="data-<%= key %>" value="<%= value %>"
  */
 class AttributeVisitorMixin extends BaseRuleVisitor {
     constructor(ruleName, context) {
@@ -315,19 +395,69 @@ class AttributeVisitorMixin extends BaseRuleVisitor {
         this.checkAttributesOnNode(node);
         super.visitHTMLOpenTagNode(node);
     }
-    visitHTMLSelfCloseTagNode(node) {
-        this.checkAttributesOnNode(node);
-        super.visitHTMLSelfCloseTagNode(node);
-    }
     checkAttributesOnNode(node) {
         forEachAttribute(node, (attributeNode) => {
-            const attributeName = getAttributeName(attributeNode);
-            const attributeValue = getAttributeValue(attributeNode);
-            if (attributeName) {
-                this.checkAttribute(attributeName, attributeValue, attributeNode, node);
+            const staticAttributeName = getAttributeName(attributeNode);
+            const isDynamicName = hasDynamicAttributeName(attributeNode);
+            const staticAttributeValue = getStaticAttributeValue(attributeNode);
+            const valueNodes = getAttributeValueNodes(attributeNode);
+            const hasOutputERB = core.hasERBOutput(valueNodes);
+            const isEffectivelyStaticValue = core.isEffectivelyStatic(valueNodes);
+            if (staticAttributeName && staticAttributeValue !== null) {
+                this.checkStaticAttributeStaticValue({
+                    attributeName: staticAttributeName,
+                    attributeValue: staticAttributeValue,
+                    attributeNode,
+                    parentNode: node
+                });
+            }
+            else if (staticAttributeName && isEffectivelyStaticValue && !hasOutputERB) {
+                const validatableContent = core.getValidatableStaticContent(valueNodes) || "";
+                this.checkStaticAttributeStaticValue({ attributeName: staticAttributeName, attributeValue: validatableContent, attributeNode, parentNode: node });
+            }
+            else if (staticAttributeName && hasOutputERB) {
+                const combinedValue = getAttributeValue(attributeNode);
+                this.checkStaticAttributeDynamicValue({ attributeName: staticAttributeName, valueNodes, attributeNode, parentNode: node, combinedValue });
+            }
+            else if (isDynamicName && staticAttributeValue !== null) {
+                const nameNode = attributeNode.name;
+                const nameNodes = nameNode.children || [];
+                const combinedName = getCombinedAttributeNameString(attributeNode);
+                this.checkDynamicAttributeStaticValue({ nameNodes, attributeValue: staticAttributeValue, attributeNode, parentNode: node, combinedName });
+            }
+            else if (isDynamicName) {
+                const nameNode = attributeNode.name;
+                const nameNodes = nameNode.children || [];
+                const combinedName = getCombinedAttributeNameString(attributeNode);
+                const combinedValue = getAttributeValue(attributeNode);
+                this.checkDynamicAttributeDynamicValue({ nameNodes, valueNodes, attributeNode, parentNode: node, combinedName, combinedValue });
             }
         });
     }
+    /**
+     * Static attribute name with static value: class="container"
+     */
+    checkStaticAttributeStaticValue(params) {
+        // Default implementation does nothing
+    }
+    /**
+     * Static attribute name with dynamic value: class="<%= css_class %>"
+     */
+    checkStaticAttributeDynamicValue(params) {
+        // Default implementation does nothing
+    }
+    /**
+     * Dynamic attribute name with static value: data-<%= key %>="foo"
+     */
+    checkDynamicAttributeStaticValue(params) {
+        // Default implementation does nothing
+    }
+    /**
+     * Dynamic attribute name with dynamic value: data-<%= key %>="<%= value %>"
+     */
+    checkDynamicAttributeDynamicValue(params) {
+        // Default implementation does nothing
+    }
 }
 /**
  * Iterates over all attributes of a tag node, calling the callback for each attribute
@@ -356,7 +486,7 @@ class BaseSourceRuleVisitor {
      */
     createOffense(message, location, severity = "error") {
         return {
-            rule: this.ruleName, // Type assertion for compatibility
+            rule: this.ruleName,
             code: this.ruleName,
             source: "Herb Linter",
             message,
@@ -406,9 +536,9 @@ class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
 }
 class ERBNoEmptyTagsRule extends ParserRule {
     name = "erb-no-empty-tags";
-    check(node, context) {
+    check(result, context) {
         const visitor = new ERBNoEmptyTagsVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
@@ -452,9 +582,32 @@ class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
 }
 class ERBNoOutputControlFlowRule extends ParserRule {
     name = "erb-no-output-control-flow";
-    check(node, context) {
+    check(result, context) {
         const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class ERBNoSilentTagInAttributeNameVisitor extends BaseRuleVisitor {
+    visitHTMLAttributeNameNode(node) {
+        const erbNodes = core.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, "error");
+        }
+    }
+    // TODO: might be worth to extract
+    isSilentERBTag(node) {
+        const silentTags = ["<%", "<%-", "<%#"];
+        return silentTags.includes(node.tag_opening?.value || "");
+    }
+}
+class ERBNoSilentTagInAttributeNameRule extends ParserRule {
+    name = "erb-no-silent-tag-in-attribute-name";
+    check(result, context) {
+        const visitor = new ERBNoSilentTagInAttributeNameVisitor(this.name, context);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
@@ -464,10 +617,6 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
         this.checkImgTag(node);
         super.visitHTMLOpenTagNode(node);
     }
-    visitHTMLSelfCloseTagNode(node) {
-        this.checkImgTag(node);
-        super.visitHTMLSelfCloseTagNode(node);
-    }
     checkImgTag(node) {
         const tagName = getTagName(node);
         if (tagName !== "img") {
@@ -543,9 +692,9 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
 }
 class ERBPreferImageTagHelperRule extends ParserRule {
     name = "erb-prefer-image-tag-helper";
-    check(node, context) {
+    check(result, context) {
         const visitor = new ERBPreferImageTagHelperVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
@@ -620,9 +769,9 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
 }
 class ERBRequireWhitespaceRule extends ParserRule {
     name = "erb-require-whitespace-inside-tags";
-    check(node, context) {
+    check(result, context) {
         const visitor = new RequireWhitespaceInsideTags(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
@@ -644,43 +793,96 @@ class AnchorRechireHrefVisitor extends BaseRuleVisitor {
 }
 class HTMLAnchorRequireHrefRule extends ParserRule {
     name = "html-anchor-require-href";
-    check(node, context) {
+    check(result, context) {
         const visitor = new AnchorRechireHrefVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
 class AriaAttributeMustBeValid extends AttributeVisitorMixin {
-    checkAttribute(attributeName, _attributeValue, attributeNode, _parentNode) {
+    checkStaticAttributeStaticValue({ attributeName, attributeNode }) {
+        this.check(attributeName, attributeNode);
+    }
+    checkStaticAttributeDynamicValue({ attributeName, attributeNode }) {
+        this.check(attributeName, attributeNode);
+    }
+    check(attributeName, attributeNode) {
         if (!attributeName.startsWith("aria-"))
             return;
-        if (!ARIA_ATTRIBUTES.has(attributeName)) {
-            this.offenses.push({
-                message: `The attribute \`${attributeName}\` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.`,
-                severity: "error",
-                location: attributeNode.location,
-                rule: this.ruleName,
-            });
-        }
+        if (ARIA_ATTRIBUTES.has(attributeName))
+            return;
+        this.addOffense(`The attribute \`${attributeName}\` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.`, attributeNode.location, "error");
     }
 }
 class HTMLAriaAttributeMustBeValid extends ParserRule {
     name = "html-aria-attribute-must-be-valid";
-    check(node, context) {
+    check(result, context) {
         const visitor = new AriaAttributeMustBeValid(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class AriaLabelIsWellFormattedVisitor extends AttributeVisitorMixin {
+    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }) {
+        if (attributeName !== "aria-label")
+            return;
+        if (attributeValue.match(/[\r\n]+/) || attributeValue.match(/&#10;|&#13;|&#x0A;|&#x0D;/i)) {
+            this.addOffense("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.", attributeNode.location, "error");
+            return;
+        }
+        if (this.looksLikeId(attributeValue)) {
+            this.addOffense("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.", attributeNode.location, "error");
+            return;
+        }
+        if (attributeValue.match(/^[a-z]/)) {
+            this.addOffense("The `aria-label` attribute value text should be formatted like visual text. Use sentence case (capitalize the first letter).", attributeNode.location, "error");
+        }
+    }
+    looksLikeId(text) {
+        return (text.includes('_') ||
+            text.includes('-') ||
+            /^[a-z]+([A-Z][a-z]*)*$/.test(text)) && !text.includes(' ');
+    }
+}
+class HTMLAriaLabelIsWellFormattedRule extends ParserRule {
+    name = "html-aria-label-is-well-formatted";
+    check(result, context) {
+        const visitor = new AriaLabelIsWellFormattedVisitor(this.name, context);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
 class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
-    checkAttribute(attributeName, attributeValue, attributeNode, _parentNode) {
+    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }) {
+        if (attributeName !== "aria-level")
+            return;
+        this.validateAriaLevel(attributeValue, attributeNode);
+    }
+    checkStaticAttributeDynamicValue({ attributeName, valueNodes, attributeNode }) {
         if (attributeName !== "aria-level")
             return;
-        if (attributeValue !== null && attributeValue.includes("<%"))
+        const validatableContent = core.getValidatableStaticContent(valueNodes);
+        if (validatableContent !== null) {
+            this.validateAriaLevel(validatableContent, attributeNode);
             return;
-        if (attributeValue === null || attributeValue === "") {
+        }
+        if (!core.hasERBOutput(valueNodes))
+            return;
+        const literalNodes = core.filterLiteralNodes(valueNodes);
+        const erbOutputNodes = core.filterERBContentNodes(valueNodes).filter(core.isERBOutputNode);
+        if (literalNodes.length > 0 && erbOutputNodes.length > 0) {
+            const staticPart = literalNodes.map(node => node.content).join("");
+            // TODO: this can be cleaned up using @herb-tools/printer
+            const erbPart = erbOutputNodes[0];
+            const erbText = `${erbPart.tag_opening?.value || ""}${erbPart.content?.value || ""}${erbPart.tag_closing?.value || ""}`;
+            this.addOffense(`The \`aria-level\` attribute must be an integer between 1 and 6, got \`${staticPart}\` and the ERB expression \`${erbText}\`.`, attributeNode.location);
+        }
+    }
+    validateAriaLevel(attributeValue, attributeNode) {
+        if (!attributeValue || attributeValue === "") {
             this.addOffense(`The \`aria-level\` attribute must be an integer between 1 and 6, got an empty value.`, attributeNode.location);
             return;
         }
@@ -692,43 +894,37 @@ class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
 }
 class HTMLAriaLevelMustBeValidRule extends ParserRule {
     name = "html-aria-level-must-be-valid";
-    check(node, context) {
+    check(result, context) {
         const visitor = new HTMLAriaLevelMustBeValidVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
 class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
-    // We want to check 2 attributes here:
-    // 1. role="heading"
-    // 2. aria-level (which must be present if role="heading")
-    checkAttribute(attributeName, attributeValue, attributeNode, parentNode) {
-        if (!(attributeName === "role" && attributeValue === "heading")) {
+    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode, parentNode }) {
+        if (!(attributeName === "role" && attributeValue === "heading"))
             return;
-        }
-        const allAttributes = getAttributes(parentNode);
-        // If we have a role="heading", we must check for aria-level
-        const ariaLevelAttr = allAttributes.find(attr => getAttributeName(attr) === "aria-level");
-        if (!ariaLevelAttr) {
-            this.addOffense(`Element with \`role="heading"\` must have an \`aria-level\` attribute.`, attributeNode.location, "error");
-        }
+        const ariaLevelAttributes = getAttributes(parentNode).find(attribute => getAttributeName(attribute) === "aria-level");
+        if (ariaLevelAttributes)
+            return;
+        this.addOffense(`Element with \`role="heading"\` must have an \`aria-level\` attribute.`, attributeNode.location, "error");
     }
 }
 class HTMLAriaRoleHeadingRequiresLevelRule extends ParserRule {
     name = "html-aria-role-heading-requires-level";
-    check(node, context) {
+    check(result, context) {
         const visitor = new AriaRoleHeadingRequiresLevel(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
 class AriaRoleMustBeValid extends AttributeVisitorMixin {
-    checkAttribute(attributeName, attributeValue, attributeNode) {
+    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }) {
         if (attributeName !== "role")
             return;
-        if (attributeValue === null)
+        if (!attributeValue)
             return;
         if (VALID_ARIA_ROLES.has(attributeValue))
             return;
@@ -737,80 +933,207 @@ class AriaRoleMustBeValid extends AttributeVisitorMixin {
 }
 class HTMLAriaRoleMustBeValidRule extends ParserRule {
     name = "html-aria-role-must-be-valid";
-    check(node, context) {
+    check(result, context) {
         const visitor = new AriaRoleMustBeValid(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
 class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
-    checkAttribute(attributeName, attributeValue, attributeNode) {
+    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }) {
         if (!hasAttributeValue(attributeNode))
             return;
         if (getAttributeValueQuoteType(attributeNode) !== "single")
             return;
         if (attributeValue?.includes('"'))
-            return; // Single quotes acceptable when value contains double quotes
-        this.addOffense(`Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="value"\`.`, attributeNode.value.location, "warning");
+            return;
+        this.addOffense(`Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="${attributeValue}"\`.`, attributeNode.value.location, "warning");
+    }
+    checkStaticAttributeDynamicValue({ attributeName, valueNodes, attributeNode, combinedValue }) {
+        if (!hasAttributeValue(attributeNode))
+            return;
+        if (getAttributeValueQuoteType(attributeNode) !== "single")
+            return;
+        if (core.filterLiteralNodes(valueNodes).some(node => node.content?.includes('"')))
+            return;
+        this.addOffense(`Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="${combinedValue}"\`.`, attributeNode.value.location, "warning");
     }
 }
 class HTMLAttributeDoubleQuotesRule extends ParserRule {
     name = "html-attribute-double-quotes";
-    check(node, context) {
+    check(result, context) {
         const visitor = new AttributeDoubleQuotesVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
+    visitHTMLAttributeNode(attribute) {
+        if (!attribute.equals || !attribute.name || !attribute.value) {
+            return;
+        }
+        if (attribute.equals.value.startsWith(" ")) {
+            this.addOffense("Remove whitespace before `=` in HTML attribute", attribute.equals.location, "error");
+        }
+        if (attribute.equals.value.endsWith(" ")) {
+            this.addOffense("Remove whitespace after `=` in HTML attribute", attribute.equals.location, "error");
+        }
+    }
+}
+class HTMLAttributeEqualsSpacingRule extends ParserRule {
+    name = "html-attribute-equals-spacing";
+    check(result, context) {
+        const visitor = new HTMLAttributeEqualsSpacingVisitor(this.name, context);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
 class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
-    checkAttribute(attributeName, _attributeValue, attributeNode) {
-        if (attributeNode.value?.type !== "AST_HTML_ATTRIBUTE_VALUE_NODE")
+    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }) {
+        if (this.hasAttributeValue(attributeNode))
             return;
-        const valueNode = attributeNode.value;
-        if (valueNode.quoted)
+        if (this.isQuoted(attributeNode))
+            return;
+        this.addOffense(`Attribute value should be quoted: \`${attributeName}="${attributeValue}"\`. Always wrap attribute values in quotes.`, attributeNode.value.location, "error");
+    }
+    checkStaticAttributeDynamicValue({ attributeName, attributeNode, combinedValue }) {
+        if (this.hasAttributeValue(attributeNode))
+            return;
+        if (this.isQuoted(attributeNode))
             return;
-        this.addOffense(
-        // TODO: print actual attribute value in message
-        `Attribute value should be quoted: \`${attributeName}="value"\`. Always wrap attribute values in quotes.`, valueNode.location, "error");
+        this.addOffense(`Attribute value should be quoted: \`${attributeName}="${combinedValue}"\`. Always wrap attribute values in quotes.`, attributeNode.value.location, "error");
+    }
+    hasAttributeValue(attributeNode) {
+        return attributeNode.value?.type !== "AST_HTML_ATTRIBUTE_VALUE_NODE";
+    }
+    isQuoted(attributeNode) {
+        const valueNode = attributeNode.value;
+        return valueNode.quoted;
     }
 }
 class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
     name = "html-attribute-values-require-quotes";
-    check(node, context) {
+    check(result, context) {
         const visitor = new AttributeValuesRequireQuotesVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+const ELEMENTS_WITH_NATIVE_DISABLED_ATTRIBUTE_SUPPORT = new Set([
+    "button", "fieldset", "input", "optgroup", "option", "select", "textarea"
+]);
+class AvoidBothDisabledAndAriaDisabledVisitor extends BaseRuleVisitor {
+    visitHTMLOpenTagNode(node) {
+        this.checkElement(node);
+        super.visitHTMLOpenTagNode(node);
+    }
+    checkElement(node) {
+        const tagName = getTagName(node);
+        if (!tagName || !ELEMENTS_WITH_NATIVE_DISABLED_ATTRIBUTE_SUPPORT.has(tagName)) {
+            return;
+        }
+        const hasDisabled = hasAttribute(node, "disabled");
+        const hasAriaDisabled = hasAttribute(node, "aria-disabled");
+        if ((hasDisabled && this.hasERBContent(node, "disabled")) || (hasAriaDisabled && this.hasERBContent(node, "aria-disabled"))) {
+            return;
+        }
+        if (hasDisabled && hasAriaDisabled) {
+            this.addOffense("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.", node.tag_name.location, "error");
+        }
+    }
+    hasERBContent(node, attributeName) {
+        const attributes = getAttributes(node);
+        const attribute = findAttributeByName(attributes, attributeName);
+        if (!attribute)
+            return false;
+        const valueNode = attribute.value;
+        if (!valueNode || valueNode.type !== "AST_HTML_ATTRIBUTE_VALUE_NODE")
+            return false;
+        const htmlValueNode = valueNode;
+        if (!htmlValueNode.children)
+            return false;
+        return htmlValueNode.children.some((child) => child.type === "AST_ERB_CONTENT_NODE");
+    }
+}
+class HTMLAvoidBothDisabledAndAriaDisabledRule extends ParserRule {
+    name = "html-avoid-both-disabled-and-aria-disabled";
+    check(result, context) {
+        const visitor = new AvoidBothDisabledAndAriaDisabledVisitor(this.name, context);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
 class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
-    checkAttribute(attributeName, _attributeValue, attributeNode) {
+    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");
     }
+    checkStaticAttributeDynamicValue({ attributeName, attributeNode, combinedValue }) {
+        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");
+    }
 }
 class HTMLBooleanAttributesNoValueRule extends ParserRule {
     name = "html-boolean-attributes-no-value";
-    check(node, context) {
+    check(result, context) {
         const visitor = new BooleanAttributesNoValueVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
-class ImgRequireAltVisitor extends BaseRuleVisitor {
+class IframeHasTitleVisitor extends BaseRuleVisitor {
     visitHTMLOpenTagNode(node) {
-        this.checkImgTag(node);
+        this.checkIframeElement(node);
         super.visitHTMLOpenTagNode(node);
     }
-    visitHTMLSelfCloseTagNode(node) {
+    checkIframeElement(node) {
+        const tagName = getTagName(node);
+        if (tagName !== "iframe") {
+            return;
+        }
+        const ariaHiddenAttribute = getAttribute(node, "aria-hidden");
+        if (ariaHiddenAttribute) {
+            const ariaHiddenValue = getAttributeValue(ariaHiddenAttribute);
+            if (ariaHiddenValue === "true") {
+                return;
+            }
+        }
+        const attribute = getAttribute(node, "title");
+        if (!attribute) {
+            this.addOffense("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.", node.location, "error");
+            return;
+        }
+        const value = getAttributeValue(attribute);
+        if (!value || value.trim() === "") {
+            this.addOffense("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.", node.location, "error");
+        }
+    }
+}
+class HTMLIframeHasTitleRule extends ParserRule {
+    name = "html-iframe-has-title";
+    check(result, context) {
+        const visitor = new IframeHasTitleVisitor(this.name, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class ImgRequireAltVisitor extends BaseRuleVisitor {
+    visitHTMLOpenTagNode(node) {
         this.checkImgTag(node);
-        super.visitHTMLSelfCloseTagNode(node);
+        super.visitHTMLOpenTagNode(node);
     }
     checkImgTag(node) {
         const tagName = getTagName(node);
@@ -824,41 +1147,144 @@ class ImgRequireAltVisitor extends BaseRuleVisitor {
 }
 class HTMLImgRequireAltRule extends ParserRule {
     name = "html-img-require-alt";
-    check(node, context) {
+    check(result, context) {
         const visitor = new ImgRequireAltVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
-class NoDuplicateAttributesVisitor extends BaseRuleVisitor {
+class NavigationHasLabelVisitor extends BaseRuleVisitor {
     visitHTMLOpenTagNode(node) {
-        this.checkDuplicateAttributes(node);
+        this.checkNavigationElement(node);
         super.visitHTMLOpenTagNode(node);
     }
-    visitHTMLSelfCloseTagNode(node) {
-        this.checkDuplicateAttributes(node);
-        super.visitHTMLSelfCloseTagNode(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");
+        }
     }
-    checkDuplicateAttributes(node) {
-        const attributeNames = new Map();
-        forEachAttribute(node, (attributeNode) => {
-            if (attributeNode.name?.type !== "AST_HTML_ATTRIBUTE_NAME_NODE")
-                return;
-            const nameNode = attributeNode.name;
-            if (!nameNode.name)
-                return;
-            const attributeName = nameNode.name.value.toLowerCase(); // HTML attributes are case-insensitive
-            if (!attributeNames.has(attributeName)) {
-                attributeNames.set(attributeName, []);
+    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"
+]);
+class NoAriaHiddenOnFocusableVisitor extends BaseRuleVisitor {
+    visitHTMLOpenTagNode(node) {
+        this.checkAriaHiddenOnFocusable(node);
+        super.visitHTMLOpenTagNode(node);
+    }
+    checkAriaHiddenOnFocusable(node) {
+        if (!this.hasAriaHiddenTrue(node))
+            return;
+        if (this.isFocusable(node)) {
+            this.addOffense(`Elements that are focusable should not have \`aria-hidden="true"\` because it will cause confusion for assistive technology users.`, node.tag_name.location, "error");
+        }
+    }
+    hasAriaHiddenTrue(node) {
+        const attributes = getAttributes(node);
+        const ariaHiddenAttr = findAttributeByName(attributes, "aria-hidden");
+        if (!ariaHiddenAttr)
+            return false;
+        const value = getAttributeValue(ariaHiddenAttr);
+        return value === "true";
+    }
+    isFocusable(node) {
+        const tagName = getTagName(node);
+        if (!tagName)
+            return false;
+        const tabIndexValue = this.getTabIndexValue(node);
+        if (tagName === "a") {
+            const hasHref = hasAttribute(node, "href");
+            if (!hasHref) {
+                return tabIndexValue !== null && tabIndexValue >= 0;
             }
-            attributeNames.get(attributeName).push(nameNode);
-        });
-        for (const [attributeName, nameNodes] of attributeNames) {
-            if (nameNodes.length > 1) {
-                for (let i = 1; i < nameNodes.length; i++) {
-                    const nameNode = nameNodes[i];
-                    this.addOffense(`Duplicate attribute \`${attributeName}\` found on tag. Remove the duplicate occurrence.`, nameNode.location, "error");
+            return tabIndexValue === null || tabIndexValue >= 0;
+        }
+        if (INTERACTIVE_ELEMENTS.has(tagName)) {
+            // Interactive elements are focusable unless tabindex is negative
+            return tabIndexValue === null || tabIndexValue >= 0;
+        }
+        else {
+            // Non-interactive elements are focusable only if tabindex >= 0
+            return tabIndexValue !== null && tabIndexValue >= 0;
+        }
+    }
+    getTabIndexValue(node) {
+        const attributes = getAttributes(node);
+        const tabIndexAttribute = findAttributeByName(attributes, "tabindex");
+        if (!tabIndexAttribute)
+            return null;
+        const value = getAttributeValue(tabIndexAttribute);
+        if (!value)
+            return null;
+        const parsed = parseInt(value, 10);
+        return isNaN(parsed) ? null : parsed;
+    }
+}
+class HTMLNoAriaHiddenOnFocusableRule extends ParserRule {
+    name = "html-no-aria-hidden-on-focusable";
+    check(result, context) {
+        const visitor = new NoAriaHiddenOnFocusableVisitor(this.name, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class NoDuplicateAttributesVisitor extends AttributeVisitorMixin {
+    attributeNames = new Map();
+    visitHTMLOpenTagNode(node) {
+        this.attributeNames.clear();
+        super.visitHTMLOpenTagNode(node);
+        this.reportDuplicates();
+    }
+    checkStaticAttributeStaticValue({ attributeName, attributeNode }) {
+        this.trackAttributeName(attributeName, attributeNode);
+    }
+    checkStaticAttributeDynamicValue({ attributeName, attributeNode }) {
+        this.trackAttributeName(attributeName, attributeNode);
+    }
+    trackAttributeName(attributeName, attributeNode) {
+        if (!this.attributeNames.has(attributeName)) {
+            this.attributeNames.set(attributeName, []);
+        }
+        this.attributeNames.get(attributeName).push(attributeNode);
+    }
+    reportDuplicates() {
+        for (const [attributeName, attributeNodes] of this.attributeNames) {
+            if (attributeNodes.length > 1) {
+                for (let i = 1; i < attributeNodes.length; i++) {
+                    const attributeNode = attributeNodes[i];
+                    this.addOffense(`Duplicate attribute \`${attributeName}\` found on tag. Remove the duplicate occurrence.`, attributeNode.name.location, "error");
                 }
             }
         }
@@ -866,16 +1292,16 @@ class NoDuplicateAttributesVisitor extends BaseRuleVisitor {
 }
 class HTMLNoDuplicateAttributesRule extends ParserRule {
     name = "html-no-duplicate-attributes";
-    check(node, context) {
+    check(result, context) {
         const visitor = new NoDuplicateAttributesVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
 class NoDuplicateIdsVisitor extends AttributeVisitorMixin {
     documentIds = new Set();
-    checkAttribute(attributeName, attributeValue, attributeNode) {
+    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }) {
         if (attributeName.toLowerCase() !== "id")
             return;
         if (!attributeValue)
@@ -890,9 +1316,9 @@ class NoDuplicateIdsVisitor extends AttributeVisitorMixin {
 }
 class HTMLNoDuplicateIdsRule extends ParserRule {
     name = "html-no-duplicate-ids";
-    check(node, context) {
+    check(result, context) {
         const visitor = new NoDuplicateIdsVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
@@ -902,10 +1328,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
         this.checkHeadingElement(node);
         super.visitHTMLElementNode(node);
     }
-    visitHTMLSelfCloseTagNode(node) {
-        this.checkSelfClosingHeading(node);
-        super.visitHTMLSelfCloseTagNode(node);
-    }
     checkHeadingElement(node) {
         if (!node.open_tag || node.open_tag.type !== "AST_HTML_OPEN_TAG_NODE") {
             return;
@@ -927,23 +1349,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
             this.addOffense(`Heading element ${elementDescription} must not be empty. Provide accessible text content for screen readers and SEO.`, node.location, "error");
         }
     }
-    checkSelfClosingHeading(node) {
-        const tagName = getTagName(node);
-        if (!tagName) {
-            return;
-        }
-        // Check if it's a standard heading tag (h1-h6) or has role="heading"
-        const isStandardHeading = HEADING_TAGS.has(tagName);
-        const isAriaHeading = this.hasHeadingRole(node);
-        if (!isStandardHeading && !isAriaHeading) {
-            return;
-        }
-        // Self-closing headings are always empty
-        const elementDescription = isStandardHeading
-            ? `\`<${tagName}>\``
-            : `\`<${tagName} role="heading">\``;
-        this.addOffense(`Heading element ${elementDescription} must not be empty. Provide accessible text content for screen readers and SEO.`, node.tag_name.location, "error");
-    }
     isEmptyHeading(node) {
         if (!node.body || node.body.length === 0) {
             return true;
@@ -1037,9 +1442,9 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
 }
 class HTMLNoEmptyHeadingsRule extends ParserRule {
     name = "html-no-empty-headings";
-    check(node, context) {
+    check(result, context) {
         const visitor = new NoEmptyHeadingsVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
@@ -1081,60 +1486,152 @@ class NestedLinkVisitor extends BaseRuleVisitor {
 }
 class HTMLNoNestedLinksRule extends ParserRule {
     name = "html-no-nested-links";
-    check(node, context) {
+    check(result, context) {
         const visitor = new NestedLinkVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
-class TagNameLowercaseVisitor extends BaseRuleVisitor {
-    visitHTMLElementNode(node) {
-        const tagName = node.tag_name?.value;
-        if (node.open_tag) {
-            this.checkTagName(node.open_tag);
+class NoPositiveTabIndexVisitor extends AttributeVisitorMixin {
+    checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }) {
+        if (attributeName !== "tabindex")
+            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");
         }
-        if (tagName && ["svg"].includes(tagName.toLowerCase())) {
-            if (node.close_tag) {
-                this.checkTagName(node.close_tag);
-            }
+    }
+}
+class HTMLNoPositiveTabIndexRule extends ParserRule {
+    name = "html-no-positive-tab-index";
+    check(result, context) {
+        const visitor = new NoPositiveTabIndexVisitor(this.name, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+class NoSelfClosingVisitor extends BaseRuleVisitor {
+    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");
+        }
+        super.visitHTMLOpenTagNode(node);
+    }
+}
+class HTMLNoSelfClosingRule extends ParserRule {
+    name = "html-no-self-closing";
+    check(result, context) {
+        const visitor = new NoSelfClosingVisitor(this.name, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
+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;
         }
-        this.visitChildNodes(node);
-        if (node.close_tag) {
+        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) {
+        this.hasXMLDeclaration = true;
+    }
+    visitChildNodes(node) {
+        if (this.hasXMLDeclaration)
+            return;
+        super.visitChildNodes(node);
+    }
+}
+class TagNameLowercaseVisitor extends BaseRuleVisitor {
+    visitHTMLElementNode(node) {
+        if (core.getTagName(node).toLowerCase() === "svg") {
+            this.checkTagName(node.open_tag);
             this.checkTagName(node.close_tag);
         }
+        else {
+            super.visitHTMLElementNode(node);
+        }
     }
-    visitHTMLSelfCloseTagNode(node) {
+    visitHTMLOpenTagNode(node) {
+        this.checkTagName(node);
+    }
+    visitHTMLCloseTagNode(node) {
         this.checkTagName(node);
-        this.visitChildNodes(node);
     }
     checkTagName(node) {
-        const tagName = node.tag_name?.value;
+        if (!node)
+            return;
+        const tagName = core.getTagName(node);
         if (!tagName)
             return;
         const lowercaseTagName = tagName.toLowerCase();
+        const type = core.isNode(node, core.HTMLOpenTagNode) ? "Opening" : "Closing";
+        const open = core.isNode(node, core.HTMLOpenTagNode) ? "<" : "</";
         if (tagName !== lowercaseTagName) {
-            let type = node.type;
-            if (node.type == "AST_HTML_OPEN_TAG_NODE")
-                type = "Opening";
-            if (node.type == "AST_HTML_CLOSE_TAG_NODE")
-                type = "Closing";
-            if (node.type == "AST_HTML_SELF_CLOSE_TAG_NODE")
-                type = "Self-closing";
-            this.addOffense(`${type} tag name \`${tagName}\` should be lowercase. Use \`${lowercaseTagName}\` instead.`, node.tag_name.location, "error");
+            this.addOffense(`${type} tag name \`${open}${tagName}>\` should be lowercase. Use \`${open}${lowercaseTagName}>\` instead.`, node.tag_name.location, "error");
         }
     }
 }
 class HTMLTagNameLowercaseRule extends ParserRule {
     name = "html-tag-name-lowercase";
-    check(node, context) {
+    isEnabled(result, context) {
+        if (context?.fileName?.endsWith(".xml") || context?.fileName?.endsWith(".xml.erb")) {
+            return false;
+        }
+        const checker = new XMLDeclarationChecker(this.name);
+        checker.visit(result.value);
+        return !checker.hasXMLDeclaration;
+    }
+    check(result, context) {
         const visitor = new TagNameLowercaseVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
 
+class ParserNoErrorsRule extends ParserRule {
+    name = "parser-no-errors";
+    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"
+        };
+    }
+}
+
 class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
     insideSVG = false;
     visitHTMLElementNode(node) {
@@ -1156,12 +1653,6 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
         }
         this.visitChildNodes(node);
     }
-    visitHTMLSelfCloseTagNode(node) {
-        if (this.insideSVG) {
-            this.checkTagName(node);
-        }
-        this.visitChildNodes(node);
-    }
     checkTagName(node) {
         const tagName = node.tag_name?.value;
         if (!tagName)
@@ -1176,17 +1667,15 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
                 type = "Opening";
             if (node.type == "AST_HTML_CLOSE_TAG_NODE")
                 type = "Closing";
-            if (node.type == "AST_HTML_SELF_CLOSE_TAG_NODE")
-                type = "Self-closing";
             this.addOffense(`${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`, node.tag_name.location, "error");
         }
     }
 }
 class SVGTagNameCapitalizationRule extends ParserRule {
     name = "svg-tag-name-capitalization";
-    check(node, context) {
+    check(result, context) {
         const visitor = new SVGTagNameCapitalizationVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
@@ -1194,24 +1683,35 @@ class SVGTagNameCapitalizationRule extends ParserRule {
 const defaultRules = [
     ERBNoEmptyTagsRule,
     ERBNoOutputControlFlowRule,
+    ERBNoSilentTagInAttributeNameRule,
     ERBPreferImageTagHelperRule,
     ERBRequiresTrailingNewlineRule,
     ERBRequireWhitespaceRule,
     HTMLAnchorRequireHrefRule,
     HTMLAriaAttributeMustBeValid,
+    HTMLAriaLabelIsWellFormattedRule,
     HTMLAriaLevelMustBeValidRule,
     HTMLAriaRoleHeadingRequiresLevelRule,
     HTMLAriaRoleMustBeValidRule,
     HTMLAttributeDoubleQuotesRule,
+    HTMLAttributeEqualsSpacingRule,
     HTMLAttributeValuesRequireQuotesRule,
+    HTMLAvoidBothDisabledAndAriaDisabledRule,
     HTMLBooleanAttributesNoValueRule,
+    HTMLIframeHasTitleRule,
     HTMLImgRequireAltRule,
+    HTMLNavigationHasLabelRule,
+    HTMLNoAriaHiddenOnFocusableRule,
     // HTMLNoBlockInsideInlineRule,
     HTMLNoDuplicateAttributesRule,
     HTMLNoDuplicateIdsRule,
     HTMLNoEmptyHeadingsRule,
     HTMLNoNestedLinksRule,
+    HTMLNoPositiveTabIndexRule,
+    HTMLNoSelfClosingRule,
+    HTMLNoTitleAttributeRule,
     HTMLTagNameLowercaseRule,
+    ParserNoErrorsRule,
     SVGTagNameCapitalizationRule,
 ];
 
@@ -1258,19 +1758,44 @@ class Linter {
      */
     lint(source, context) {
         this.offenses = [];
-        const parseResult = this.herb.parse(source);
+        const parseResult = this.herb.parse(source, { track_whitespace: true });
         const lexResult = this.herb.lex(source);
         for (const RuleClass of this.rules) {
             const rule = new RuleClass();
+            let isEnabled = true;
             let ruleOffenses;
             if (this.isLexerRule(rule)) {
-                ruleOffenses = rule.check(lexResult, context);
+                if (rule.isEnabled) {
+                    isEnabled = rule.isEnabled(lexResult, context);
+                }
+                if (isEnabled) {
+                    ruleOffenses = rule.check(lexResult, context);
+                }
+                else {
+                    ruleOffenses = [];
+                }
             }
             else if (this.isSourceRule(rule)) {
-                ruleOffenses = rule.check(source, context);
+                if (rule.isEnabled) {
+                    isEnabled = rule.isEnabled(source, context);
+                }
+                if (isEnabled) {
+                    ruleOffenses = rule.check(source, context);
+                }
+                else {
+                    ruleOffenses = [];
+                }
             }
             else {
-                ruleOffenses = rule.check(parseResult.value, context);
+                if (rule.isEnabled) {
+                    isEnabled = rule.isEnabled(parseResult, context);
+                }
+                if (isEnabled) {
+                    ruleOffenses = rule.check(parseResult, context);
+                }
+                else {
+                    ruleOffenses = [];
+                }
             }
             this.offenses.push(...ruleOffenses);
         }
@@ -1295,7 +1820,7 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
         const isUnknown = !isInline && !isBlock;
         return { isInline, isBlock, isUnknown };
     }
-    addViolationMessage(tagName, isBlock, openTag) {
+    addOffenseMessage(tagName, isBlock, openTag) {
         const parentInline = this.inlineStack[this.inlineStack.length - 1];
         const elementType = isBlock ? "Block-level" : "Unknown";
         this.addOffense(`${elementType} element \`<${tagName}>\` cannot be placed inside inline element \`<${parentInline}>\`.`, openTag.tag_name.location, "error");
@@ -1324,7 +1849,7 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
         }
         const { isInline, isBlock, isUnknown } = this.getElementType(tagName);
         if ((isBlock || isUnknown) && this.inlineStack.length > 0) {
-            this.addViolationMessage(tagName, isBlock, openTag);
+            this.addOffenseMessage(tagName, isBlock, openTag);
         }
         if (isInline) {
             this.visitInlineElement(node, tagName);
@@ -1335,9 +1860,9 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
 }
 class HTMLNoBlockInsideInlineRule extends ParserRule {
     name = "html-no-block-inside-inline";
-    check(node, context) {
+    check(result, context) {
         const visitor = new BlockInsideInlineVisitor(this.name, context);
-        visitor.visit(node);
+        visitor.visit(result.value);
         return visitor.offenses;
     }
 }
@@ -1345,21 +1870,31 @@ class HTMLNoBlockInsideInlineRule extends ParserRule {
 exports.DEFAULT_LINT_CONTEXT = DEFAULT_LINT_CONTEXT;
 exports.ERBNoEmptyTagsRule = ERBNoEmptyTagsRule;
 exports.ERBNoOutputControlFlowRule = ERBNoOutputControlFlowRule;
+exports.ERBNoSilentTagInAttributeNameRule = ERBNoSilentTagInAttributeNameRule;
 exports.ERBPreferImageTagHelperRule = ERBPreferImageTagHelperRule;
 exports.ERBRequiresTrailingNewlineRule = ERBRequiresTrailingNewlineRule;
 exports.HTMLAnchorRequireHrefRule = HTMLAnchorRequireHrefRule;
+exports.HTMLAriaLabelIsWellFormattedRule = HTMLAriaLabelIsWellFormattedRule;
 exports.HTMLAriaLevelMustBeValidRule = HTMLAriaLevelMustBeValidRule;
 exports.HTMLAriaRoleHeadingRequiresLevelRule = HTMLAriaRoleHeadingRequiresLevelRule;
 exports.HTMLAriaRoleMustBeValidRule = HTMLAriaRoleMustBeValidRule;
 exports.HTMLAttributeDoubleQuotesRule = HTMLAttributeDoubleQuotesRule;
+exports.HTMLAttributeEqualsSpacingRule = HTMLAttributeEqualsSpacingRule;
 exports.HTMLAttributeValuesRequireQuotesRule = HTMLAttributeValuesRequireQuotesRule;
+exports.HTMLAvoidBothDisabledAndAriaDisabledRule = HTMLAvoidBothDisabledAndAriaDisabledRule;
 exports.HTMLBooleanAttributesNoValueRule = HTMLBooleanAttributesNoValueRule;
+exports.HTMLIframeHasTitleRule = HTMLIframeHasTitleRule;
 exports.HTMLImgRequireAltRule = HTMLImgRequireAltRule;
+exports.HTMLNavigationHasLabelRule = HTMLNavigationHasLabelRule;
+exports.HTMLNoAriaHiddenOnFocusableRule = HTMLNoAriaHiddenOnFocusableRule;
 exports.HTMLNoBlockInsideInlineRule = HTMLNoBlockInsideInlineRule;
 exports.HTMLNoDuplicateAttributesRule = HTMLNoDuplicateAttributesRule;
 exports.HTMLNoDuplicateIdsRule = HTMLNoDuplicateIdsRule;
 exports.HTMLNoEmptyHeadingsRule = HTMLNoEmptyHeadingsRule;
 exports.HTMLNoNestedLinksRule = HTMLNoNestedLinksRule;
+exports.HTMLNoPositiveTabIndexRule = HTMLNoPositiveTabIndexRule;
+exports.HTMLNoSelfClosingRule = HTMLNoSelfClosingRule;
+exports.HTMLNoTitleAttributeRule = HTMLNoTitleAttributeRule;
 exports.HTMLTagNameLowercaseRule = HTMLTagNameLowercaseRule;
 exports.LexerRule = LexerRule;
 exports.Linter = Linter;