@herb-tools/linter 0.7.5 → 0.8.0

package/dist/types/rules/html-img-require-alt.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLImgRequireAltRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-input-require-autocomplete.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class HTMLInputRequireAutocompleteRule extends ParserRule {
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/html-navigation-has-label.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNavigationHasLabelRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-no-aria-hidden-on-focusable.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNoAriaHiddenOnFocusableRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-no-block-inside-inline.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNoBlockInsideInlineRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-no-duplicate-attributes.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNoDuplicateAttributesRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-no-duplicate-ids.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types";
 import type { ParseResult } from "@herb-tools/core";
-import type { LintOffense, LintContext } from "../types";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types";
 export declare class HTMLNoDuplicateIdsRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-no-duplicate-meta-names.d.ts

@@ -0,0 +1,9 @@
+import { ParserRule } from "../types";
+import type { ParseResult } from "@herb-tools/core";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types";
+export declare class HTMLNoDuplicateMetaNamesRule extends ParserRule {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/html-no-empty-attributes.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNoEmptyAttributesRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-no-empty-headings.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNoEmptyHeadingsRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-no-nested-links.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNoNestedLinksRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-no-positive-tab-index.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNoPositiveTabIndexRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-no-self-closing.d.ts

@@ -1,7 +1,16 @@
-import { ParserRule } from "../types.js";
-import type { LintContext, LintOffense } from "../types.js";
-import type { ParseResult } from "@herb-tools/core";
-export declare class HTMLNoSelfClosingRule extends ParserRule {
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { UnboundLintOffense, LintContext, LintOffense, FullRuleConfig } from "../types.js";
+import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core";
+interface NoSelfClosingAutofixContext extends BaseAutofixContext {
+    node: Mutable<HTMLOpenTagNode>;
+    tagName: string;
+    isVoid: boolean;
+}
+export declare class HTMLNoSelfClosingRule extends ParserRule<NoSelfClosingAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<NoSelfClosingAutofixContext>[];
+    autofix(offense: LintOffense<NoSelfClosingAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules/html-no-space-in-tag.d.ts

@@ -0,0 +1,16 @@
+import { WhitespaceNode } from "@herb-tools/core";
+import { ParserRule, BaseAutofixContext } from "../types.js";
+import type { ParseResult, HTMLOpenTagNode } from "@herb-tools/core";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+interface HTMLNoSpaceInTagAutofixContext extends BaseAutofixContext {
+    node: WhitespaceNode | HTMLOpenTagNode;
+    message: string;
+}
+export declare class HTMLNoSpaceInTagRule extends ParserRule<HTMLNoSpaceInTagAutofixContext> {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<HTMLNoSpaceInTagAutofixContext>[];
+    autofix(offense: LintOffense<HTMLNoSpaceInTagAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
+}
+export {};

package/dist/types/rules/html-no-title-attribute.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNoTitleAttributeRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-no-underscores-in-attribute-names.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintContext, LintOffense } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNoUnderscoresInAttributeNamesRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-tag-name-lowercase.d.ts

@@ -1,8 +1,18 @@
-import { ParserRule } from "../types.js";
-import { ParseResult } from "@herb-tools/core";
-import type { LintOffense, LintContext } from "../types.js";
-export declare class HTMLTagNameLowercaseRule extends ParserRule {
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import { HTMLOpenTagNode } from "@herb-tools/core";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { HTMLCloseTagNode, ParseResult } from "@herb-tools/core";
+interface TagNameAutofixContext extends BaseAutofixContext {
+    node: Mutable<HTMLOpenTagNode | HTMLCloseTagNode>;
+    tagName: string;
+    correctedTagName: string;
+}
+export declare class HTMLTagNameLowercaseRule extends ParserRule<TagNameAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    isEnabled(result: ParseResult, context?: Partial<LintContext>): boolean;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    isEnabled(result: ParseResult, _context?: Partial<LintContext>): boolean;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<TagNameAutofixContext>[];
+    autofix(offense: LintOffense<TagNameAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules/index.d.ts

@@ -1,10 +1,22 @@
 export * from "./rule-utils.js";
+export * from "./herb-disable-comment-base.js";
 export * from "./erb-comment-syntax.js";
+export * from "./erb-no-case-node-children.js";
 export * from "./erb-no-empty-tags.js";
+export * from "./erb-no-extra-newline.js";
+export * from "./erb-no-extra-whitespace-inside-tags.js";
 export * from "./erb-no-output-control-flow.js";
 export * from "./erb-no-silent-tag-in-attribute-name.js";
 export * from "./erb-prefer-image-tag-helper.js";
-export * from "./erb-requires-trailing-newline.js";
+export * from "./erb-require-trailing-newline.js";
+export * from "./erb-require-whitespace-inside-tags.js";
+export * from "./erb-right-trim.js";
+export * from "./herb-disable-comment-valid-rule-name.js";
+export * from "./herb-disable-comment-no-redundant-all.js";
+export * from "./herb-disable-comment-no-duplicate-rules.js";
+export * from "./herb-disable-comment-missing-rules.js";
+export * from "./herb-disable-comment-malformed.js";
+export * from "./herb-disable-comment-unnecessary.js";
 export * from "./html-anchor-require-href.js";
 export * from "./html-aria-label-is-well-formatted.js";
 export * from "./html-aria-level-must-be-valid.js";
@@ -14,21 +26,25 @@ export * from "./html-attribute-double-quotes.js";
 export * from "./html-attribute-equals-spacing.js";
 export * from "./html-attribute-values-require-quotes.js";
 export * from "./html-avoid-both-disabled-and-aria-disabled.js";
+export * from "./html-body-only-elements.js";
 export * from "./html-boolean-attributes-no-value.js";
+export * from "./html-head-only-elements.js";
 export * from "./html-iframe-has-title.js";
 export * from "./html-img-require-alt.js";
+export * from "./html-input-require-autocomplete.js";
 export * from "./html-navigation-has-label.js";
 export * from "./html-no-aria-hidden-on-focusable.js";
 export * from "./html-no-block-inside-inline.js";
 export * from "./html-no-duplicate-attributes.js";
 export * from "./html-no-duplicate-ids.js";
+export * from "./html-no-duplicate-meta-names.js";
 export * from "./html-no-empty-attributes.js";
 export * from "./html-no-empty-headings.js";
 export * from "./html-no-nested-links.js";
 export * from "./html-no-positive-tab-index.js";
 export * from "./html-no-self-closing.js";
+export * from "./html-no-space-in-tag.js";
 export * from "./html-no-title-attribute.js";
+export * from "./html-no-underscores-in-attribute-names.js";
 export * from "./html-tag-name-lowercase.js";
 export * from "./svg-tag-name-capitalization.js";
-export * from "./html-no-underscores-in-attribute-names.js";
-export * from "./erb-right-trim.js";

package/dist/types/rules/parser-no-errors.d.ts

@@ -1,8 +1,9 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense } from "../types.js";
+import type { LintOffense, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class ParserNoErrorsRule extends ParserRule {
     name: string;
+    get defaultConfig(): FullRuleConfig;
     check(result: ParseResult): LintOffense[];
     private herbErrorToLintOffense;
 }

package/dist/types/rules/rule-utils.d.ts

@@ -1,7 +1,7 @@
 import { Visitor, Location } from "@herb-tools/core";
-import type { HTMLAttributeNode, HTMLAttributeValueNode, HTMLOpenTagNode, LexResult, Token, Node } from "@herb-tools/core";
+import type { HTMLAttributeNode, HTMLAttributeValueNode, HTMLElementNode, HTMLOpenTagNode, LexResult, Token, Node } from "@herb-tools/core";
 import type * as Nodes from "@herb-tools/core";
-import type { LintOffense, LintSeverity, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, BaseAutofixContext } from "../types.js";
 export declare enum ControlFlowType {
     CONDITIONAL = 0,
     LOOP = 1
@@ -9,35 +9,37 @@ export declare enum ControlFlowType {
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
-export declare abstract class BaseRuleVisitor extends Visitor {
-    readonly offenses: LintOffense[];
+export declare abstract class BaseRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends Visitor {
+    readonly offenses: UnboundLintOffense<TAutofixContext>[];
     protected ruleName: string;
     protected context: LintContext;
     constructor(ruleName: string, context?: Partial<LintContext>);
     /**
-     * Helper method to create a lint offense
+     * Helper method to create an unbound lint offense (without severity).
+     * The Linter will bind severity based on the rule's config.
      */
-    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext>;
     /**
      * Helper method to add an offense to the offenses array
      */
-    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void;
 }
 /**
  * Mixin that adds control flow tracking capabilities to rule visitors
  * This allows rules to track state across different control flow structures
  * like if/else branches, loops, etc.
  *
+ * @template TAutofixContext - Type for autofix context (node + custom data)
  * @template TControlFlowState - Type for state passed between onEnterControlFlow and onExitControlFlow
  * @template TBranchState - Type for state passed between onEnterBranch and onExitBranch
  */
-export declare abstract class ControlFlowTrackingVisitor<TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor {
+export declare abstract class ControlFlowTrackingVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext, TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor<TAutofixContext> {
     protected isInControlFlow: boolean;
     protected currentControlFlowType: ControlFlowType | null;
     /**
      * Handle visiting a control flow node with proper scope management
      */
-    protected handleControlFlowNode(node: Node, controlFlowType: ControlFlowType, visitChildren: () => void): void;
+    protected handleControlFlowNode(_node: Node, controlFlowType: ControlFlowType, visitChildren: () => void): void;
     /**
      * Handle visiting a branch node (like else, when) with proper scope management
      */
@@ -64,7 +66,7 @@ export declare function getAttributes(node: HTMLOpenTagNode): HTMLAttributeNode[
 /**
  * Gets the tag name from an HTML tag node (lowercased)
  */
-export declare function getTagName(node: HTMLOpenTagNode): string | null;
+export declare function getTagName(node: HTMLElementNode | HTMLOpenTagNode | null | undefined): string | null;
 /**
  * Gets the attribute name from an HTMLAttributeNode (lowercased)
  * Returns null if the attribute name contains dynamic content (ERB)
@@ -210,7 +212,7 @@ export declare function isBooleanAttribute(attributeName: string): boolean;
  * - checkDynamicAttributeStaticValue()  - name="data-<%= key %>" value="foo"
  * - checkDynamicAttributeDynamicValue() - name="data-<%= key %>" value="<%= value %>"
  */
-export declare abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+export declare abstract class AttributeVisitorMixin<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends BaseRuleVisitor<TAutofixContext> {
     constructor(ruleName: string, context?: Partial<LintContext>);
     visitHTMLOpenTagNode(node: HTMLOpenTagNode): void;
     private checkAttributesOnNode;
@@ -242,19 +244,20 @@ export declare function forEachAttribute(node: HTMLOpenTagNode, callback: (attri
 /**
  * Base lexer visitor class that provides common functionality for lexer-based rule visitors
  */
-export declare abstract class BaseLexerRuleVisitor {
-    readonly offenses: LintOffense[];
+export declare abstract class BaseLexerRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+    readonly offenses: UnboundLintOffense<TAutofixContext>[];
     protected ruleName: string;
     protected context: LintContext;
     constructor(ruleName: string, context?: Partial<LintContext>);
     /**
-     * Helper method to create a lint offense for lexer rules
+     * Helper method to create an unbound lint offense (without severity).
+     * The Linter will bind severity based on the rule's config.
      */
-    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext>;
     /**
      * Helper method to add an offense to the offenses array
      */
-    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void;
     /**
      * Main entry point for lexer rule visitors
      * @param lexResult - The lexer result containing tokens and source
@@ -274,19 +277,20 @@ export declare abstract class BaseLexerRuleVisitor {
 /**
  * Base source visitor class that provides common functionality for source-based rule visitors
  */
-export declare abstract class BaseSourceRuleVisitor {
-    readonly offenses: LintOffense[];
+export declare abstract class BaseSourceRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+    readonly offenses: UnboundLintOffense<TAutofixContext>[];
     protected ruleName: string;
     protected context: LintContext;
     constructor(ruleName: string, context?: Partial<LintContext>);
     /**
-     * Helper method to create a lint offense for source rules
+     * Helper method to create an unbound lint offense (without severity).
+     * The Linter will bind severity based on the rule's config.
      */
-    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext>;
     /**
      * Helper method to add an offense to the offenses array
      */
-    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void;
     /**
      * Main entry point for source rule visitors
      * @param source - The raw source code
@@ -297,8 +301,51 @@ export declare abstract class BaseSourceRuleVisitor {
      * Override this method to implement source-level checks
      */
     protected abstract visitSource(source: string): void;
-    /**
-     * Helper method to create a location for a specific position in the source
-     */
-    protected createLocationAt(source: string, position: number): Location;
 }
+/**
+ * Autofix utilities for applying string replacements
+ */
+/**
+ * Checks if two locations are equal
+ * @param a - First location
+ * @param b - Second location
+ * @returns true if locations are equal
+ */
+export declare function locationsEqual(a: Location, b: Location): boolean;
+/**
+ * Finds a node in the AST that has a specific location
+ * Uses direct recursive traversal for reliability
+ * @param root - The root node to search from
+ * @param location - The location to match
+ * @param predicate - Optional predicate function to filter nodes (e.g., isERBNode)
+ * @returns The matching node or null if not found
+ */
+export declare function findNodeByLocation(root: Node, location: Location, predicate?: (node: Node) => boolean): any;
+/**
+ * AST Navigation Utilities
+ * These utilities help navigate the AST tree for complex autofix operations
+ */
+/**
+ * Finds the parent node of a given child node in the AST
+ * @param root - The root node to search from (typically the document node)
+ * @param target - The child node to find the parent of
+ * @returns The parent node, or null if not found
+ *
+ * @example
+ * const parent = findParent(result.value, offense.autofixContext.node)
+ * if (parent?.type === "AST_HTML_ELEMENT_NODE") {
+ *   // Modify parent...
+ * }
+ */
+export declare function findParent(root: Node, target: Node): Node | null;
+export declare const DOCUMENT_ONLY_TAG_NAMES: Set<string>;
+export declare const HTML_ONLY_TAG_NAMES: Set<string>;
+export declare const HEAD_ONLY_TAG_NAMES: Set<string>;
+export declare const HEAD_AND_BODY_TAG_NAMES: Set<string>;
+export declare function isDocumentOnlyTag(tagName: string): boolean;
+export declare function isHtmlOnlyTag(tagName: string): boolean;
+export declare function isHeadOnlyTag(tagName: string): boolean;
+export declare function isHeadAndBodyTag(tagName: string): boolean;
+export declare function isBodyOnlyTag(tagName: string): boolean;
+export declare function isBodyTag(tagName: string): boolean;
+export declare function isHeadTag(tagName: string): boolean;

package/dist/types/rules/svg-tag-name-capitalization.d.ts

@@ -1,7 +1,16 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-import type { ParseResult } from "@herb-tools/core";
-export declare class SVGTagNameCapitalizationRule extends ParserRule {
+import type { UnboundLintOffense, LintOffense, LintContext, BaseAutofixContext, Mutable, FullRuleConfig } from "../types.js";
+import type { HTMLOpenTagNode, HTMLCloseTagNode, ParseResult } from "@herb-tools/core";
+interface SVGTagNameCapitalizationAutofixContext extends BaseAutofixContext {
+    node: Mutable<HTMLOpenTagNode | HTMLCloseTagNode>;
+    currentTagName: string;
+    correctCamelCase: string;
+}
+export declare class SVGTagNameCapitalizationRule extends ParserRule<SVGTagNameCapitalizationAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<SVGTagNameCapitalizationAutofixContext>[];
+    autofix(offense: LintOffense<SVGTagNameCapitalizationAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules.d.ts

@@ -0,0 +1,2 @@
+import type { RuleClass } from "./types.js";
+export declare const rules: RuleClass[];

package/dist/types/src/cli/argument-parser.d.ts

@@ -1,16 +1,22 @@
 import type { ThemeInput } from "@herb-tools/highlighter";
 export type FormatOption = "simple" | "detailed" | "json";
 export interface ParsedArguments {
-    pattern: string;
+    patterns: string[];
+    configFile?: string;
     formatOption: FormatOption;
     showTiming: boolean;
     theme: ThemeInput;
     wrapLines: boolean;
     truncateLines: boolean;
     useGitHubActions: boolean;
+    fix: boolean;
+    ignoreDisableComments: boolean;
+    force: boolean;
+    init: boolean;
+    loadCustomRules: boolean;
 }
 export declare class ArgumentParser {
     private readonly usage;
     parse(argv: string[]): ParsedArguments;
-    private getFilePattern;
+    private getFilePatterns;
 }

package/dist/types/src/cli/file-processor.d.ts

@@ -1,18 +1,31 @@
+import { Config } from "@herb-tools/config";
 import type { Diagnostic } from "@herb-tools/core";
 import type { FormatOption } from "./argument-parser.js";
+import type { HerbConfigOptions } from "@herb-tools/config";
 export interface ProcessedFile {
     filename: string;
     offense: Diagnostic;
     content: string;
+    autocorrectable?: boolean;
 }
 export interface ProcessingContext {
     projectPath?: string;
     pattern?: string;
+    fix?: boolean;
+    ignoreDisableComments?: boolean;
+    linterConfig?: HerbConfigOptions['linter'];
+    config?: Config;
+    loadCustomRules?: boolean;
 }
 export interface ProcessingResult {
     totalErrors: number;
     totalWarnings: number;
+    totalInfo: number;
+    totalHints: number;
+    totalIgnored: number;
+    totalWouldBeIgnored?: number;
     filesWithOffenses: number;
+    filesFixed: number;
     ruleCount: number;
     allOffenses: ProcessedFile[];
     ruleOffenses: Map<string, {
@@ -23,5 +36,7 @@ export interface ProcessingResult {
 }
 export declare class FileProcessor {
     private linter;
+    private customRulesLoaded;
+    private isRuleAutocorrectable;
     processFiles(files: string[], formatOption?: FormatOption, context?: ProcessingContext): Promise<ProcessingResult>;
 }

package/dist/types/src/cli/formatters/json-formatter.d.ts

@@ -9,6 +9,9 @@ interface JSONSummary {
     filesWithOffenses: number;
     totalErrors: number;
     totalWarnings: number;
+    totalInfo: number;
+    totalHints: number;
+    totalIgnored: number;
     totalOffenses: number;
     ruleCount: number;
 }
@@ -28,6 +31,9 @@ interface JSONFormatOptions {
     files: string[];
     totalErrors: number;
     totalWarnings: number;
+    totalInfo: number;
+    totalHints: number;
+    totalIgnored: number;
     filesWithOffenses: number;
     ruleCount: number;
     startTime: number;

package/dist/types/src/cli/formatters/simple-formatter.d.ts

@@ -4,4 +4,5 @@ import type { ProcessedFile } from "../file-processor.js";
 export declare class SimpleFormatter extends BaseFormatter {
     format(allOffenses: ProcessedFile[]): Promise<void>;
     formatFile(filename: string, offenses: Diagnostic[]): void;
+    formatFileProcessed(filename: string, processedFiles: ProcessedFile[]): void;
 }

package/dist/types/src/cli/summary-reporter.d.ts

@@ -2,6 +2,10 @@ export interface SummaryData {
     files: string[];
     totalErrors: number;
     totalWarnings: number;
+    totalInfo?: number;
+    totalHints?: number;
+    totalIgnored: number;
+    totalWouldBeIgnored?: number;
     filesWithOffenses: number;
     ruleCount: number;
     startTime: number;
@@ -11,6 +15,8 @@ export interface SummaryData {
         count: number;
         files: Set<string>;
     }>;
+    autofixableCount: number;
+    ignoreDisableComments?: boolean;
 }
 export declare class SummaryReporter {
     private pluralize;