@herb-tools/linter 0.6.1 → 0.7.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Visitor, Position, Location, getStaticAttributeName, hasERBOutput, isEffectivelyStatic, getValidatableStaticContent, hasDynamicAttributeName as hasDynamicAttributeName$1, getCombinedAttributeName, filterERBContentNodes, filterNodes, ERBContentNode, isERBOutputNode, getNodesBeforePosition, getNodesAfterPosition, isToken, isParseResult, isNode, LiteralNode, isERBNode, filterLiteralNodes, getTagName as getTagName$1, HTMLOpenTagNode } from '@herb-tools/core';
+import { Visitor, getStaticAttributeName, hasDynamicAttributeName as hasDynamicAttributeName$1, getCombinedAttributeName, hasStaticContent, getStaticContentFromNodes, Position, Location, hasERBOutput, isEffectivelyStatic, getValidatableStaticContent, filterERBContentNodes, filterNodes, ERBContentNode, isERBOutputNode, getNodesBeforePosition, getNodesAfterPosition, isToken, isParseResult, isNode, LiteralNode, isERBNode, filterLiteralNodes, getTagName as getTagName$1, HTMLOpenTagNode } from '@herb-tools/core';
 
 class ParserRule {
     static type = "parser";
@@ -133,10 +133,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 = getStaticAttributeName(nameNode);
+        if (!lowercase)
+            return staticName;
         return staticName ? staticName.toLowerCase() : null;
     }
     return null;
@@ -171,6 +173,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)
  */
@@ -191,6 +202,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 hasStaticContent(valueNodes);
+}
+/**
+ * Gets the static content of an attribute value (all literal parts combined)
+ * Returns the concatenated literal content, or null if no literal nodes exist
+ */
+function getStaticAttributeValueContent(attributeNode) {
+    const valueNodes = getAttributeValueNodes(attributeNode);
+    return getStaticContentFromNodes(valueNodes);
+}
 /**
  * Gets the attribute value content from an HTMLAttributeValueNode
  */
@@ -465,6 +491,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);
@@ -475,16 +502,17 @@ class AttributeVisitorMixin extends BaseRuleVisitor {
                     attributeName: staticAttributeName,
                     attributeValue: staticAttributeValue,
                     attributeNode,
+                    originalAttributeName,
                     parentNode: node
                 });
             }
             else if (staticAttributeName && isEffectivelyStaticValue && !hasOutputERB) {
                 const validatableContent = 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;
@@ -504,28 +532,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
  */
@@ -537,6 +575,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
  */
@@ -800,6 +892,8 @@ class Printer extends Visitor {
      * @throws {Error} When node has parse errors and ignoreErrors is false
      */
     print(input, options = DEFAULT_PRINT_OPTIONS) {
+        if (!input)
+            return "";
         if (isToken(input)) {
             return input.value;
         }
@@ -1402,7 +1496,7 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
         try {
             return ERBToRubyStringPrinter.print(node, { ignoreErrors: false });
         }
-        catch (error) {
+        catch {
             return "expression";
         }
     }
@@ -1786,19 +1880,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 {
@@ -1871,47 +1964,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"
 ]);
@@ -2162,6 +2214,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);
@@ -2338,7 +2444,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");
         }
     }
 }
@@ -2377,31 +2483,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) {
@@ -2508,9 +2589,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");
         }
