@tony.ganchev/eslint-plugin-header 3.2.4 → 3.2.6

package/lib/rules/header.js

@@ -1,8 +1,8 @@
-/*
- * MIT License
- *
- * Copyright (c) 2015-present Stuart Knightley, Tony Ganchev, and contributors
- *
+/**
+ * @file Header validation rule implementation.
+ * @copyright Copyright (c) 2015-present Stuart Knightley and contributors
+ * @copyright Copyright (c) 2024-2026 Tony Ganchev
+ * @license MIT
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the “Software”), to deal
  * in the Software without restriction, including without limitation the rights
@@ -33,66 +33,118 @@ const { description, recommended } = require("./header.docs");
 const { lineEndingOptions, commentTypeOptions, schema } = require("./header.schema");
 
 /**
- * Import type definitions.
- * @typedef {import('eslint').Rule.Fix} Fix
- * @typedef {import('eslint').Rule.NodeListener} NodeListener
- * @typedef {import('eslint').Rule.ReportFixer} ReportFixer
- * @typedef {import('eslint').Rule.RuleFixer} RuleFixer
- * @typedef {import('eslint').Rule.RuleContext} RuleContext
- * @typedef {import('estree').Comment} Comment
- * @typedef {import('estree').Program} Program
- * @typedef {import("estree").SourceLocation} SourceLocation
+ * @import { JSSyntaxElement, Linter, Rule, SourceCode } from "eslint"
+ * @import { Comment, SourceLocation } from "estree"
+ * @import { ViolationReport } from "@eslint/core";
+ * @typedef {Rule.NodeListener} NodeListener
+ * @typedef {Rule.ReportFixer} ReportFixer
+ * @typedef {Rule.RuleFixer} RuleFixer
+ * @typedef {Rule.RuleContext} RuleContext
+ */
+
+/**
+ * @typedef {"\n" | "\r\n"} LineEnding The sequence of characters that define
+ * the end of a line.
+ */
+
+/**
+ * @typedef {object} HeaderLinePattern Matching rule for a line from the header
+ * using regular expression and optionally providing an auto-fix replacement.
+ * @property {string | RegExp} pattern A regular expression that should match
+ * the header line.
+ * @property {string} [template] When set, if the actual header line does not
+ * match `pattern`, this value is to be used when running auto-fix.
+ */
+
+/**
+ * @typedef {string | RegExp | HeaderLinePattern} HeaderLine Matching rule for
+ * a single line of the header comment or the header comment as a whole if only
+ * one used.
+ * @typedef {HeaderLine | HeaderLine[]} HeaderLines The set of header comment-
+ * matching rules.
+ * @typedef {"os" | "unix" | "windows"} LineEndingOption Defines what EOL
+ * characters to expect - either forced to be Windows / POSIX-compatible, or
+ * defaulting to whatever the OS expects.
+ * @typedef {{ lineEndings?: LineEndingOption }} HeaderSettings How to treat
+ * line endings.
+ * @typedef {"block" | "line"} CommentType The expected type of comment to use
+ * for the header.
+ */
+
+/**
+ * @typedef {object} FileBasedConfig Header content configuration defined in a
+ * separate JavaScript template file.
+ * @property {string} file Template file path relative to the directory
+ * from which ESLint runs.
+ * @property {BufferEncoding} [encoding] Encoding to use when reading the
+ * file. If omitted, `"utf8"` will be assumed.
+ */
+
+/**
+ * @typedef {object} InlineConfig Header content configuration defined inline
+ * within the ESLint configuration.
+ * @property {CommentType} commentType The type of comment to expect.
+ * @property {HeaderLine[]} lines Matching rules for lines. If only one rule
+ * is provided, the rule would attempt to match either the first line ar all
+ * lines together.
+ */
+
+/**
+ * @typedef {object} TrailingEmptyLines Rule configuration on the handling of
+ * empty lines after the header comment.
+ * @property {number} [minimum] If set, the rule would check that at least
+ * a `minimum` number of EOL characters trail the header.
+ */
+
+/**
+ * @typedef {object} HeaderOptionsWithoutSettings
+ * @property {FileBasedConfig | InlineConfig} header The text matching rules
+ * for the header.
+ * @property {TrailingEmptyLines} [trailingEmptyLines] Rules about empty lines
+ * after the header comment.
  */
 
 /**
- * Local type definitions.
- * @typedef {{ pattern: string | RegExp, template?: string }} HeaderLinePattern
- * @typedef {string | RegExp | HeaderLinePattern} HeaderLine
- * @typedef {HeaderLine | HeaderLine[]} HeaderLines
- * @typedef {'os' | 'unix' | 'windows'} LineEndingOption
- * @typedef {{ lineEndings?: LineEndingOption }} HeaderSettings
- * @typedef {'block' | 'line'} CommentType
- * @typedef {{
- *      file: string,
- *      encoding?: BufferEncoding
- *  }
- * } FileBasedConfig
- * @typedef {{
- *      commentType: CommentType,
- *      lines: HeaderLine[]
- *  }
- * } InlineConfig
- * @typedef {{ minimum?: number }} TrailingEmptyLines
- * @typedef {{
- *      header: FileBasedConfig | InlineConfig,
- *      trailingEmptyLines?: TrailingEmptyLines
- *  }
- *  & HeaderSettings
- * } HeaderOptions
- * @typedef {[HeaderOptions] |
- *  [template: string] |
- *  [template: string, settings: HeaderSettings] |
- *  [type: CommentType, lines: HeaderLines] |
- *  [type: CommentType, lines: HeaderLines, settings: HeaderSettings] |
- *  [type: CommentType, lines: HeaderLines, minLines: number] |
- *  [
- *     type: CommentType,
- *     lines: HeaderLines,
- *     minLines: number,
- *     settings: HeaderSettings
- *  ]
- * } AllHeaderOptions
- * @typedef {import('eslint').Linter.RuleEntry<AllHeaderOptions>
- * } HeaderRuleConfig
+ * @typedef {HeaderOptionsWithoutSettings & HeaderSettings} HeaderOptions Modern
+ * object-based rule configuration.
+ */
+
+/**
+ * @typedef {[template: string]} LegacyFileBasedConfig
+ * @typedef {[template: string, settings: HeaderSettings]
+ * } LegacyFileBasedSettingsConfig
+ * @typedef {[type: CommentType, lines: HeaderLines]} LegacyInlineConfig
+ * @typedef {[type: CommentType, lines: HeaderLines, settings: HeaderSettings]
+ * } LegacyInlineSettingsConfig
+ * @typedef {[type: CommentType, lines: HeaderLines, minLines: number]
+ * } LegacyInlineMinLinesConfig
+ * @typedef {[
+ * type: CommentType,
+ * lines: HeaderLines,
+ * minLines: number,
+ * settings: HeaderSettings
+ * ]} LegacyInlineMinLinesSettingsConfig
+ * @typedef {[HeaderOptions]
+ * | LegacyFileBasedConfig
+ * | LegacyFileBasedSettingsConfig
+ * | LegacyInlineConfig
+ * | LegacyInlineSettingsConfig
+ * | LegacyInlineMinLinesConfig
+ * | LegacyInlineMinLinesSettingsConfig
+ * } AllHeaderOptions Full possible rule configuration options.
+ */
+
+/**
+ * @typedef {Linter.RuleEntry<AllHeaderOptions>} HeaderRuleConfig Rule
+ * configuration array including severity.
  */
 
 /**
  * Tests if the passed line configuration string or object is a pattern
  * definition.
- * @param {HeaderLine} object line configuration object or string
+ * @param {HeaderLine} object Line configuration object or string.
  * @returns {object is HeaderLinePattern} `true` if the line configuration is a
- *                                        pattern-defining object or `false`
- *                                        otherwise.
+ * pattern-defining object or `false` otherwise.
  */
 function isPattern(object) {
     return typeof object === "object"
@@ -102,10 +154,10 @@ function isPattern(object) {
 /**
  * Utility over a line config argument to match an expected string either
  * against a regex or for full match against a string.
- * @param {string} actual the string to test.
+ * @param {string} actual The string to test.
  * @param {string | RegExp} expected The string or regex to test again.
  * @returns {boolean} `true` if the passed string matches the expected line
- *                    config or `false` otherwise.
+ * config or `false` otherwise.
  */
 function match(actual, expected) {
     if (expected instanceof RegExp) {
@@ -117,61 +169,35 @@ function match(actual, expected) {
 
 /**
  * Remove Unix she-bangs from the list of comments.
- * @param {(Comment | { type: "Shebang" })[]} comments the list of comment
- *                                                     lines.
- * @returns {Comment[]} the list of comments with containing all incoming
- *                      comments from `comments` with the shebang comments
- *                      omitted.
+ * @param {(Comment | { type: "Shebang" })[]} comments The list of comment
+ * lines.
+ * @returns {Comment[]} The list of comments with containing all incoming
+ * comments from `comments` with the shebang comments omitted.
  */
 function excludeShebangs(comments) {
     /** @type {Comment[]} */
-    return comments.filter(function(comment) {
+    return comments.filter(function (comment) {
         return comment.type !== "Shebang";
     });
 }
 
-/**
- * TypeScript helper to confirm defined type.
- * @template T
- * @param {T | undefined} val  the value to validate.
- * @returns {asserts val is T} validates defined type
- */
-function assertDefined(val) {
-    assert.strict.notEqual(typeof val, "undefined");
-}
-
-/**
- * TypeScript helper to confirm non-null type.
- * @template T
- * @param {T | null} val  the value to validate.
- * @returns {asserts val is T} validates non-null type
- */
-function assertNotNull(val) {
-    assert.strict.notEqual(val, null);
-}
-
 /**
  * Returns either the first block comment or the first set of line comments that
  * are ONLY separated by a single newline. Note that this does not actually
  * check if they are at the start of the file since that is already checked by
  * `hasHeader()`.
- * @param {RuleContext} context ESLint execution environment.
- * @returns {Comment[]} lines that constitute the leading comment.
+ * @param {SourceCode} sourceCode AST.
+ * @returns {Comment[]} Lines That constitute the leading comment.
  */
-function getLeadingComments(context) {
-    const sourceCode = contextSourceCode(context);
+function getLeadingComments(sourceCode) {
     const all = excludeShebangs(sourceCode.getAllComments());
-    assert.ok(all);
-    assert.ok(all.length);
     if (all[0].type.toLowerCase() === commentTypeOptions.block) {
         return [all[0]];
     }
     let i = 1;
     for (; i < all.length; ++i) {
-        const previousRange = all[i - 1].range;
-        assertDefined(previousRange);
-        const currentRange = all[i].range;
-        assertDefined(currentRange);
+        const previousRange = /** @type {[number, number]} */ (all[i - 1].range);
+        const currentRange = /** @type {[number, number]} */ (all[i].range);
         const txt = sourceCode.text.slice(previousRange[1], currentRange[0]);
         if (!txt.match(/^(\r\n|\r|\n)$/)) {
             break;
@@ -183,10 +209,10 @@ function getLeadingComments(context) {
 /**
  * Generate a comment including trailing spaces out of a number of comment body
  * lines.
- * @param {CommentType} commentType the type of comment to generate.
- * @param {string[]} textArray list of lines of the comment content.
- * @param {'\n' | '\r\n'} eol end-of-line characters.
- * @returns {string} resulting comment.
+ * @param {CommentType} commentType The type of comment to generate.
+ * @param {string[]} textArray List of lines of the comment content.
+ * @param {LineEnding} eol End-of-line characters.
+ * @returns {string} Resulting comment.
  */
 function genCommentBody(commentType, textArray, eol) {
     if (commentType === commentTypeOptions.block) {
@@ -201,20 +227,16 @@ function genCommentBody(commentType, textArray, eol) {
 /**
  * Determines the start and end position in the source code of the leading
  * comment.
- * @param {Comment[]} comments list of comments.
- * @returns {[number, number]} resulting range.
+ * @param {Comment[]} comments List of comments.
+ * @returns {[number, number]} Resulting range.
  */
 function genCommentsRange(comments) {
     assert.ok(comments.length);
     const firstComment = comments[0];
-    assertDefined(firstComment);
-    const firstCommentRange = firstComment.range;
-    assertDefined(firstCommentRange);
+    const firstCommentRange = /** @type {[number, number]} */ (firstComment.range);
     const start = firstCommentRange[0];
     const lastComment = comments.slice(-1)[0];
-    assertDefined(lastComment);
-    const lastCommentRange = lastComment.range;
-    assertDefined(lastCommentRange);
+    const lastCommentRange = /** @type {[number, number]} */ (lastComment.range);
     const end = lastCommentRange[1];
     return [start, end];
 }
@@ -222,8 +244,8 @@ function genCommentsRange(comments) {
 /**
  * Calculates the number of leading empty lines in the source code. The function
  * counts both Windows and POSIX line endings.
- * @param {string} src the source code to traverse.
- * @returns {number} the number of leading empty lines.
+ * @param {string} src The source code to traverse.
+ * @returns {number} The number of leading empty lines.
  */
 function leadingEmptyLines(src) {
     let numLines = 0;
@@ -241,18 +263,17 @@ function leadingEmptyLines(src) {
 
 /**
  * Factory for fixer that adds a missing header.
- * @param {CommentType} commentType type of comment to use.
- * @param {RuleContext} context ESLint execution runtime.
- * @param {string[]} headerLines lines of the header comment.
- * @param {'\n' | '\r\n'} eol end-of-line characters
- * @param {number} numNewlines number of trailing lines after the comment.
- * @returns {ReportFixer} the fixer.
+ * @param {CommentType} commentType Type of comment to use.
+ * @param {SourceCode} sourceCode AST.
+ * @param {string[]} headerLines Lines of the header comment.
+ * @param {LineEnding} eol End-of-line characters.
+ * @param {number} numNewlines Number of trailing lines after the comment.
+ * @returns {ReportFixer} The fix to apply.
  */
-function genPrependFixer(commentType, context, headerLines, eol, numNewlines) {
-    return function(fixer) {
+function genPrependFixer(commentType, sourceCode, headerLines, eol, numNewlines) {
+    return function (fixer) {
         let insertPos = 0;
         let newHeader = genCommentBody(commentType, headerLines, eol);
-        const sourceCode = contextSourceCode(context);
         if (sourceCode.text.startsWith("#!")) {
             const firstNewLinePos = sourceCode.text.indexOf("\n");
             insertPos = firstNewLinePos === -1 ? sourceCode.text.length : firstNewLinePos + 1;
@@ -272,18 +293,18 @@ function genPrependFixer(commentType, context, headerLines, eol, numNewlines) {
 
 /**
  * Factory for fixer that replaces an incorrect header.
- * @param {CommentType} commentType type of comment to use.
- * @param {RuleContext} context ESLint execution context.
- * @param {Comment[]} leadingComments comment elements to replace.
- * @param {string[]} headerLines lines of the header comment.
- * @param {'\n' | '\r\n'} eol end-of-line characters
- * @param {number} numNewlines number of trailing lines after the comment.
- * @returns {(fixer: RuleFixer) => Fix | Fix[] | null} the fixer.
+ * @param {CommentType} commentType Type of comment to use.
+ * @param {SourceCode} sourceCode AST.
+ * @param {Comment[]} leadingComments Comment elements to replace.
+ * @param {string[]} headerLines Lines of the header comment.
+ * @param {LineEnding} eol End-of-line characters.
+ * @param {number} numNewlines Number of trailing lines after the comment.
+ * @returns {ReportFixer} The fix to apply.
  */
-function genReplaceFixer(commentType, context, leadingComments, headerLines, eol, numNewlines) {
-    return function(fixer) {
+function genReplaceFixer(commentType, sourceCode, leadingComments, headerLines, eol, numNewlines) {
+    return function (fixer) {
         const commentRange = genCommentsRange(leadingComments);
-        const emptyLines = leadingEmptyLines(contextSourceCode(context).text.substring(commentRange[1]));
+        const emptyLines = leadingEmptyLines(sourceCode.text.substring(commentRange[1]));
         const missingNewlines = Math.max(0, numNewlines - emptyLines);
         const eols = eol.repeat(missingNewlines);
         return fixer.replaceTextRange(
@@ -295,14 +316,14 @@ function genReplaceFixer(commentType, context, leadingComments, headerLines, eol
 
 /**
  * Factory for fixer that replaces an incorrect header.
- * @param {Comment[]} leadingComments comment elements to replace.
- * @param {'\n' | '\r\n'} eol end-of-line characters
- * @param {number} missingEmptyLinesCount number of trailing lines after the
- *                                        comment.
- * @returns {(fixer: RuleFixer) => Fix | Fix[] | null} the fixer.
+ * @param {Comment[]} leadingComments Comment elements to replace.
+ * @param {LineEnding} eol End-of-line characters.
+ * @param {number} missingEmptyLinesCount Number of trailing lines after the
+ * comment.
+ * @returns {ReportFixer} The fix to apply.
  */
 function genEmptyLinesFixer(leadingComments, eol, missingEmptyLinesCount) {
-    return function(fixer) {
+    return function (fixer) {
         return fixer.insertTextAfterRange(
             genCommentsRange(leadingComments),
             eol.repeat(missingEmptyLinesCount)
@@ -313,9 +334,8 @@ function genEmptyLinesFixer(leadingComments, eol, missingEmptyLinesCount) {
 /**
  * Returns the used line-termination characters per the rule's config if any or
  * else based on the runtime environments.
- * @param {LineEndingOption} style line-ending styles.
- * @returns {'\n' | '\r\n'} the correct line ending characters for the
- *                          environment.
+ * @param {LineEndingOption} style Line-ending styles.
+ * @returns {LineEnding} The correct line ending characters for the environment.
  */
 function getEol(style) {
     assert.strictEqual(Object.prototype.hasOwnProperty.call(lineEndingOptions, style), true,
@@ -327,14 +347,14 @@ function getEol(style) {
             return "\r\n";
         case lineEndingOptions.os:
         default:
-            return /** @type {'\n' | '\r\n'} */ (os.EOL);
+            return /** @type {LineEnding} */ (os.EOL);
     }
 }
 
 /**
  * Tests if the first line in the source code (after a Unix she-bang) is a
  * comment. Does not tolerate empty lines before the first match.
- * @param {string} src source code to test.
+ * @param {string} src Source code to test.
  * @returns {boolean} `true` if there is a comment or `false` otherwise.
  */
 function hasHeader(src) {
@@ -343,10 +363,10 @@ function hasHeader(src) {
 }
 
 /**
- * asserts on an expression and adds template texts to the failure message.
+ * Asserts on an expression and adds template texts to the failure message.
  * Helper to write cleaner code.
- * @param {boolean} condition assert condition.
- * @param {string} message assert message on violation.
+ * @param {boolean} condition Condition to verify.
+ * @param {string} message Assert message on violation.
  */
 function schemaAssert(condition, message) {
     assert.strictEqual(condition, true, message + " - should have been handled by eslint schema validation.");
@@ -359,10 +379,10 @@ function schemaAssert(condition, message) {
  * options in that some settings are still union types and unspecified
  * properties are not replaced by defaults. If the options follow the new
  * format, a simple seep copy would be returned.
- * @param {AllHeaderOptions} originalOptions the options as configured by the
- *                                           user.
- * @returns {HeaderOptions} the transformed new-style options with no
- *                             normalization.
+ * @param {AllHeaderOptions} originalOptions The options as configured by the
+ * user.
+ * @returns {HeaderOptions} The transformed new-style options with no
+ * normalization.
  */
 function transformLegacyOptions(originalOptions) {
     schemaAssert(originalOptions?.length > 0,
@@ -428,38 +448,29 @@ function transformLegacyOptions(originalOptions) {
 }
 
 /**
- * @param {FileBasedConfig | InlineConfig} config the header configuration.
- * @returns {config is FileBasedConfig} true if `config` is `FileBasedConfig`.
+ * Type guard for `FileBasedConfig`.
+ * @param {FileBasedConfig | InlineConfig} config The header configuration.
+ * @returns {config is FileBasedConfig} `true` if `config` is `FileBasedConfig`,
+ * else `false`.
  */
 function isFileBasedHeaderConfig(config) {
     return Object.prototype.hasOwnProperty.call(config, "file");
 }
 
 /**
- * @param {FileBasedConfig | InlineConfig} config the header configuration.
- * @returns {asserts config is InlineConfig} asserts `config` is
- *                                               `LineBasedConfig`.
+ * Transforms file template-based matching rules to inline rules for further
+ * use.
+ * @param {FileBasedConfig | InlineConfig} matcher The matching rule.
+ * @returns {InlineConfig} The resulting normalized configuration.
  */
-function assertLineBasedHeaderConfig(config) {
-    assert.ok(Object.prototype.hasOwnProperty.call(config, "lines"));
-}
-
-/**
- * Transforms a set of new-style options adding defaults and standardizing on
- * one of multiple config styles.
- * @param {HeaderOptions} originalOptions new-style options to normalize.
- * @returns {HeaderOptions} normalized options.
- */
-function normalizeOptions(originalOptions) {
-    const options = structuredClone(originalOptions);
-
-    if (isFileBasedHeaderConfig(originalOptions.header)) {
-        const text = fs.readFileSync(originalOptions.header.file, originalOptions.header.encoding || "utf8");
+function normalizeMatchingRules(matcher) {
+    if (isFileBasedHeaderConfig(matcher)) {
+        const text = fs.readFileSync(matcher.file, matcher.encoding || "utf8");
         const [commentType, lines] = commentParser(text);
-        options.header = { commentType, lines };
+        return { commentType, lines };
     }
-    assertLineBasedHeaderConfig(options.header);
-    options.header.lines = options.header.lines.flatMap(
+    const commentType = matcher.commentType;
+    const lines = matcher.lines.flatMap(
         (line) => {
             if (typeof line === "string") {
                 return /** @type {HeaderLine[]} */(line.split(/\r?\n/));
@@ -477,6 +488,19 @@ function normalizeOptions(originalOptions) {
             }
             return [{ pattern }];
         });
+    return { commentType, lines };
+}
+
+/**
+ * Transforms a set of new-style options adding defaults and standardizing on
+ * one of multiple config styles.
+ * @param {HeaderOptions} originalOptions New-style options to normalize.
+ * @returns {HeaderOptions} Normalized options.
+ */
+function normalizeOptions(originalOptions) {
+    const options = structuredClone(originalOptions);
+
+    options.header = normalizeMatchingRules(originalOptions.header);
 
     if (!options.lineEndings) {
         options.lineEndings = "os";
@@ -498,17 +522,15 @@ function normalizeOptions(originalOptions) {
  * insufficient) lines that trail the comment. A special case is when there are
  * no empty lines after the header in which case we highlight the next character
  * in the source regardless of which one it is).
- * @param {Comment[]} leadingComments the comment lines that constitute the
- *                                    header.
- * @param {number} actualEmptyLines the number of empty lines that follow the
- *                                  header.
- * @returns {SourceLocation} the location (line and column) of the violation.
+ * @param {Comment[]} leadingComments The comment lines that constitute the
+ * header.
+ * @param {number} actualEmptyLines The number of empty lines that follow the
+ * header.
+ * @returns {SourceLocation} The location (line and column) of the violation.
  */
 function missingEmptyLinesViolationLoc(leadingComments, actualEmptyLines) {
     assert.ok(leadingComments);
-    const loc = leadingComments[leadingComments.length - 1].loc;
-    assertDefined(loc);
-    assertNotNull(loc);
+    const loc = /** @type {SourceLocation} */ (leadingComments[leadingComments.length - 1].loc);
     const lastCommentLineLocEnd = loc.end;
     return {
         start: lastCommentLineLocEnd,
@@ -519,7 +541,315 @@ function missingEmptyLinesViolationLoc(leadingComments, actualEmptyLines) {
     };
 }
 
-/** @type {import('eslint').Rule.RuleModule} */
+/**
+ * Matches comments against of header content-matching rules. An object performs
+ * a number of expensive operations only once and thus can be used multiple
+ * times to test different comments.
+ */
+class CommentMatcher {
+    /**
+     * Initializes the matcher for a specific comment-matching rules.
+     * @param {InlineConfig} headerConfig Content-matching rules.
+     * @param {string} eol The EOL characters used.
+     * @param {number} numLines The requirred minimum number of trailing empty
+     * lines.
+     */
+    constructor(headerConfig, eol, numLines) {
+        this.commentType = headerConfig.commentType;
+        this.headerLines = headerConfig.lines.map((line) => isPattern(line) ? line.pattern : line);
+        this.eol = eol;
+        this.numLines = numLines;
+    }
+
+    /**
+     * Performs a validation of a comment against a header matching
+     * configuration.
+     * @param {Comment[]} leadingComments The block comment or sequence of line
+     * comments to test.
+     * @param {SourceCode} sourceCode The source code AST.
+     * @returns {ViolationReport<JSSyntaxElement, string> | null} If set a
+     * violation report to pass back to ESLint or interpret as necessary.
+     */
+    validate(leadingComments, sourceCode) {
+
+        const firstLeadingCommentLoc = /** @type {SourceLocation} */ (leadingComments[0].loc);
+        const firstLeadingCommentRange = /** @type {[number, number]} */ (leadingComments[0].range);
+
+        const lastLeadingCommentLoc = /** @type {SourceLocation} */ (leadingComments[leadingComments.length - 1].loc);
+
+        if (leadingComments[0].type.toLowerCase() !== this.commentType) {
+            return {
+                loc: {
+                    start: firstLeadingCommentLoc.start,
+                    end: lastLeadingCommentLoc.end
+                },
+                messageId: "incorrectCommentType",
+                data: {
+                    commentType: this.commentType
+                },
+            };
+        }
+        if (this.commentType === commentTypeOptions.line) {
+            if (this.headerLines.length === 1) {
+                const leadingCommentValues = leadingComments.map((c) => c.value);
+                if (
+                    !match(leadingCommentValues.join("\n"), this.headerLines[0])
+                    && !match(leadingCommentValues.join("\r\n"), this.headerLines[0])
+                ) {
+                    return {
+                        loc: {
+                            start: firstLeadingCommentLoc.start,
+                            end: lastLeadingCommentLoc.end
+                        },
+                        messageId: "incorrectHeader",
+                    };
+                }
+            } else {
+                for (let i = 0; i < this.headerLines.length; i++) {
+                    if (leadingComments.length - 1 < i) {
+                        return {
+                            loc: {
+                                start: lastLeadingCommentLoc.end,
+                                end: lastLeadingCommentLoc.end
+                            },
+                            messageId: "headerTooShort",
+                            data: {
+                                remainder: this.headerLines.slice(i).join(this.eol)
+                            },
+                        };
+                    }
+                    const headerLine = this.headerLines[i];
+                    const comment = leadingComments[i];
+                    const commentLoc = /** @type {SourceLocation} */ (comment.loc);
+                    if (typeof headerLine === "string") {
+                        const leadingCommentLength = comment.value.length;
+                        const headerLineLength = headerLine.length;
+                        for (let j = 0; j < Math.min(leadingCommentLength, headerLineLength); j++) {
+                            if (comment.value[j] !== headerLine[j]) {
+                                return {
+                                    loc: {
+                                        start: {
+                                            column: "//".length + j,
+                                            line: commentLoc.start.line
+                                        },
+                                        end: commentLoc.end
+                                    },
+                                    messageId: "headerLineMismatchAtPos",
+                                    data: {
+                                        expected: headerLine.substring(j)
+                                    },
+                                };
+                            }
+                        }
+                        if (leadingCommentLength < headerLineLength) {
+                            return {
+                                loc: {
+                                    start: commentLoc.end,
+                                    end: commentLoc.end,
+                                },
+                                messageId: "headerLineTooShort",
+                                data: {
+                                    remainder: headerLine.substring(leadingCommentLength)
+                                },
+                            };
+                        }
+                        if (leadingCommentLength > headerLineLength) {
+                            return {
+                                loc: {
+                                    start: {
+                                        column: "//".length + headerLineLength,
+                                        line: commentLoc.start.line
+                                    },
+                                    end: commentLoc.end,
+                                },
+                                messageId: "headerLineTooLong",
+                            };
+                        }
+                    } else {
+                        if (!match(comment.value, headerLine)) {
+                            return {
+                                loc: {
+                                    start: {
+                                        column: "//".length,
+                                        line: commentLoc.start.line,
+                                    },
+                                    end: commentLoc.end,
+                                },
+                                messageId: "incorrectHeaderLine",
+                                data: {
+                                    pattern: headerLine.toString()
+                                },
+                            };
+                        }
+                    }
+                }
+            }
+
+            const commentRange = /** @type {[number, number]} */ (leadingComments[this.headerLines.length - 1].range);
+            const actualLeadingEmptyLines = leadingEmptyLines(sourceCode.text.substring(commentRange[1]));
+            const missingEmptyLines = this.numLines - actualLeadingEmptyLines;
+            if (missingEmptyLines > 0) {
+                return {
+                    loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
+                    messageId: "noNewlineAfterHeader",
+                    data: {
+                        expected: this.numLines,
+                        actual: actualLeadingEmptyLines
+                    },
+                };
+            }
+
+            return null;
+        }
+        // if block comment pattern has more than 1 line, we also split the
+        // comment
+        let leadingLines = [leadingComments[0].value];
+        if (this.headerLines.length > 1) {
+            leadingLines = leadingComments[0].value.split(/\r?\n/);
+        }
+
+        /** @type {null | string} */
+        let errorMessageId = null;
+        /** @type {undefined | Record<string, string>} */
+        let errorMessageData;
+        /** @type {null | SourceLocation} */
+        let errorMessageLoc = null;
+        for (let i = 0; i < this.headerLines.length; i++) {
+            if (leadingLines.length - 1 < i) {
+                return {
+                    loc: {
+                        start: lastLeadingCommentLoc.end,
+                        end: lastLeadingCommentLoc.end
+                    },
+                    messageId: "headerTooShort",
+                    data: {
+                        remainder: this.headerLines.slice(i).join(this.eol)
+                    },
+                };
+            }
+            const leadingLine = leadingLines[i];
+            const headerLine = this.headerLines[i];
+            if (typeof headerLine === "string") {
+                for (let j = 0; j < Math.min(leadingLine.length, headerLine.length); j++) {
+                    if (leadingLine[j] !== headerLine[j]) {
+                        errorMessageId = "headerLineMismatchAtPos";
+                        const columnOffset = i === 0 ? "/*".length : 0;
+                        const line = firstLeadingCommentLoc.start.line + i;
+                        errorMessageLoc = {
+                            start: {
+                                column: columnOffset + j,
+                                line
+                            },
+                            end: {
+                                column: columnOffset + leadingLine.length,
+                                line
+                            }
+                        };
+                        errorMessageData = {
+                            expected: headerLine.substring(j)
+                        };
+                        break;
+                    }
+                }
+                if (errorMessageId) {
+                    break;
+                }
+                if (leadingLine.length < headerLine.length) {
+                    errorMessageId = "headerLineTooShort";
+                    const startColumn = (i === 0 ? "/*".length : 0) + leadingLine.length;
+                    errorMessageLoc = {
+                        start: {
+                            column: startColumn,
+                            line: firstLeadingCommentLoc.start.line + i
+                        },
+                        end: {
+                            column: startColumn + 1,
+                            line: firstLeadingCommentLoc.start.line + i
+                        }
+                    };
+                    errorMessageData = {
+                        remainder: headerLine.substring(leadingLine.length)
+                    };
+                    break;
+                }
+                if (leadingLine.length > headerLine.length) {
+                    errorMessageId = "headerLineTooLong";
+                    errorMessageLoc = {
+                        start: {
+                            column: (i === 0 ? "/*".length : 0) + headerLine.length,
+                            line: firstLeadingCommentLoc.start.line + i
+                        },
+                        end: {
+                            column: (i === 0 ? "/*".length : 0) + leadingLine.length,
+                            line: firstLeadingCommentLoc.start.line + i
+                        }
+                    };
+                    break;
+                }
+            } else {
+                if (!match(leadingLine, headerLine)) {
+                    errorMessageId = "incorrectHeaderLine";
+                    errorMessageData = {
+                        pattern: headerLine.toString()
+                    };
+                    const columnOffset = i === 0 ? "/*".length : 0;
+                    errorMessageLoc = {
+                        start: {
+                            column: columnOffset + 0,
+                            line: firstLeadingCommentLoc.start.line + i
+                        },
+                        end: {
+                            column: columnOffset + leadingLine.length,
+                            line: firstLeadingCommentLoc.start.line + i
+                        }
+                    };
+                    break;
+                }
+            }
+        }
+
+        if (!errorMessageId && leadingLines.length > this.headerLines.length) {
+            errorMessageId = "headerTooLong";
+            errorMessageLoc = {
+                start: {
+                    column: (this.headerLines.length === 0 ? "/*".length : 0) + 0,
+                    line: firstLeadingCommentLoc.start.line + this.headerLines.length
+                },
+                end: {
+                    column: lastLeadingCommentLoc.end.column - "*/".length,
+                    line: lastLeadingCommentLoc.end.line
+                }
+            };
+        }
+
+        if (errorMessageId) {
+            return {
+                loc: /** @type {SourceLocation} */ (errorMessageLoc),
+                messageId: errorMessageId,
+                data: errorMessageData,
+            };
+        }
+
+        const actualLeadingEmptyLines =
+            leadingEmptyLines(sourceCode.text.substring(firstLeadingCommentRange[1]));
+        const missingEmptyLines = this.numLines - actualLeadingEmptyLines;
+        if (missingEmptyLines > 0) {
+            return {
+                loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
+                messageId: "noNewlineAfterHeader",
+                data: {
+                    expected: this.numLines,
+                    actual: actualLeadingEmptyLines
+                },
+            };
+        }
+
+        return null;
+    }
+}
+
+
+/** @type {Rule.RuleModule} */
 const headerRule = {
     meta: {
         type: "layout",
@@ -551,55 +881,43 @@ const headerRule = {
             noNewlineAfterHeader: "not enough newlines after header: expected: {{expected}}, actual: {{actual}}"
         }
     },
+
     /**
      * Rule creation function.
      * @param {RuleContext} context ESLint rule execution context.
-     * @returns {NodeListener} the rule definition.
+     * @returns {NodeListener} The rule definition.
      */
-    create: function(context) {
+    create: function (context) {
 
-        const newStyleOptions = transformLegacyOptions(/** @type {AllHeaderOptions} */ (context.options));
+        const newStyleOptions = transformLegacyOptions(/** @type {AllHeaderOptions} */(context.options));
         const options = normalizeOptions(newStyleOptions);
 
-        assertLineBasedHeaderConfig(options.header);
-        const commentType = /** @type {CommentType} */ (options.header.commentType);
-
         const eol = getEol(
-            /** @type {LineEndingOption} */ (options.lineEndings)
+            /** @type {LineEndingOption} */(options.lineEndings)
         );
 
-        /** @type {string[]} */
-        let fixLines = [];
-        // If any of the lines are regular expressions, then we can't
-        // automatically fix them. We set this to true below once we
-        // ensure none of the lines are of type RegExp
-        let canFix = true;
-        const headerLines = options.header.lines.map(function(line) {
-            // Can only fix regex option if a template is also provided
+        const header = /** @type {InlineConfig} */ (options.header);
+
+        const canFix = !header.lines.some((line) => isPattern(line) && !("template" in line));
+
+        const fixLines = header.lines.map((line) => {
             if (isPattern(line)) {
-                if (Object.prototype.hasOwnProperty.call(line, "template")) {
-                    fixLines.push(/** @type {string} */ (line.template));
-                } else {
-                    canFix = false;
-                    fixLines.push("");
-                }
-                return line.pattern;
-            } else {
-                fixLines.push(/** @type {string} */ (line));
-                return line;
+                return ("template" in line) ? /** @type {string} */(line.template) : "";
             }
+            return /** @type {string} */(line);
         });
 
-
         const numLines = /** @type {number} */ (options.trailingEmptyLines?.minimum);
 
+        const headerMatcher = new CommentMatcher(header, eol, numLines);
+
         return {
             /**
              * Hooks into the processing of the overall script node to do the
              * header validation.
              * @returns {void}
              */
-            Program: function() {
+            Program: function () {
                 const sourceCode = contextSourceCode(context);
                 if (!hasHeader(sourceCode.text)) {
                     const hasShebang = sourceCode.text.startsWith("#!");
@@ -616,41 +934,10 @@ const headerRule = {
                             }
                         },
                         messageId: "missingHeader",
-                        fix: genPrependFixer(
-                            commentType,
-                            context,
-                            fixLines,
-                            eol,
-                            numLines)
-                    });
-                    return;
-                }
-                const leadingComments = getLeadingComments(context);
-                const firstLeadingCommentLoc = leadingComments[0].loc;
-                const firstLeadingCommentRange = leadingComments[0].range;
-                assertDefined(firstLeadingCommentRange);
-
-                const lastLeadingCommentLoc = leadingComments[leadingComments.length - 1].loc;
-
-                if (leadingComments[0].type.toLowerCase() !== commentType) {
-                    assertDefined(firstLeadingCommentLoc);
-                    assertNotNull(firstLeadingCommentLoc);
-                    assertDefined(lastLeadingCommentLoc);
-                    assertNotNull(lastLeadingCommentLoc);
-                    context.report({
-                        loc: {
-                            start: firstLeadingCommentLoc.start,
-                            end: lastLeadingCommentLoc.end
-                        },
-                        messageId: "incorrectCommentType",
-                        data: {
-                            commentType: commentType
-                        },
                         fix: canFix
-                            ? genReplaceFixer(
-                                commentType,
-                                context,
-                                leadingComments,
+                            ? genPrependFixer(
+                                headerMatcher.commentType,
+                                sourceCode,
                                 fixLines,
                                 eol,
                                 numLines)
@@ -658,341 +945,25 @@ const headerRule = {
                     });
                     return;
                 }
-                if (commentType === commentTypeOptions.line) {
-                    if (headerLines.length === 1) {
-                        const leadingCommentValues = leadingComments.map((c) => c.value);
-                        if (
-                            !match(leadingCommentValues.join("\n"), headerLines[0])
-                            && !match(leadingCommentValues.join("\r\n"), headerLines[0])
-                        ) {
-                            assertDefined(firstLeadingCommentLoc);
-                            assertNotNull(firstLeadingCommentLoc);
-                            assertDefined(lastLeadingCommentLoc);
-                            assertNotNull(lastLeadingCommentLoc);
-                            context.report({
-                                loc: {
-                                    start: firstLeadingCommentLoc.start,
-                                    end: lastLeadingCommentLoc.end
-                                },
-                                messageId: "incorrectHeader",
-                                fix: canFix
-                                    ? genReplaceFixer(
-                                        commentType,
-                                        context,
-                                        leadingComments,
-                                        fixLines,
-                                        eol,
-                                        numLines)
-                                    : null
-                            });
-                            return;
-                        }
-                    } else {
-                        for (let i = 0; i < headerLines.length; i++) {
-                            if (leadingComments.length - 1 < i) {
-                                assertDefined(lastLeadingCommentLoc);
-                                assertNotNull(lastLeadingCommentLoc);
-                                context.report({
-                                    loc: {
-                                        start: lastLeadingCommentLoc.end,
-                                        end: lastLeadingCommentLoc.end
-                                    },
-                                    messageId: "headerTooShort",
-                                    data: {
-                                        remainder: headerLines.slice(i).join(eol)
-                                    },
-                                    fix: canFix
-                                        ? genReplaceFixer(
-                                            commentType,
-                                            context,
-                                            leadingComments,
-                                            fixLines,
-                                            eol,
-                                            numLines)
-                                        : null
-                                });
-                                return;
-                            }
-                            const headerLine = headerLines[i];
-                            const comment = leadingComments[i];
-                            const commentLoc = comment.loc;
-                            assertDefined(commentLoc);
-                            assertNotNull(commentLoc);
-                            if (typeof headerLine === "string") {
-                                const leadingCommentLength = comment.value.length;
-                                const headerLineLength = headerLine.length;
-                                for (let j = 0; j < Math.min(leadingCommentLength, headerLineLength); j++) {
-                                    if (comment.value[j] !== headerLine[j]) {
-                                        context.report({
-                                            loc: {
-                                                start: {
-                                                    column: "//".length + j,
-                                                    line: commentLoc.start.line
-                                                },
-                                                end: commentLoc.end
-                                            },
-                                            messageId: "headerLineMismatchAtPos",
-                                            data: {
-                                                expected: headerLine.substring(j)
-                                            },
-                                            fix: genReplaceFixer(
-                                                commentType,
-                                                context,
-                                                leadingComments,
-                                                fixLines,
-                                                eol,
-                                                numLines)
-                                        });
-                                        return;
-                                    }
-                                }
-                                if (leadingCommentLength < headerLineLength) {
-                                    context.report({
-                                        loc: {
-                                            start: commentLoc.end,
-                                            end: commentLoc.end,
-                                        },
-                                        messageId: "headerLineTooShort",
-                                        data: {
-                                            remainder: headerLine.substring(leadingCommentLength)
-                                        },
-                                        fix: canFix
-                                            ? genReplaceFixer(
-                                                commentType,
-                                                context,
-                                                leadingComments,
-                                                fixLines,
-                                                eol,
-                                                numLines)
-                                            : null
-                                    });
-                                    return;
-                                }
-                                if (leadingCommentLength > headerLineLength) {
-                                    context.report({
-                                        loc: {
-                                            start: {
-                                                column: "//".length + headerLineLength,
-                                                line: commentLoc.start.line
-                                            },
-                                            end: commentLoc.end,
-                                        },
-                                        messageId: "headerLineTooLong",
-                                        fix: canFix
-                                            ? genReplaceFixer(
-                                                commentType,
-                                                context,
-                                                leadingComments,
-                                                fixLines,
-                                                eol,
-                                                numLines)
-                                            : null
-                                    });
-                                    return;
-                                }
-                            } else {
-                                if (!match(comment.value, headerLine)) {
-                                    context.report({
-                                        loc: {
-                                            start: {
-                                                column: "//".length,
-                                                line: commentLoc.start.line,
-                                            },
-                                            end: commentLoc.end,
-                                        },
-                                        messageId: "incorrectHeaderLine",
-                                        data: {
-                                            pattern: headerLine.toString()
-                                        },
-                                        fix: canFix
-                                            ? genReplaceFixer(
-                                                commentType,
-                                                context,
-                                                leadingComments,
-                                                fixLines,
-                                                eol,
-                                                numLines)
-                                            : null
-                                    });
-                                    return;
-                                }
-                            }
-                        }
-                    }
-
-                    const commentRange = leadingComments[headerLines.length - 1].range;
-                    assertDefined(commentRange);
-                    const actualLeadingEmptyLines = leadingEmptyLines(sourceCode.text.substring(commentRange[1]));
-                    const missingEmptyLines = numLines - actualLeadingEmptyLines;
-                    if (missingEmptyLines > 0) {
-                        context.report({
-                            loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
-                            messageId: "noNewlineAfterHeader",
-                            data: {
-                                expected: numLines,
-                                actual: actualLeadingEmptyLines
-                            },
-                            fix: genEmptyLinesFixer(leadingComments, eol, missingEmptyLines)
-                        });
-                    }
-                    return;
-                }
-                // if block comment pattern has more than 1 line, we also split
-                // the comment
-                let leadingLines = [leadingComments[0].value];
-                if (headerLines.length > 1) {
-                    leadingLines = leadingComments[0].value.split(/\r?\n/);
-                }
-
-                /** @type {null | string} */
-                let errorMessageId = null;
-                /** @type {undefined | Record<string, string>} */
-                let errorMessageData;
-                /** @type {null | SourceLocation} */
-                let errorMessageLoc = null;
-                for (let i = 0; i < headerLines.length; i++) {
-                    const leadingLine = leadingLines[i];
-                    const headerLine = headerLines[i];
-                    if (typeof headerLine === "string") {
-                        for (let j = 0; j < Math.min(leadingLine.length, headerLine.length); j++) {
-                            if (leadingLine[j] !== headerLine[j]) {
-                                errorMessageId = "headerLineMismatchAtPos";
-                                const columnOffset = i === 0 ? "/*".length : 0;
-                                assertDefined(firstLeadingCommentLoc);
-                                assertNotNull(firstLeadingCommentLoc);
-                                const line = firstLeadingCommentLoc.start.line + i;
-                                errorMessageLoc = {
-                                    start: {
-                                        column: columnOffset + j,
-                                        line
-                                    },
-                                    end: {
-                                        column: columnOffset + leadingLine.length,
-                                        line
-                                    }
-                                };
-                                errorMessageData = {
-                                    expected: headerLine.substring(j)
-                                };
-                                break;
-                            }
-                        }
-                        if (errorMessageId) {
-                            break;
-                        }
-                        if (leadingLine.length < headerLine.length) {
-                            errorMessageId = "headerLineTooShort";
-                            const startColumn = (i === 0 ? "/*".length : 0) + leadingLine.length;
-                            assertDefined(firstLeadingCommentLoc);
-                            assertNotNull(firstLeadingCommentLoc);
-                            errorMessageLoc = {
-                                start: {
-                                    column: startColumn,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                },
-                                end: {
-                                    column: startColumn + 1,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                }
-                            };
-                            errorMessageData = {
-                                remainder: headerLine.substring(leadingLine.length)
-                            };
-                            break;
-                        }
-                        if (leadingLine.length > headerLine.length) {
-                            assertDefined(firstLeadingCommentLoc);
-                            assertNotNull(firstLeadingCommentLoc);
-                            errorMessageId = "headerLineTooLong";
-                            errorMessageLoc = {
-                                start: {
-                                    column: (i === 0 ? "/*".length : 0) + headerLine.length,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                },
-                                end: {
-                                    column: (i === 0 ? "/*".length : 0) + leadingLine.length,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                }
-                            };
-                            break;
-                        }
-                    } else {
-                        if (!match(leadingLine, headerLine)) {
-                            errorMessageId = "incorrectHeaderLine";
-                            errorMessageData = {
-                                pattern: headerLine.toString()
-                            };
-                            const columnOffset = i === 0 ? "/*".length : 0;
-                            assertDefined(firstLeadingCommentLoc);
-                            assertNotNull(firstLeadingCommentLoc);
-                            errorMessageLoc = {
-                                start: {
-                                    column: columnOffset + 0,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                },
-                                end: {
-                                    column: columnOffset + leadingLine.length,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                }
-                            };
-                            break;
-                        }
-                    }
-                }
-
-                if (!errorMessageId && leadingLines.length > headerLines.length) {
-                    errorMessageId = "headerTooLong";
-                    assertDefined(firstLeadingCommentLoc);
-                    assertNotNull(firstLeadingCommentLoc);
-                    assertDefined(lastLeadingCommentLoc);
-                    assertNotNull(lastLeadingCommentLoc);
-                    errorMessageLoc = {
-                        start: {
-                            column: (headerLines.length === 0 ? "/*".length : 0) + 0,
-                            line: firstLeadingCommentLoc.start.line + headerLines.length
-                        },
-                        end: {
-                            column: lastLeadingCommentLoc.end.column - "*/".length,
-                            line: lastLeadingCommentLoc.end.line
-                        }
-                    };
-                }
-
-                if (errorMessageId) {
-                    if (canFix && headerLines.length > 1) {
-                        fixLines = [fixLines.join(eol)];
+                const leadingComments = getLeadingComments(sourceCode);
+
+                const report = headerMatcher.validate(leadingComments, sourceCode);
+
+                if (report !== null) {
+                    if ("messageId" in report && report.messageId === "noNewlineAfterHeader") {
+                        const { expected, actual } =
+                            /** @type {{ expected: number, actual: number }} */ (report.data);
+                        report.fix = genEmptyLinesFixer(leadingComments, eol, expected - actual);
+                    } else if (canFix) {
+                        report.fix = genReplaceFixer(
+                            headerMatcher.commentType,
+                            sourceCode,
+                            leadingComments,
+                            fixLines,
+                            eol,
+                            numLines);
                     }
-                    assertNotNull(errorMessageLoc);
-                    context.report({
-                        loc: errorMessageLoc,
-                        messageId: errorMessageId,
-                        data: errorMessageData,
-                        fix: canFix
-                            ? genReplaceFixer(
-                                commentType,
-                                context,
-                                leadingComments,
-                                fixLines,
-                                eol,
-                                numLines)
-                            : null
-                    });
-                    return;
-                }
-
-                const actualLeadingEmptyLines =
-                    leadingEmptyLines(sourceCode.text.substring(firstLeadingCommentRange[1]));
-                const missingEmptyLines = numLines - actualLeadingEmptyLines;
-                if (missingEmptyLines > 0) {
-                    context.report({
-                        loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
-                        messageId: "noNewlineAfterHeader",
-                        data: {
-                            expected: numLines,
-                            actual: actualLeadingEmptyLines
-                        },
-                        fix: genEmptyLinesFixer(leadingComments, eol, missingEmptyLines)
-                    });
+                    context.report(report);
                 }
             }
         };