@tony.ganchev/eslint-plugin-header 3.3.4 → 3.4.0

package/lib/rules/header.js

@@ -178,60 +178,156 @@ function match(actual, expected) {
     }
 }
 
+/**
+ * @typedef {[number, number]} Range
+ */
+
+/**
+ * @typedef {object} CommentEx
+ * @property {"Shebang" | "Block" | "Line"} type Comment type.
+ * @property {string} value Content of the comment.
+ * @property {Range} range Linear position of the comment within the source.
+ * @property {SourceLocation} loc Editor-oriented location of the comment.
+ */
+
+/**
+ * @typedef {object} BlockComment
+ * @property {string} startDelimiter The delimiter that marks the start of the
+ * block comment.
+ * @property {string} endDelimiter The delimiter that marks the end of the
+ * block comment.
+ */
+
+/**
+ * @typedef {object} LineComment
+ * @property {string} startDelimiter The delimiter that marks the start of the
+ * line comment.
+ */
+
+/**
+ * @typedef {object} Language
+ * @property { BlockComment } blockComment The tokens delimiting a block
+ * comment.
+ * @property { LineComment } [lineComment] The tokens delimiting a line comment
+ * if such is allowed.
+ * @property { boolean} [shebang] If set to `true`, the logic to handle shebangs
+ * will kick in.
+ */
+
 /**
  * Returns an array of comment groups before the actual code.
  * Block comments form single-element groups.
  * Line comments without empty lines between them form grouped elements.
  * @param {SourceCode} sourceCode AST.
- * @returns {Comment[][]} Array of groups of leading comments.
+ * @param {Language} language The language configuration.
+ * @returns {CommentEx[][]} Array of groups of leading comments.
  */