@@ -2525,6 +2606,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 = getStaticContentFromNodes(nameNodes);
+        this.check(attributeName, attributeNode);
+    }
+    checkDynamicAttributeDynamicValue({ nameNodes, attributeNode }) {
+        const attributeName = 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,
@@ -2545,19 +2658,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 {
@@ -2654,6 +2769,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) {
@@ -2712,5 +2868,30 @@ class HTMLNoBlockInsideInlineRule extends ParserRule {
     }
 }
 
-export { DEFAULT_LINT_CONTEXT, ERBNoEmptyTagsRule, ERBNoOutputControlFlowRule, ERBNoSilentTagInAttributeNameRule, ERBPreferImageTagHelperRule, ERBRequiresTrailingNewlineRule, HTMLAnchorRequireHrefRule, HTMLAriaLabelIsWellFormattedRule, HTMLAriaLevelMustBeValidRule, HTMLAriaRoleHeadingRequiresLevelRule, HTMLAriaRoleMustBeValidRule, HTMLAttributeDoubleQuotesRule, HTMLAttributeEqualsSpacingRule, HTMLAttributeValuesRequireQuotesRule, HTMLAvoidBothDisabledAndAriaDisabledRule, HTMLBooleanAttributesNoValueRule, HTMLIframeHasTitleRule, HTMLImgRequireAltRule, HTMLNavigationHasLabelRule, HTMLNoAriaHiddenOnFocusableRule, HTMLNoBlockInsideInlineRule, HTMLNoDuplicateAttributesRule, HTMLNoDuplicateIdsRule, HTMLNoEmptyHeadingsRule, HTMLNoNestedLinksRule, HTMLNoPositiveTabIndexRule, HTMLNoSelfClosingRule, HTMLNoTitleAttributeRule, HTMLTagNameLowercaseRule, LexerRule, Linter, ParserRule, SVGTagNameCapitalizationRule, SourceRule };
+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;
+    }
+}
+
+export { ARIA_ATTRIBUTES, AttributeVisitorMixin, BaseLexerRuleVisitor, BaseRuleVisitor, BaseSourceRuleVisitor, ControlFlowTrackingVisitor, ControlFlowType, DEFAULT_LINT_CONTEXT, ERBNoEmptyTagsRule, ERBNoOutputControlFlowRule, ERBNoSilentTagInAttributeNameRule, ERBPreferImageTagHelperRule, ERBRequiresTrailingNewlineRule, HEADING_TAGS, HTMLAnchorRequireHrefRule, HTMLAriaLabelIsWellFormattedRule, HTMLAriaLevelMustBeValidRule, HTMLAriaRoleHeadingRequiresLevelRule, HTMLAriaRoleMustBeValidRule, HTMLAttributeDoubleQuotesRule, HTMLAttributeEqualsSpacingRule, HTMLAttributeValuesRequireQuotesRule, HTMLAvoidBothDisabledAndAriaDisabledRule, HTMLBooleanAttributesNoValueRule, HTMLIframeHasTitleRule, HTMLImgRequireAltRule, HTMLNavigationHasLabelRule, HTMLNoAriaHiddenOnFocusableRule, HTMLNoBlockInsideInlineRule, HTMLNoDuplicateAttributesRule, HTMLNoDuplicateIdsRule, HTMLNoEmptyAttributesRule, HTMLNoEmptyHeadingsRule, HTMLNoNestedLinksRule, HTMLNoPositiveTabIndexRule, HTMLNoSelfClosingRule, HTMLNoTitleAttributeRule, HTMLNoUnderscoresInAttributeNamesRule, HTMLTagNameLowercaseRule, HTML_BLOCK_ELEMENTS, HTML_BOOLEAN_ATTRIBUTES, HTML_INLINE_ELEMENTS, HTML_VOID_ELEMENTS, LexerRule, Linter, ParserRule, SVGTagNameCapitalizationRule, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE, SourceRule, VALID_ARIA_ROLES, createEndOfFileLocation, findAttributeByName, forEachAttribute, getAttribute, getAttributeName, getAttributeValue, getAttributeValueNodes, getAttributeValueQuoteType, getAttributes, getCombinedAttributeNameString, getStaticAttributeValue, getStaticAttributeValueContent, getTagName, hasAttribute, hasAttributeValue, hasDynamicAttributeName, hasDynamicAttributeValue, hasStaticAttributeValue, hasStaticAttributeValueContent, isAttributeValueQuoted, isBlockElement, isBooleanAttribute, isInlineElement, isVoidElement };
 //# sourceMappingURL=index.js.map