@herb-tools/linter 0.4.1 → 0.4.3

package/dist/index.cjs

@@ -2,15 +2,33 @@
 
 var core = require('@herb-tools/core');
 
+class ParserRule {
+    static type = "parser";
+}
+class LexerRule {
+    static type = "lexer";
+}
+/**
+ * Default context object with all keys defined but set to undefined
+ */
+const DEFAULT_LINT_CONTEXT = {
+    fileName: undefined
+};
+class SourceRule {
+    static type = "source";
+}
+
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
 class BaseRuleVisitor extends core.Visitor {
     offenses = [];
     ruleName;
-    constructor(ruleName) {
+    context;
+    constructor(ruleName, context) {
         super();
         this.ruleName = ruleName;
+        this.context = { ...DEFAULT_LINT_CONTEXT, ...context };
     }
     /**
      * Helper method to create a lint offense
@@ -148,6 +166,49 @@ const HTML_BOOLEAN_ATTRIBUTES = new Set([
     "noresize", "noshade", "nowrap", "sortable", "truespeed", "typemustmatch"
 ]);
 const HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+/**
+ * SVG elements that use camelCase naming
+ */
+const SVG_CAMEL_CASE_ELEMENTS = new Set([
+    "animateMotion",
+    "animateTransform",
+    "clipPath",
+    "feBlend",
+    "feColorMatrix",
+    "feComponentTransfer",
+    "feComposite",
+    "feConvolveMatrix",
+    "feDiffuseLighting",
+    "feDisplacementMap",
+    "feDistantLight",
+    "feDropShadow",
+    "feFlood",
+    "feFuncA",
+    "feFuncB",
+    "feFuncG",
+    "feFuncR",
+    "feGaussianBlur",
+    "feImage",
+    "feMerge",
+    "feMergeNode",
+    "feMorphology",
+    "feOffset",
+    "fePointLight",
+    "feSpecularLighting",
+    "feSpotLight",
+    "feTile",
+    "feTurbulence",
+    "foreignObject",
+    "glyphRef",
+    "linearGradient",
+    "radialGradient",
+    "textPath"
+]);
+/**
+ * Mapping from lowercase SVG element names to their correct camelCase versions
+ * Generated dynamically from SVG_CAMEL_CASE_ELEMENTS
+ */
+const SVG_LOWERCASE_TO_CAMELCASE = new Map(Array.from(SVG_CAMEL_CASE_ELEMENTS).map(element => [element.toLowerCase(), element]));
 const VALID_ARIA_ROLES = new Set([
     "banner", "complementary", "contentinfo", "form", "main", "navigation", "region", "search",
     "article", "cell", "columnheader", "definition", "directory", "document", "feed", "figure",
@@ -210,6 +271,19 @@ const ARIA_ATTRIBUTES = new Set([
     'aria-valuenow',
     'aria-valuetext',
 ]);
+/**
+ * Helper function to create a location at the end of the source with a 1-character range
+ */
+function createEndOfFileLocation(source) {
+    const lines = source.split('\n');
+    const lastLineNumber = lines.length;
+    const lastLine = lines[lines.length - 1];
+    const lastColumnNumber = lastLine.length;
+    const startColumn = lastColumnNumber > 0 ? lastColumnNumber - 1 : 0;
+    const start = new core.Position(lastLineNumber, startColumn);
+    const end = new core.Position(lastLineNumber, lastColumnNumber);
+    return new core.Location(start, end);
+}
 /**
  * Checks if an element is inline
  */
@@ -234,6 +308,9 @@ function isBooleanAttribute(attributeName) {
  * and attribute iteration logic. Provides simplified interface with extracted attribute info.
  */
 class AttributeVisitorMixin extends BaseRuleVisitor {
+    constructor(ruleName, context) {
+        super(ruleName, context);
+    }
     visitHTMLOpenTagNode(node) {
         this.checkAttributesOnNode(node);
         super.visitHTMLOpenTagNode(node);
@@ -263,6 +340,56 @@ function forEachAttribute(node, callback) {
         }
     }
 }
+/**
+ * Base source visitor class that provides common functionality for source-based rule visitors
+ */
+class BaseSourceRuleVisitor {
+    offenses = [];
+    ruleName;
+    context;
+    constructor(ruleName, context) {
+        this.ruleName = ruleName;
+        this.context = { ...DEFAULT_LINT_CONTEXT, ...context };
+    }
+    /**
+     * Helper method to create a lint offense for source rules
+     */
+    createOffense(message, location, severity = "error") {
+        return {
+            rule: this.ruleName, // Type assertion for compatibility
+            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 source rule visitors
+     * @param source - The raw source code
+     */
+    visit(source) {
+        this.visitSource(source);
+    }
+    /**
+     * Helper method to create a location for a specific position in the source
+     */
+    createLocationAt(source, position) {
+        const beforePosition = source.substring(0, position);
+        const lines = beforePosition.split('\n');
+        const line = lines.length;
+        const column = lines[lines.length - 1].length + 1;
+        const start = new core.Position(line, column);
+        const end = new core.Position(line, column);
+        return new core.Location(start, end);
+    }
+}
 
 class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
     visitERBContentNode(node) {
@@ -277,10 +404,10 @@ class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
         this.addOffense("ERB tag should not be empty. Remove empty ERB tags or add content.", node.location, "error");
     }
 }
-class ERBNoEmptyTagsRule {
+class ERBNoEmptyTagsRule extends ParserRule {
     name = "erb-no-empty-tags";
-    check(node) {
-        const visitor = new ERBNoEmptyTagsVisitor(this.name);
+    check(node, context) {
+        const visitor = new ERBNoEmptyTagsVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -323,15 +450,126 @@ class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
         return;
     }
 }
-class ERBNoOutputControlFlowRule {
+class ERBNoOutputControlFlowRule extends ParserRule {
     name = "erb-no-output-control-flow";
-    check(node) {
-        const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name);
+    check(node, context) {
+        const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name, context);
+        visitor.visit(node);
+        return visitor.offenses;
+    }
+}
+
+class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
+    visitHTMLOpenTagNode(node) {
+        this.checkImgTag(node);
+        super.visitHTMLOpenTagNode(node);
+    }
+    visitHTMLSelfCloseTagNode(node) {
+        this.checkImgTag(node);
+        super.visitHTMLSelfCloseTagNode(node);
+    }
+    checkImgTag(node) {
+        const tagName = getTagName(node);
+        if (tagName !== "img") {
+            return;
+        }
+        const attributes = getAttributes(node);
+        const srcAttribute = findAttributeByName(attributes, "src");
+        if (!srcAttribute) {
+            return;
+        }
+        if (!srcAttribute.value) {
+            return;
+        }
+        const valueNode = srcAttribute.value;
+        const hasERBContent = this.containsERBContent(valueNode);
+        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");
+        }
+    }
+    containsERBContent(valueNode) {
+        if (!valueNode.children)
+            return false;
+        return valueNode.children.some(child => child.type === "AST_ERB_CONTENT_NODE");
+    }
+    buildSuggestedExpression(valueNode) {
+        if (!valueNode.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;
+        }
+        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;
+            }
+        }
+        return "expression";
+    }
+}
+class ERBPreferImageTagHelperRule extends ParserRule {
+    name = "erb-prefer-image-tag-helper";
+    check(node, context) {
+        const visitor = new ERBPreferImageTagHelperVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
 }
 
+class ERBRequiresTrailingNewlineVisitor extends BaseSourceRuleVisitor {
+    visitSource(source) {
+        if (source.length === 0)
+            return;
+        if (source.endsWith('\n'))
+            return;
+        if (!this.context.fileName)
+            return;
+        this.addOffense("File must end with trailing newline", createEndOfFileLocation(source), "error");
+    }
+}
+class ERBRequiresTrailingNewlineRule extends SourceRule {
+    name = "erb-requires-trailing-newline";
+    check(source, context) {
+        const visitor = new ERBRequiresTrailingNewlineVisitor(this.name, context);
+        visitor.visit(source);
+        return visitor.offenses;
+    }
+}
+
 class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     visitChildNodes(node) {
         this.checkWhitespace(node);
@@ -348,8 +586,24 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
             return;
         }
         const value = content.value;
-        this.checkOpenTagWhitespace(openTag, value);
-        this.checkCloseTagWhitespace(closeTag, value);
+        if (openTag.value === "<%#") {
+            this.checkCommentTagWhitespace(openTag, closeTag, value);
+        }
+        else {
+            this.checkOpenTagWhitespace(openTag, value);
+            this.checkCloseTagWhitespace(closeTag, value);
+        }
+    }
+    checkCommentTagWhitespace(openTag, closeTag, content) {
+        if (!content.startsWith(" ") && !content.startsWith("\n") && !content.startsWith("=")) {
+            this.addOffense(`Add whitespace after \`${openTag.value}\`.`, openTag.location, "error");
+        }
+        else if (content.startsWith("=") && content.length > 1 && !content[1].match(/\s/)) {
+            this.addOffense(`Add whitespace after \`<%#=\`.`, openTag.location, "error");
+        }
+        if (!content.endsWith(" ") && !content.endsWith("\n")) {
+            this.addOffense(`Add whitespace before \`${closeTag.value}\`.`, closeTag.location, "error");
+        }
     }
     checkOpenTagWhitespace(openTag, content) {
         if (content.startsWith(" ") || content.startsWith("\n")) {
@@ -364,10 +618,10 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
         this.addOffense(`Add whitespace before \`${closeTag.value}\`.`, closeTag.location, "error");
     }
 }
-class ERBRequireWhitespaceRule {
+class ERBRequireWhitespaceRule extends ParserRule {
     name = "erb-require-whitespace-inside-tags";
-    check(node) {
-        const visitor = new RequireWhitespaceInsideTags(this.name);
+    check(node, context) {
+        const visitor = new RequireWhitespaceInsideTags(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -388,10 +642,10 @@ class AnchorRechireHrefVisitor extends BaseRuleVisitor {
         }
     }
 }
-class HTMLAnchorRequireHrefRule {
+class HTMLAnchorRequireHrefRule extends ParserRule {
     name = "html-anchor-require-href";
-    check(node) {
-        const visitor = new AnchorRechireHrefVisitor(this.name);
+    check(node, context) {
+        const visitor = new AnchorRechireHrefVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -411,10 +665,35 @@ class AriaAttributeMustBeValid extends AttributeVisitorMixin {
         }
     }
 }
-class HTMLAriaAttributeMustBeValid {
+class HTMLAriaAttributeMustBeValid extends ParserRule {
     name = "html-aria-attribute-must-be-valid";
-    check(node) {
-        const visitor = new AriaAttributeMustBeValid(this.name);
+    check(node, context) {
+        const visitor = new AriaAttributeMustBeValid(this.name, context);
+        visitor.visit(node);
+        return visitor.offenses;
+    }
+}
+
+class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
+    checkAttribute(attributeName, attributeValue, attributeNode, _parentNode) {
+        if (attributeName !== "aria-level")
+            return;
+        if (attributeValue !== null && attributeValue.includes("<%"))
+            return;
+        if (attributeValue === null || attributeValue === "") {
+            this.addOffense(`The \`aria-level\` attribute must be an integer between 1 and 6, got an empty value.`, attributeNode.location);
+            return;
+        }
+        const number = parseInt(attributeValue);
+        if (isNaN(number) || number < 1 || number > 6 || attributeValue !== number.toString()) {
+            this.addOffense(`The \`aria-level\` attribute must be an integer between 1 and 6, got \`${attributeValue}\`.`, attributeNode.location);
+        }
+    }
+}
+class HTMLAriaLevelMustBeValidRule extends ParserRule {
+    name = "html-aria-level-must-be-valid";
+    check(node, context) {
+        const visitor = new HTMLAriaLevelMustBeValidVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -436,10 +715,10 @@ class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
         }
     }
 }
-class HTMLAriaRoleHeadingRequiresLevelRule {
+class HTMLAriaRoleHeadingRequiresLevelRule extends ParserRule {
     name = "html-aria-role-heading-requires-level";
-    check(node) {
-        const visitor = new AriaRoleHeadingRequiresLevel(this.name);
+    check(node, context) {
+        const visitor = new AriaRoleHeadingRequiresLevel(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -456,10 +735,10 @@ class AriaRoleMustBeValid extends AttributeVisitorMixin {
         this.addOffense(`The \`role\` attribute must be a valid ARIA role. Role \`${attributeValue}\` is not recognized.`, attributeNode.location, "error");
     }
 }
-class HTMLAriaRoleMustBeValidRule {
+class HTMLAriaRoleMustBeValidRule extends ParserRule {
     name = "html-aria-role-must-be-valid";
-    check(node) {
-        const visitor = new AriaRoleMustBeValid(this.name);
+    check(node, context) {
+        const visitor = new AriaRoleMustBeValid(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -476,10 +755,10 @@ class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
         this.addOffense(`Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="value"\`.`, attributeNode.value.location, "warning");
     }
 }
-class HTMLAttributeDoubleQuotesRule {
+class HTMLAttributeDoubleQuotesRule extends ParserRule {
     name = "html-attribute-double-quotes";
-    check(node) {
-        const visitor = new AttributeDoubleQuotesVisitor(this.name);
+    check(node, context) {
+        const visitor = new AttributeDoubleQuotesVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -497,10 +776,10 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
         `Attribute value should be quoted: \`${attributeName}="value"\`. Always wrap attribute values in quotes.`, valueNode.location, "error");
     }
 }
-class HTMLAttributeValuesRequireQuotesRule {
+class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
     name = "html-attribute-values-require-quotes";
-    check(node) {
-        const visitor = new AttributeValuesRequireQuotesVisitor(this.name);
+    check(node, context) {
+        const visitor = new AttributeValuesRequireQuotesVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -515,10 +794,10 @@ class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
         this.addOffense(`Boolean attribute \`${attributeName}\` should not have a value. Use \`${attributeName}\` instead of \`${attributeName}="${attributeName}"\`.`, attributeNode.value.location, "error");
     }
 }
-class HTMLBooleanAttributesNoValueRule {
+class HTMLBooleanAttributesNoValueRule extends ParserRule {
     name = "html-boolean-attributes-no-value";
-    check(node) {
-        const visitor = new BooleanAttributesNoValueVisitor(this.name);
+    check(node, context) {
+        const visitor = new BooleanAttributesNoValueVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -543,10 +822,10 @@ class ImgRequireAltVisitor extends BaseRuleVisitor {
         }
     }
 }
-class HTMLImgRequireAltRule {
+class HTMLImgRequireAltRule extends ParserRule {
     name = "html-img-require-alt";
-    check(node) {
-        const visitor = new ImgRequireAltVisitor(this.name);
+    check(node, context) {
+        const visitor = new ImgRequireAltVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -585,10 +864,10 @@ class NoDuplicateAttributesVisitor extends BaseRuleVisitor {
         }
     }
 }
-class HTMLNoDuplicateAttributesRule {
+class HTMLNoDuplicateAttributesRule extends ParserRule {
     name = "html-no-duplicate-attributes";
-    check(node) {
-        const visitor = new NoDuplicateAttributesVisitor(this.name);
+    check(node, context) {
+        const visitor = new NoDuplicateAttributesVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -609,10 +888,10 @@ class NoDuplicateIdsVisitor extends AttributeVisitorMixin {
         this.documentIds.add(id);
     }
 }
-class HTMLNoDuplicateIdsRule {
+class HTMLNoDuplicateIdsRule extends ParserRule {
     name = "html-no-duplicate-ids";
-    check(node) {
-        const visitor = new NoDuplicateIdsVisitor(this.name);
+    check(node, context) {
+        const visitor = new NoDuplicateIdsVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -756,10 +1035,10 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
         return false;
     }
 }
-class HTMLNoEmptyHeadingsRule {
+class HTMLNoEmptyHeadingsRule extends ParserRule {
     name = "html-no-empty-headings";
-    check(node) {
-        const visitor = new NoEmptyHeadingsVisitor(this.name);
+    check(node, context) {
+        const visitor = new NoEmptyHeadingsVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -800,33 +1079,98 @@ class NestedLinkVisitor extends BaseRuleVisitor {
         super.visitHTMLOpenTagNode(node);
     }
 }
-class HTMLNoNestedLinksRule {
+class HTMLNoNestedLinksRule extends ParserRule {
     name = "html-no-nested-links";
-    check(node) {
-        const visitor = new NestedLinkVisitor(this.name);
+    check(node, context) {
+        const visitor = new NestedLinkVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
 }
 
 class TagNameLowercaseVisitor extends BaseRuleVisitor {
-    visitHTMLOpenTagNode(node) {
-        this.checkTagName(node);
+    visitHTMLElementNode(node) {
+        const tagName = node.tag_name?.value;
+        if (node.open_tag) {
+            this.checkTagName(node.open_tag);
+        }
+        if (tagName && ["svg"].includes(tagName.toLowerCase())) {
+            if (node.close_tag) {
+                this.checkTagName(node.close_tag);
+            }
+            return;
+        }
         this.visitChildNodes(node);
+        if (node.close_tag) {
+            this.checkTagName(node.close_tag);
+        }
     }
-    visitHTMLCloseTagNode(node) {
+    visitHTMLSelfCloseTagNode(node) {
         this.checkTagName(node);
         this.visitChildNodes(node);
     }
+    checkTagName(node) {
+        const tagName = node.tag_name?.value;
+        if (!tagName)
+            return;
+        const lowercaseTagName = tagName.toLowerCase();
+        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");
+        }
+    }
+}
+class HTMLTagNameLowercaseRule extends ParserRule {
+    name = "html-tag-name-lowercase";
+    check(node, context) {
+        const visitor = new TagNameLowercaseVisitor(this.name, context);
+        visitor.visit(node);
+        return visitor.offenses;
+    }
+}
+
+class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
+    insideSVG = false;
+    visitHTMLElementNode(node) {
+        const tagName = node.tag_name?.value;
+        if (tagName && ["svg"].includes(tagName.toLowerCase())) {
+            const wasInsideSVG = this.insideSVG;
+            this.insideSVG = true;
+            this.visitChildNodes(node);
+            this.insideSVG = wasInsideSVG;
+            return;
+        }
+        if (this.insideSVG) {
+            if (node.open_tag) {
+                this.checkTagName(node.open_tag);
+            }
+            if (node.close_tag) {
+                this.checkTagName(node.close_tag);
+            }
+        }
+        this.visitChildNodes(node);
+    }
     visitHTMLSelfCloseTagNode(node) {
-        this.checkTagName(node);
+        if (this.insideSVG) {
+            this.checkTagName(node);
+        }
         this.visitChildNodes(node);
     }
     checkTagName(node) {
         const tagName = node.tag_name?.value;
         if (!tagName)
             return;
-        if (tagName !== tagName.toLowerCase()) {
+        if (SVG_CAMEL_CASE_ELEMENTS.has(tagName))
+            return;
+        const lowercaseTagName = tagName.toLowerCase();
+        const correctCamelCase = SVG_LOWERCASE_TO_CAMELCASE.get(lowercaseTagName);
+        if (correctCamelCase && tagName !== correctCamelCase) {
             let type = node.type;
             if (node.type == "AST_HTML_OPEN_TAG_NODE")
                 type = "Opening";
@@ -834,14 +1178,14 @@ class TagNameLowercaseVisitor extends BaseRuleVisitor {
                 type = "Closing";
             if (node.type == "AST_HTML_SELF_CLOSE_TAG_NODE")
                 type = "Self-closing";
-            this.addOffense(`${type} tag name \`${tagName}\` should be lowercase. Use \`${tagName.toLowerCase()}\` instead.`, node.tag_name.location, "error");
+            this.addOffense(`${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`, node.tag_name.location, "error");
         }
     }
 }
-class HTMLTagNameLowercaseRule {
-    name = "html-tag-name-lowercase";
-    check(node) {
-        const visitor = new TagNameLowercaseVisitor(this.name);
+class SVGTagNameCapitalizationRule extends ParserRule {
+    name = "svg-tag-name-capitalization";
+    check(node, context) {
+        const visitor = new SVGTagNameCapitalizationVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
@@ -850,9 +1194,12 @@ class HTMLTagNameLowercaseRule {
 const defaultRules = [
     ERBNoEmptyTagsRule,
     ERBNoOutputControlFlowRule,
+    ERBPreferImageTagHelperRule,
+    ERBRequiresTrailingNewlineRule,
     ERBRequireWhitespaceRule,
     HTMLAnchorRequireHrefRule,
     HTMLAriaAttributeMustBeValid,
+    HTMLAriaLevelMustBeValidRule,
     HTMLAriaRoleHeadingRequiresLevelRule,
     HTMLAriaRoleMustBeValidRule,
     HTMLAttributeDoubleQuotesRule,
@@ -865,16 +1212,20 @@ const defaultRules = [
     HTMLNoEmptyHeadingsRule,
     HTMLNoNestedLinksRule,
     HTMLTagNameLowercaseRule,
+    SVGTagNameCapitalizationRule,
 ];
 
 class Linter {
     rules;
+    herb;
     offenses;
     /**
      * Creates a new Linter instance.
-     * @param rules - Array of rule classes (not instances) to use. If not provided, uses default rules.
+     * @param herb - The Herb backend instance for parsing and lexing
+     * @param rules - Array of rule classes (Parser/AST or Lexer) to use. If not provided, uses default rules.
      */
-    constructor(rules) {
+    constructor(herb, rules) {
+        this.herb = herb;
         this.rules = rules !== undefined ? rules : this.getDefaultRules();
         this.offenses = [];
     }
@@ -888,11 +1239,39 @@ class Linter {
     getRuleCount() {
         return this.rules.length;
     }
-    lint(document) {
+    /**
+     * Type guard to check if a rule is a LexerRule
+     */
+    isLexerRule(rule) {
+        return rule.constructor.type === "lexer";
+    }
+    /**
+     * Type guard to check if a rule is a SourceRule
+     */
+    isSourceRule(rule) {
+        return rule.constructor.type === "source";
+    }
+    /**
+     * Lint source code using Parser/AST, Lexer, and Source rules.
+     * @param source - The source code to lint
+     * @param context - Optional context for linting (e.g., fileName for distinguishing files vs snippets)
+     */
+    lint(source, context) {
         this.offenses = [];
-        for (const Rule of this.rules) {
-            const rule = new Rule();
-            const ruleOffenses = rule.check(document);
+        const parseResult = this.herb.parse(source);
+        const lexResult = this.herb.lex(source);
+        for (const RuleClass of this.rules) {
+            const rule = new RuleClass();
+            let ruleOffenses;
+            if (this.isLexerRule(rule)) {
+                ruleOffenses = rule.check(lexResult, context);
+            }
+            else if (this.isSourceRule(rule)) {
+                ruleOffenses = rule.check(source, context);
+            }
+            else {
+                ruleOffenses = rule.check(parseResult.value, context);
+            }
             this.offenses.push(...ruleOffenses);
         }
         const errors = this.offenses.filter(offense => offense.severity === "error").length;
@@ -954,18 +1333,22 @@ class BlockInsideInlineVisitor extends BaseRuleVisitor {
         this.visitBlockElement(node);
     }
 }
-class HTMLNoBlockInsideInlineRule {
+class HTMLNoBlockInsideInlineRule extends ParserRule {
     name = "html-no-block-inside-inline";
-    check(node) {
-        const visitor = new BlockInsideInlineVisitor(this.name);
+    check(node, context) {
+        const visitor = new BlockInsideInlineVisitor(this.name, context);
         visitor.visit(node);
         return visitor.offenses;
     }
 }
 
+exports.DEFAULT_LINT_CONTEXT = DEFAULT_LINT_CONTEXT;
 exports.ERBNoEmptyTagsRule = ERBNoEmptyTagsRule;
 exports.ERBNoOutputControlFlowRule = ERBNoOutputControlFlowRule;
+exports.ERBPreferImageTagHelperRule = ERBPreferImageTagHelperRule;
+exports.ERBRequiresTrailingNewlineRule = ERBRequiresTrailingNewlineRule;
 exports.HTMLAnchorRequireHrefRule = HTMLAnchorRequireHrefRule;
+exports.HTMLAriaLevelMustBeValidRule = HTMLAriaLevelMustBeValidRule;
 exports.HTMLAriaRoleHeadingRequiresLevelRule = HTMLAriaRoleHeadingRequiresLevelRule;
 exports.HTMLAriaRoleMustBeValidRule = HTMLAriaRoleMustBeValidRule;
 exports.HTMLAttributeDoubleQuotesRule = HTMLAttributeDoubleQuotesRule;
@@ -978,5 +1361,9 @@ exports.HTMLNoDuplicateIdsRule = HTMLNoDuplicateIdsRule;
 exports.HTMLNoEmptyHeadingsRule = HTMLNoEmptyHeadingsRule;
 exports.HTMLNoNestedLinksRule = HTMLNoNestedLinksRule;
 exports.HTMLTagNameLowercaseRule = HTMLTagNameLowercaseRule;
+exports.LexerRule = LexerRule;
 exports.Linter = Linter;
+exports.ParserRule = ParserRule;
+exports.SVGTagNameCapitalizationRule = SVGTagNameCapitalizationRule;
+exports.SourceRule = SourceRule;
 //# sourceMappingURL=index.cjs.map