-function getLeadingComments(sourceCode) {
-    const all = sourceCode.getAllComments();
-    if (all.length === 0) {
-        return [];
-    }
-    // Determine where the actual code starts. If no code, use end of file.
-    const firstToken = sourceCode.getFirstToken(sourceCode.ast);
-    const codeStart = firstToken ? firstToken.range[0] : sourceCode.text.length;
-    // Filter comments that appear before the actual code starts.
-    const commentsBeforeCode = all.filter((c) => /** @type {[number, number]} */(c.range)[1] <= codeStart);
-    if (commentsBeforeCode.length === 0) {
-        return [];
-    }
-    /** @type {Comment[][]} */
+function getLeadingComments(sourceCode, language) {
+    const text = sourceCode.text;
     const groups = [];
-    /** @type {Comment[]} */
+    /** @type {CommentEx[]} */
     let currentGroup = [];
-    for (let i = 0; i < commentsBeforeCode.length; ++i) {
-        const comment = commentsBeforeCode[i];
+    let pos = 0;
+    let lastCommentEnd = 0;
 
-        if (comment.type === "Block" || /** @type {string} */ (comment.type) === "Shebang") {
-            // Push any existing current group first
+    /**
+     * Adds a comment to the appropriate group, handling line-comment grouping.
+     * @param {CommentEx} comment The comment to add.
+     * @returns {void}
+     */
+    function addComment(comment) {
+        if (comment.type === "Block" || comment.type === "Shebang") {
             if (currentGroup.length > 0) {
                 groups.push(currentGroup);
                 currentGroup = [];
             }
             groups.push([comment]);
         } else {
-            if (currentGroup.length === 0) {
-                currentGroup.push(comment);
-            } else {
-                const previous = currentGroup[currentGroup.length - 1];
-                const previousRange = /** @type {[number, number]} */ (previous.range);
-                const currentRange = /** @type {[number, number]} */ (comment.range);
-                const txt = sourceCode.text.slice(previousRange[1], currentRange[0]);
-
-                // If there is more than 1 newline, there is an empty line
-                // between comments.
-                const newlineCount = /** @type {RegExpMatchArray} */ (txt.match(/\r?\n/g)).length;
-                if (newlineCount <= 1) {
-                    currentGroup.push(comment);
-                } else {
+            // Group consecutive line comments
+            if (currentGroup.length > 0) {
+                const range = comment.range;
+                const whitespace = text.slice(lastCommentEnd, range[0]);
+                const newlineCount = whitespace.split(/\r?\n/).length - 1;
+                if (newlineCount > 1) {
                     groups.push(currentGroup);
-                    currentGroup = [comment];
+                    currentGroup = [];
                 }
             }
+            currentGroup.push(comment);
         }
+        lastCommentEnd = comment.range[1];
+    }
+
+    while (pos < text.length) {
+        // Try Shebang only at the very start
+        if (language.shebang && pos === 0) {
+            const shebangMatch = text.match(/^#!.*/);
+            if (shebangMatch) {
+                const shebangText = shebangMatch[0];
+                const valueText = shebangText.slice(2);
+                addComment({
+                    type: "Shebang",
+                    value: valueText,
+                    range: [0, shebangText.length],
+                    loc: {
+                        start: sourceCode.getLocFromIndex(0),
+                        end: sourceCode.getLocFromIndex(shebangText.length)
+                    }
+                });
+                pos = shebangText.length;
+                continue;
+            }
+        }
+
+        // Check for block comment
+        if (language.blockComment && text.startsWith(language.blockComment.startDelimiter, pos)) {
+            const endIdx =
+                text.indexOf(language.blockComment.endDelimiter, pos + language.blockComment.startDelimiter.length);
+            if (endIdx !== -1) {
+                const valueText = text.slice(pos + language.blockComment.startDelimiter.length, endIdx);
+                const endPos = endIdx + language.blockComment.endDelimiter.length;
+                addComment({
+                    type: "Block",
+                    value: valueText,
+                    range: [pos, endPos],
+                    loc: {
+                        start: sourceCode.getLocFromIndex(pos),
+                        end: sourceCode.getLocFromIndex(endPos)
+                    }
+                });
+                pos = endPos;
+                continue;
+            }
+        }
+
+        // Check for line comment
+        if (language.lineComment && text.startsWith(language.lineComment.startDelimiter, pos)) {
+            const endOfLineMatch = text.slice(pos).match(/\r?\n/);
+            const endOffset = endOfLineMatch ? (/** @type {number} */ (endOfLineMatch.index)) : text.length - pos;
+            const endIdx = pos + endOffset;
+            const valueText = text.slice(pos + language.lineComment.startDelimiter.length, endIdx);
+            addComment({
+                type: "Line",
+                value: valueText,
+                range: [pos, endIdx],
+                loc: {
+                    start: sourceCode.getLocFromIndex(pos),
+                    end: sourceCode.getLocFromIndex(endIdx)
+                }
+            });
+            pos = endIdx;
+            continue;
+        }
+
+        // Check for whitespace to skip
+        const wsMatch = text.slice(pos).match(/^\s+/);
+        if (wsMatch) {
+            pos += wsMatch[0].length;
+            continue;
+        }
+
+        // Anything else is code, stop parsing leading comments
+        break;
     }
 
     if (currentGroup.length > 0) {
@@ -247,32 +343,32 @@ function getLeadingComments(sourceCode) {
  * @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.
+ * @param {Language} language The language configuration.
  * @returns {string} Resulting comment.
  */
-function genCommentBody(commentType, textArray, eol) {
+function genCommentBody(commentType, textArray, eol, language) {
     if (commentType === commentTypeOptions.block) {
-        return "/*" + textArray.join(eol) + "*/";
+        return language.blockComment.startDelimiter + textArray.join(eol) + language.blockComment.endDelimiter;
     } else {
+        const lineStartDelimiter = /** @type {LineComment} */ (language.lineComment).startDelimiter;
         // We need one trailing EOL on line comments to ensure the fixed source
         // is parsable.
-        return "//" + textArray.join(eol + "//");
+        return lineStartDelimiter + textArray.join(eol + lineStartDelimiter);
     }
 }
 
 /**
  * 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 {CommentEx[]} comments List of comments.
+ * @returns {Range} Resulting range.
  */
 function genCommentsRange(comments) {
     assert.ok(comments.length);
     const firstComment = comments[0];
-    const firstCommentRange = /** @type {[number, number]} */ (firstComment.range);
-    const start = firstCommentRange[0];
+    const start = firstComment.range[0];
     const lastComment = comments.slice(-1)[0];
-    const lastCommentRange = /** @type {[number, number]} */ (lastComment.range);
-    const end = lastCommentRange[1];
+    const end = lastComment.range[1];
     return [start, end];
 }
 
@@ -303,13 +399,14 @@ function leadingEmptyLines(src) {
  * @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.
+ * @param {Language} language The language configuration.
  * @returns {ReportFixer} The fix to apply.
  */
-function genPrependFixer(commentType, sourceCode, headerLines, eol, numNewlines) {
+function genPrependFixer(commentType, sourceCode, headerLines, eol, numNewlines, language) {
     return function (fixer) {
         let insertPos = 0;
-        let newHeader = genCommentBody(commentType, headerLines, eol);
-        if (sourceCode.text.startsWith("#!")) {
+        let newHeader = genCommentBody(commentType, headerLines, eol, language);
+        if (language.shebang && sourceCode.text.startsWith("#!")) {
             const firstNewLinePos = sourceCode.text.indexOf("\n");
             insertPos = firstNewLinePos === -1 ? sourceCode.text.length : firstNewLinePos + 1;
             if (firstNewLinePos === -1) {
@@ -330,13 +427,14 @@ function genPrependFixer(commentType, sourceCode, headerLines, eol, numNewlines)
  * Factory for fixer that replaces an incorrect header.
  * @param {CommentType} commentType Type of comment to use.
  * @param {SourceCode} sourceCode AST.
- * @param {Comment[]} leadingComments Comment elements to replace.
+ * @param {CommentEx[]} 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.
+ * @param {Language} language The language configuration.
  * @returns {ReportFixer} The fix to apply.
  */
-function genReplaceFixer(commentType, sourceCode, leadingComments, headerLines, eol, numNewlines) {
+function genReplaceFixer(commentType, sourceCode, leadingComments, headerLines, eol, numNewlines, language) {
     return function (fixer) {
         const commentRange = genCommentsRange(leadingComments);
         const emptyLines = leadingEmptyLines(sourceCode.text.substring(commentRange[1]));
@@ -344,14 +442,14 @@ function genReplaceFixer(commentType, sourceCode, leadingComments, headerLines,
         const eols = eol.repeat(missingNewlines);
         return fixer.replaceTextRange(
             commentRange,
-            genCommentBody(commentType, headerLines, eol) + eols
+            genCommentBody(commentType, headerLines, eol, language) + eols
         );
     };
 }
 
 /**
  * Factory for fixer that replaces an incorrect header.
- * @param {Comment[]} leadingComments Comment elements to replace.
+ * @param {CommentEx[]} leadingComments Comment elements to replace.
  * @param {LineEnding} eol End-of-line characters.
  * @param {number} missingEmptyLinesCount Number of trailing lines after the
  * comment.
@@ -481,17 +579,24 @@ function isFileBasedHeaderConfig(config) {
     return "file" in config;
 }
 
+/** @type {Record<string, { commentType: CommentType; lines: string[]}>} */
+const parsedFilesCache = {};
+
 /**
  * Transforms file template-based matching rules to inline rules for further
  * use.
  * @param {FileBasedConfig | InlineConfig} matcher The matching rule.
+ * @param {Language} language The language configuration.
  * @returns {InlineConfig} The resulting normalized configuration.
  */
-function normalizeMatchingRules(matcher) {
+function normalizeMatchingRules(matcher, language) {
     if (isFileBasedHeaderConfig(matcher)) {
-        const text = fs.readFileSync(matcher.file, matcher.encoding || "utf8");
-        const [commentType, lines] = commentParser(text);
-        return { commentType, lines };
+        if (!(matcher.file in parsedFilesCache)) {
+            const text = fs.readFileSync(matcher.file, matcher.encoding || "utf8");
+            const [commentType, lines] = commentParser(text, language);
+            parsedFilesCache[matcher.file] = { commentType, lines };
+        }
+        return parsedFilesCache[matcher.file];
     }
     const commentType = matcher.commentType;
     const lines = matcher.lines.flatMap(
@@ -519,12 +624,13 @@ function normalizeMatchingRules(matcher) {
  * 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.
+ * @param {Language} language The language configuration.
  * @returns {HeaderOptions} Normalized options.
  */
-function normalizeOptions(originalOptions) {
+function normalizeOptions(originalOptions, language) {
     const options = structuredClone(originalOptions);
 
-    options.header = normalizeMatchingRules(originalOptions.header);
+    options.header = normalizeMatchingRules(originalOptions.header, language);
 
     if (!options.lineEndings) {
         options.lineEndings = "os";
@@ -532,7 +638,7 @@ function normalizeOptions(originalOptions) {
 
     if (originalOptions.leadingComments) {
         options.leadingComments = {
-            comments: originalOptions.leadingComments.comments.map((c) => normalizeMatchingRules(c))
+            comments: originalOptions.leadingComments.comments.map((c) => normalizeMatchingRules(c, language))
         };
     } else {
         options.leadingComments = { comments: [] };
@@ -553,7 +659,7 @@ 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
+ * @param {CommentEx[]} leadingComments The comment lines that constitute the
  * header.
  * @param {number} actualEmptyLines The number of empty lines that follow the
  * header.
@@ -561,7 +667,7 @@ function normalizeOptions(originalOptions) {
  */
 function missingEmptyLinesViolationLoc(leadingComments, actualEmptyLines) {
     assert.ok(leadingComments);
-    const loc = /** @type {SourceLocation} */ (leadingComments[leadingComments.length - 1].loc);
+    const loc = leadingComments[leadingComments.length - 1].loc;
     const lastCommentLineLocEnd = loc.end;
     return {
         start: lastCommentLineLocEnd,
@@ -584,12 +690,14 @@ class CommentMatcher {
      * @param {string} eol The EOL characters used.
      * @param {number} numLines The requirred minimum number of trailing empty
      * lines.
+     * @param {Language} language The language configuration.
      */
-    constructor(headerConfig, eol, numLines) {
+    constructor(headerConfig, eol, numLines, language) {
         this.commentType = headerConfig.commentType;
         this.headerLines = headerConfig.lines.map((line) => isPattern(line) ? line.pattern : line);
         this.eol = eol;
         this.numLines = numLines;
+        this.language = language;
     }
 
     /**
@@ -600,18 +708,18 @@ class CommentMatcher {
     /**
      * 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 {CommentEx[]} leadingComments The block comment or sequence of
+     * line comments to test.
      * @param {SourceCode} sourceCode The source code AST.
      * @returns {ViolationReportEx | 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 firstLeadingCommentLoc = leadingComments[0].loc;
+        const firstLeadingCommentRange = leadingComments[0].range;
 
-        const lastLeadingCommentLoc = /** @type {SourceLocation} */ (leadingComments[leadingComments.length - 1].loc);
+        const lastLeadingCommentLoc = leadingComments[leadingComments.length - 1].loc;
 
         if (leadingComments[0].type.toLowerCase() !== this.commentType) {
             return {
@@ -626,6 +734,7 @@ class CommentMatcher {
             };
         }
         if (this.commentType === commentTypeOptions.line) {
+            const lineCommentDelimiter = /** @type {LineComment} */ (this.language.lineComment).startDelimiter;
             if (this.headerLines.length === 1) {
                 const leadingCommentValues = leadingComments.map((c) => c.value);
                 if (
@@ -659,7 +768,7 @@ class CommentMatcher {
                     }
                     const headerLine = this.headerLines[i];
                     const comment = leadingComments[i];
-                    const commentLoc = /** @type {SourceLocation} */ (comment.loc);
+                    const commentLoc = comment.loc;
                     if (typeof headerLine === "string") {
                         const leadingCommentLength = comment.value.length;
                         const headerLineLength = headerLine.length;
@@ -668,7 +777,7 @@ class CommentMatcher {
                                 return {
                                     loc: {
                                         start: {
-                                            column: "//".length + j,
+                                            column: lineCommentDelimiter.length + j,
                                             line: commentLoc.start.line
                                         },
                                         end: commentLoc.end
@@ -696,7 +805,7 @@ class CommentMatcher {
                             return {
                                 loc: {
                                     start: {
-                                        column: "//".length + headerLineLength,
+                                        column: lineCommentDelimiter.length + headerLineLength,
                                         line: commentLoc.start.line
                                     },
                                     end: commentLoc.end,
@@ -709,7 +818,7 @@ class CommentMatcher {
                             return {
                                 loc: {
                                     start: {
-                                        column: "//".length,
+                                        column: lineCommentDelimiter.length,
                                         line: commentLoc.start.line,
                                     },
                                     end: commentLoc.end,
@@ -724,7 +833,7 @@ class CommentMatcher {
                 }
             }
 
-            const commentRange = /** @type {[number, number]} */ (leadingComments[this.headerLines.length - 1].range);
+            const commentRange = leadingComments[this.headerLines.length - 1].range;
             const actualLeadingEmptyLines = leadingEmptyLines(sourceCode.text.substring(commentRange[1]));
             const missingEmptyLines = this.numLines - actualLeadingEmptyLines;
             if (missingEmptyLines > 0) {
@@ -753,6 +862,9 @@ class CommentMatcher {
         let errorMessageData;
         /** @type {null | SourceLocation} */
         let errorMessageLoc = null;
+        const blockStartLen = this.language.blockComment.startDelimiter.length;
+        const blockEndLen = this.language.blockComment.endDelimiter.length;
+
         for (let i = 0; i < this.headerLines.length; i++) {
             if (leadingLines.length - 1 < i) {
                 return {
@@ -772,54 +884,39 @@ class CommentMatcher {
                 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 columnOffset = i === 0 ? blockStartLen : 0;
                         const line = firstLeadingCommentLoc.start.line + i;
                         errorMessageLoc = {
-                            start: {
-                                column: columnOffset + j,
-                                line
-                            },
-                            end: {
-                                column: columnOffset + leadingLine.length,
-                                line
-                            }
-                        };
-                        errorMessageData = {
-                            expected: headerLine.substring(j)
+                            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;
+                    const startColumn = (i === 0 ? blockStartLen : 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)
+                        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,
+                            column: (i === 0 ? blockStartLen : 0) + headerLine.length,
                             line: firstLeadingCommentLoc.start.line + i
                         },
                         end: {
-                            column: (i === 0 ? "/*".length : 0) + leadingLine.length,
+                            column: (i === 0 ? blockStartLen : 0) + leadingLine.length,
                             line: firstLeadingCommentLoc.start.line + i
                         }
                     };
@@ -828,19 +925,11 @@ class CommentMatcher {
             } else {
                 if (!match(leadingLine, headerLine)) {
                     errorMessageId = "incorrectHeaderLine";
-                    errorMessageData = {
-                        pattern: headerLine.toString()
-                    };
-                    const columnOffset = i === 0 ? "/*".length : 0;
+                    errorMessageData = { pattern: headerLine.toString() };
+                    const columnOffset = i === 0 ? blockStartLen : 0;
                     errorMessageLoc = {
-                        start: {
-                            column: columnOffset + 0,
-                            line: firstLeadingCommentLoc.start.line + i
-                        },
-                        end: {
-                            column: columnOffset + leadingLine.length,
-                            line: firstLeadingCommentLoc.start.line + i
-                        }
+                        start: { column: columnOffset + 0, line: firstLeadingCommentLoc.start.line + i },
+                        end: { column: columnOffset + leadingLine.length, line: firstLeadingCommentLoc.start.line + i }
                     };
                     break;
                 }
@@ -851,11 +940,11 @@ class CommentMatcher {
             errorMessageId = "headerTooLong";
             errorMessageLoc = {
                 start: {
-                    column: (this.headerLines.length === 0 ? "/*".length : 0) + 0,
+                    column: (this.headerLines.length === 0 ? blockStartLen : 0) + 0,
                     line: firstLeadingCommentLoc.start.line + this.headerLines.length
                 },
                 end: {
-                    column: lastLeadingCommentLoc.end.column - "*/".length,
+                    column: lastLeadingCommentLoc.end.column - blockEndLen,
                     line: lastLeadingCommentLoc.end.line
                 }
             };
@@ -927,7 +1016,8 @@ const headerRule = {
                 "leading comment validation failed: comment line does not match pattern: '{{pattern}}'",
             // messages only applicable to header validation.
             missingHeader: "missing header",
-            noNewlineAfterHeader: "not enough newlines after header: expected: {{expected}}, actual: {{actual}}"
+            noNewlineAfterHeader: "not enough newlines after header: expected: {{expected}}, actual: {{actual}}",
+            unsupportedLineHeader: "line header configured but not supported for this language"
         }
     },
 
@@ -939,125 +1029,72 @@ const headerRule = {
     create: function (context) {
 
         const newStyleOptions = transformLegacyOptions(/** @type {AllHeaderOptions} */(context.options));
-        const options = normalizeOptions(newStyleOptions);
-        const eol = getEol(/** @type {LineEndingOption} */(options.lineEndings));
-        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)) {
-                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);
-        const allowedLeadingComments = /** @type {LeadingComments} */ (options.leadingComments).comments;
-        const allowedCommentsMatchers =
-            allowedLeadingComments.map((c) => new CommentMatcher(/** @type {InlineConfig} */(c), eol, 0));
-
-        return {
-            /**
-             * Hooks into the processing of the overall script node to do the
-             * header validation.
-             * @returns {void}
-             */
-            Program: function () {
-                const sourceCode = contextSourceCode(context);
-                const leadingComments = getLeadingComments(sourceCode);
-                // XXX: the reason we test like this instead of checking the
-                // first comment is of type "Shabeng" is because
-                // @typecript-eslint/prser does not recognize shebang comments
-                // with some TypeScript configuration. Since we are not
-                // releasing a major version we do not want to break the current
-                // behavior of not be pedantic about the tsconfig.json.
-                const hasShebang = sourceCode.text.startsWith("#!");
-                let startingHeaderLine = 1;
-                if (hasShebang) {
-                    if (leadingComments.length > 0
-                        && /** @type {string} */ (leadingComments[0][0].type) === "Shebang"
-                    ) {
-                        leadingComments.splice(0, 1);
-                    }
-                    startingHeaderLine = 2;
-                }
-
-                if (leadingComments.length === 0
-                    || /** @type {SourceLocation} */ (leadingComments[0][0].loc).start.line > startingHeaderLine) {
-
-                    context.report({
-                        loc: {
-                            start: {
-                                column: 0,
-                                line: startingHeaderLine
-                            },
-                            end: {
-                                column: 0,
-                                line: startingHeaderLine
-                            }
-                        },
-                        messageId: "missingHeader",
-                        fix: canFix
-                            ? genPrependFixer(
-                                headerMatcher.commentType,
-                                sourceCode,
-                                fixLines,
-                                eol,
-                                numLines)
-                            : null
-                    });
-                    return;
+        const sourceCode = contextSourceCode(context);
+
+        /**
+         * Hooks into the processing of the overall script node to do the
+         * header validation.
+         * @param {Language} language The language configuration.
+         * @returns {void}
+         */
+        function onRootNode(language) {
+            const options = normalizeOptions(newStyleOptions, language);
+            const eol = getEol(/** @type {LineEndingOption} */(options.lineEndings));
+            const header = /** @type {InlineConfig} */ (options.header);
+            const canFix = !header.lines.some((line) =>
+                isPattern(/** @type {HeaderLine} */(line)) && !("template" in line));
+            const fixLines = header.lines.map((line) => {
+                if (isPattern(/** @type {HeaderLine} */(line))) {
+                    return ("template" in line) ? /** @type {string} */(line.template) : "";
                 }
+                return /** @type {string} */(line);
+            });
+            const numLines = /** @type {number} */ (options.trailingEmptyLines?.minimum);
 
-                for (const leadingComment of leadingComments) {
-
-                    const headerReport = headerMatcher.validate(leadingComment, sourceCode);
-                    if (headerReport === null) {
-                        return;
-                    }
-                    const leadingCommentReports =
-                        allowedCommentsMatchers.map((m) => m.validate(leadingComment, sourceCode));
-                    const commentMatched = leadingCommentReports.some((report) => report === null);
-
-                    if (!commentMatched) {
-                        if ("messageId" in headerReport && headerReport.messageId === "noNewlineAfterHeader") {
-                            const { expected, actual } =
-                                /** @type {{ expected: number, actual: number }} */ (headerReport.data);
-                            headerReport.fix = genEmptyLinesFixer(leadingComment, eol, expected - actual);
-                        } else if (canFix) {
-                            headerReport.fix = genReplaceFixer(
-                                headerMatcher.commentType,
-                                sourceCode,
-                                leadingComment,
-                                fixLines,
-                                eol,
-                                numLines);
-                        }
+            if (!language.lineComment && (/** @type {InlineConfig} */ (options.header)).commentType === "line") {
+                context.report({
+                    messageId: "unsupportedLineHeader",
+                    loc: {
+                        start: sourceCode.getLocFromIndex(0),
+                        end: sourceCode.getLocFromIndex(1),
+                    },
+                });
+                return;
+            }
 
-                        context.report(headerReport);
-                        for (const commentReport of leadingCommentReports) {
-                            if (commentReport !== null) {
-                                /** @type {{ messageId: string }} */ (commentReport).messageId =
-                                    "leadingComment-" + /** @type {{ messageId: string }} */ (commentReport).messageId;
-                                context.report(commentReport);
-                            }
-                        }
-                        return;
-                    }
+            const headerMatcher = new CommentMatcher(header, eol, numLines, language);
+            const allowedLeadingComments = /** @type {LeadingComments} */ (options.leadingComments).comments;
+            const allowedCommentsMatchers =
+                allowedLeadingComments.map((c) => new CommentMatcher(/** @type {InlineConfig} */(c), eol, 0, language));
+
+            const leadingComments = getLeadingComments(sourceCode, language);
+            // XXX: the reason we test like this instead of checking the
+            // first comment is of type "Shabeng" is because
+            // @typecript-eslint/prser does not recognize shebang comments
+            // with some TypeScript configuration. Since we are not
+            // releasing a major version we do not want to break the current
+            // behavior of not be pedantic about the tsconfig.json.
+            const hasShebang = language.shebang && sourceCode.text.startsWith("#!");
+            let startingHeaderLine = 1;
+            if (hasShebang) {
+                if (leadingComments.length > 0
+                    && /** @type {string} */ (leadingComments[0][0].type) === "Shebang"
+                ) {
+                    leadingComments.splice(0, 1);
                 }
+                startingHeaderLine = 2;
+            }
 
-                const lastComment = leadingComments[leadingComments.length - 1];
-                const lastCommentLine = lastComment[lastComment.length - 1];
-                const lineIndex = /** @type {number} */ (lastCommentLine.loc?.end.line) + 1;
-
+            if (leadingComments.length === 0 || leadingComments[0][0].loc.start.line > startingHeaderLine) {
                 context.report({
                     loc: {
                         start: {
                             column: 0,
-                            line: lineIndex
+                            line: startingHeaderLine
                         },
                         end: {
                             column: 0,
-                            line: lineIndex
+                            line: startingHeaderLine
                         }
                     },
                     messageId: "missingHeader",
@@ -1067,12 +1104,121 @@ const headerRule = {
                             sourceCode,
                             fixLines,
                             eol,
-                            numLines)
+                            numLines,
+                            language)
                         : null
                 });
+                return;
             }
+
+            for (const leadingComment of leadingComments) {
+
+                const headerReport = headerMatcher.validate(leadingComment, sourceCode);
+                if (headerReport === null) {
+                    return;
+                }
+                const leadingCommentReports =
+                    allowedCommentsMatchers.map((m) => m.validate(leadingComment, sourceCode));
+                const commentMatched = leadingCommentReports.some((report) => report === null);
+
+                if (!commentMatched) {
+                    if ("messageId" in headerReport && headerReport.messageId === "noNewlineAfterHeader") {
+                        const { expected, actual } =
+                            /** @type {{ expected: number, actual: number }} */ (headerReport.data);
+                        headerReport.fix = genEmptyLinesFixer(leadingComment, eol, expected - actual);
+                    } else if (canFix) {
+                        headerReport.fix = genReplaceFixer(
+                            headerMatcher.commentType,
+                            sourceCode,
+                            leadingComment,
+                            fixLines,
+                            eol,
+                            numLines,
+                            language);
+                    }
+
+                    context.report(headerReport);
+                    for (const commentReport of leadingCommentReports) {
+                        if (commentReport !== null) {
+                            /** @type {{ messageId: string }} */ (commentReport).messageId =
+                                "leadingComment-" + /** @type {{ messageId: string }} */ (commentReport).messageId;
+                            context.report(commentReport);
+                        }
+                    }
+                    return;
+                }
+            }
+
+            const lastComment = leadingComments[leadingComments.length - 1];
+            const lastCommentLine = lastComment[lastComment.length - 1];
+            const lineIndex = lastCommentLine.loc.end.line + 1;
+
+            context.report({
+                loc: {
+                    start: {
+                        column: 0,
+                        line: lineIndex
+                    },
+                    end: {
+                        column: 0,
+                        line: lineIndex
+                    }
+                },
+                messageId: "missingHeader",
+                fix: canFix
+                    ? genPrependFixer(
+                        headerMatcher.commentType,
+                        sourceCode,
+                        fixLines,
+                        eol,
+                        numLines,
+                        language)
+                    : null
+            });
+        }
+
+        /** @type {Language} */
+        const jsStyleLanguage = {
+            blockComment: {
+                startDelimiter: "/*",
+                endDelimiter: "*/"
+            },
+            lineComment: {
+                startDelimiter: "//"
+            },
+            shebang: true
+        };
+
+        /** @type {Language} */
+        const cssStyleLanguage = {
+            blockComment: {
+                startDelimiter: "/*",
+                endDelimiter: "*/"
+            },
+        };
+
+        /** @type {Language} */
+        const htmlStyleLanguage = {
+            blockComment: {
+                startDelimiter: "<!--",
+                endDelimiter: "-->"
+            }
+        };
+
+        const hooks = {
+            Program: () =>
+                onRootNode(
+                    sourceCode.constructor.name === "HTMLSourceCode"
+                        ? htmlStyleLanguage
+                        : jsStyleLanguage
+                ),
+            StyleSheet: () => onRootNode(cssStyleLanguage),
+            // eslint/markdown
+            root: () => onRootNode(htmlStyleLanguage),
         };
+        return hooks;
     }
 };
 
 exports.header = headerRule;
+exports.parsedFilesCache = parsedFilesCache;