@tony.ganchev/eslint-plugin-header 3.1.10 → 3.1.12

package/LICENSE.md

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) 2015-present Stuart Knightley, Tony Ganchev and contributors
+Copyright (c) 2015-present Stuart Knightley, Tony Ganchev, and contributors
 
 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

package/README.md

@@ -10,17 +10,18 @@ defined in the rule settings.
 ## Table of Contents
 
 1. [Scope and Acknowledgements](#scope-and-acknowledgements)
-2. [Usage](#usage)
+2. [Compatibility](#compatibility)
+3. [Usage](#usage)
    1. [File-based Configuration](#file-based-configuration)
    2. [Inline Configuration](#inline-configuration)
       1. [Header Contents Configuration](#header-contents-configuration)
       2. [Trailing Empty Lines Configuration](#trailing-empty-lines-configuration)
       3. [Line Endings](#line-endings)
-3. [Examples](#examples)
-4. [Versioning](#versioning)
+4. [Examples](#examples)
+5. [Versioning](#versioning)
    1. [What is a Feature?](#what-is-a-feature)
    2. [What is Backward-compatibility?](#what-is-backward-compatibility)
-5. [License](#license)
+6. [License](#license)
 
 ## Scope and Acknowledgements
 
@@ -39,6 +40,11 @@ It addresses the following issus:
   forward. This would come at the expense of plugin compatibility and the
   portability of fixes to the upstream repository.
 
+## Compatibility
+
+The plugin supports ESLint 7 / 8 / 9 / 10rc0 (check package.json for details).
+Both flat config and legacy, hierarchical config can be used.
+
 ## Usage
 
 This rule takes between 1 and 4 arguments after the rule validation severity.

package/index.js

@@ -1,7 +1,7 @@
 /*
  * MIT License
  *
- * Copyright (c) 2015-present Stuart Knightley, Tony Ganchev and contributors
+ * Copyright (c) 2015-present Stuart Knightley, Tony Ganchev, and contributors
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the “Software”), to deal

package/lib/comment-parser.js

@@ -1,7 +1,7 @@
 /*
  * MIT License
  *
- * Copyright (c) 2015-present Stuart Knightley, Tony Ganchev and contributors
+ * Copyright (c) 2015-present Stuart Knightley, Tony Ganchev, and contributors
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the “Software”), to deal

package/lib/rules/eslint-utils.js

@@ -0,0 +1,42 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2025-present Tony Ganchev and contributors
+ *
+ * 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
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+"use strict";
+
+/**
+ * @typedef {import('eslint').Rule.RuleContext} RuleContext
+ * @typedef {import('eslint').SourceCode} SourceCode
+ */
+
+module.exports = {
+    /**
+     * Provides compatibility wrapper for ESLint 7 through 10 for getting the
+     * full source code object from the execution context.
+     * @param {RuleContext} context ESLint execution context.
+     * @returns {SourceCode} the source-code object.
+     */
+    contextSourceCode: function(context) {
+        return context.sourceCode || context.getSourceCode();
+    }
+};

package/lib/rules/header.js

@@ -24,10 +24,16 @@
 
 "use strict";
 
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const commentParser = require("../comment-parser");
+const { contextSourceCode } = require("./eslint-utils");
+const { description, recommended, url } = require("./header.docs");
+const { commentTypeOptions, lineEndingOptions, schema } = require("./header.schema");
+
 /**
  * Import type definitions.
- * @typedef {import('estree').Comment} Comment
- * @typedef {import('estree').Program} Program
  * @typedef {import('eslint').Rule.Fix} Fix
  * @typedef {import('eslint').Rule.NodeListener} NodeListener
  * @typedef {import('eslint').Rule.ReportFixer} ReportFixer
@@ -35,6 +41,9 @@
  * @typedef {import('eslint').Rule.RuleTextEdit} RuleTextEdit
  * @typedef {import('eslint').Rule.RuleTextEditor} RuleTextEditor
  * @typedef {import('eslint').Rule.RuleContext} RuleContext
+ * @typedef {import('estree').Comment} Comment
+ * @typedef {import('estree').Program} Program
+ * @typedef {import("estree").SourceLocation} SourceLocation
  */
 
 /**
@@ -52,13 +61,6 @@
  * } HeaderOptions
  */
 
-const assert = require("assert");
-const fs = require("fs");
-const os = require("os");
-const commentParser = require("../comment-parser");
-const { description, recommended, url } = require("./header.docs");
-const { commentTypeOptions, lineEndingOptions, schema } = require("./header.schema");
-
 /**
  * Tests if the passed line configuration string or object is a pattern
  * definition.
@@ -90,8 +92,8 @@ function match(actual, expected) {
  * Remove Unix she-bangs from the list of comments.
  * @param {Comment[]} comments the list of comment lines.
  * @returns {Comment[]} the list of comments with containing all incomming
- *                      comments from `comments` with the shebang
- *                      comments omitted.
+ *                      comments from `comments` with the shebang comments
+ *                      omitted.
  */
 function excludeShebangs(comments) {
     return comments.filter(function(comment) {
@@ -109,13 +111,14 @@ function excludeShebangs(comments) {
  * @returns {Comment[]} lines that constitute the leading comment.
  */
 function getLeadingComments(context, node) {
-    const all = excludeShebangs(context.sourceCode.getAllComments(node.body.length ? node.body[0] : node));
+    const sourceCode = contextSourceCode(context);
+    const all = excludeShebangs(sourceCode.getAllComments(node.body.length ? node.body[0] : node));
     if (all[0].type.toLowerCase() === commentTypeOptions.block) {
         return [all[0]];
     }
     let i = 1;
     for (; i < all.length; ++i) {
-        const txt = context.sourceCode.text.slice(all[i - 1].range[1], all[i].range[0]);
+        const txt = sourceCode.text.slice(all[i - 1].range[1], all[i].range[0]);
         if (!txt.match(/^(\r\n|\r|\n)$/)) {
             break;
         }
@@ -186,14 +189,15 @@ function genPrependFixer(commentType, context, headerLines, eol, numNewlines) {
     return function(fixer) {
         let insertPos = 0;
         let newHeader = genCommentBody(commentType, headerLines, eol, numNewlines);
-        if (context.sourceCode.text.substring(0, 2) === "#!") {
-            const firstNewLinePos = context.sourceCode.text.indexOf("\n");
-            insertPos = firstNewLinePos === -1 ? context.sourceCode.text.length : firstNewLinePos + 1;
+        const sourceCode = contextSourceCode(context);
+        if (sourceCode.text.startsWith("#!")) {
+            const firstNewLinePos = sourceCode.text.indexOf("\n");
+            insertPos = firstNewLinePos === -1 ? sourceCode.text.length : firstNewLinePos + 1;
             if (firstNewLinePos === -1) {
                 newHeader = eol + newHeader;
             }
         }
-        const numEmptyLines = leadingEmptyLines(context.sourceCode.text.substring(insertPos));
+        const numEmptyLines = leadingEmptyLines(sourceCode.text.substring(insertPos));
         const additionalEmptyLines = Math.max(0, numNewlines - numEmptyLines);
         newHeader += eol.repeat(additionalEmptyLines);
         return fixer.insertTextBeforeRange(
@@ -218,7 +222,7 @@ function genPrependFixer(commentType, context, headerLines, eol, numNewlines) {
 function genReplaceFixer(commentType, context, leadingComments, headerLines, eol, numNewlines) {
     return function(fixer) {
         const commentRange = genCommentsRange(leadingComments);
-        const emptyLines = leadingEmptyLines(context.sourceCode.text.substring(commentRange[1]));
+        const emptyLines = leadingEmptyLines(contextSourceCode(context).text.substring(commentRange[1]));
         const missingNewlines = Math.max(0, numNewlines - emptyLines);
         const eols = eol.repeat(missingNewlines);
         return fixer.replaceTextRange(
@@ -288,16 +292,33 @@ function getEOL(options) {
  * @param {string} src source code to test.
  * @returns {boolean} `true` if there is a comment or `false` otherwise.
  */
-// TODO: check if it is valid to have the copyright notice separated by an empty
-//       line from the shebang.
 function hasHeader(src) {
-    if (src.startsWith("#!")) {
-        const m = src.match(/(\r\n|\r|\n)/);
-        if (m) {
-            src = src.slice(m.index + m[0].length);
+    const srcWithoutShebang = src.replace(/^#![^\n]*\r?\n/, "");
+    return srcWithoutShebang.startsWith("/*") || srcWithoutShebang.startsWith("//");
+}
+
+/**
+ * Calculates the source location of the violation that not enough empty lines
+ * follow the header.
+ * The behavior chosen is that the violation is shown over the empty (but
+ * 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.
+ */
+function missingEmptyLinesViolationLoc(leadingComments, actualEmptyLines) {
+    const lastCommentLineLocEnd = leadingComments[leadingComments.length - 1].loc.end;
+    return {
+        start: lastCommentLineLocEnd,
+        end: {
+            column: actualEmptyLines === 0 ? lastCommentLineLocEnd.column + 1 : 0,
+            line: lastCommentLineLocEnd.line + actualEmptyLines
         }
-    }
-    return src.startsWith("/*") || src.startsWith("//");
+    };
 }
 
 module.exports = {
@@ -312,10 +333,16 @@ module.exports = {
         schema,
         defaultOptions: [{}],
         messages: {
+            headerLineMismatchAtPos: "header line does not match expected after this position; expected: {{expected}}",
+            headerLineTooLong: "header line longer than expected",
+            headerLineTooShort: "header line shorter than expected; missing: {{remainder}}",
+            headerTooShort: "header too short: missing lines: {{remainder}}",
+            headerTooLong: "header too long",
             incorrectCommentType: "header should be a {{commentType}} comment",
             incorrectHeader: "incorrect header",
+            incorrectHeaderLine: "header line does not match pattern: {{pattern}}",
             missingHeader: "missing header",
-            noNewlineAfterHeader: "no newline after header"
+            noNewlineAfterHeader: "not enough newlines after header: expected: {{expected}}, actual: {{actual}}"
         }
     },
     /**
@@ -335,6 +362,7 @@ module.exports = {
         }
 
         const commentType = options[0].toLowerCase();
+        /** @type {(string | RegExp)[]} */
         let headerLines;
         let fixLines = [];
         // If any of the lines are regular expressions, then we can't
@@ -372,9 +400,21 @@ module.exports = {
              * @returns {void}
              */
             Program: function(node) {
-                if (!hasHeader(context.sourceCode.text)) {
+                const sourceCode = contextSourceCode(context);
+                if (!hasHeader(sourceCode.text)) {
+                    const hasShebang = sourceCode.text.startsWith("#!");
+                    const line = hasShebang ? 2 : 1;
                     context.report({
-                        loc: node.loc,
+                        loc: {
+                            start: {
+                                column: 1,
+                                line
+                            },
+                            end: {
+                                column: 1,
+                                line
+                            }
+                        },
                         messageId: "missingHeader",
                         fix: genPrependFixer(commentType, context, fixLines, eol, numNewlines)
                     });
@@ -384,7 +424,10 @@ module.exports = {
 
                 if (leadingComments[0].type.toLowerCase() !== commentType) {
                     context.report({
-                        loc: node.loc,
+                        loc: {
+                            start: leadingComments[0].loc.start,
+                            end: leadingComments[leadingComments.length - 1].loc.end
+                        },
                         messageId: "incorrectCommentType",
                         data: {
                             commentType: commentType
@@ -396,16 +439,6 @@ module.exports = {
                     return;
                 }
                 if (commentType === commentTypeOptions.line) {
-                    if (leadingComments.length < headerLines.length) {
-                        context.report({
-                            loc: node.loc,
-                            messageId: "incorrectHeader",
-                            fix: canFix
-                                ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines)
-                                : null
-                        });
-                        return;
-                    }
                     if (headerLines.length === 1) {
                         const leadingCommentValues = leadingComments.map((c) => c.value);
                         if (
@@ -413,7 +446,10 @@ module.exports = {
                             && !match(leadingCommentValues.join("\r\n"), headerLines[0])
                         ) {
                             context.report({
-                                loc: node.loc,
+                                loc: {
+                                    start: leadingComments[0].loc.start,
+                                    end: leadingComments[leadingComments.length - 1].loc.end
+                                },
                                 messageId: "incorrectHeader",
                                 fix: canFix
                                     ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines)
@@ -423,10 +459,15 @@ module.exports = {
                         }
                     } else {
                         for (let i = 0; i < headerLines.length; i++) {
-                            if (!match(leadingComments[i].value, headerLines[i])) {
+                            if (leadingComments.length - 1 < i) {
                                 context.report({
-                                    loc: node.loc,
-                                    messageId: "incorrectHeader",
+                                    loc: {
+                                        start: leadingComments[leadingComments.length - 1].loc.end
+                                    },
+                                    messageId: "headerTooShort",
+                                    data: {
+                                        remainder: headerLines.slice(i).join(eol)
+                                    },
                                     fix: canFix
                                         ? genReplaceFixer(
                                             commentType,
@@ -439,17 +480,119 @@ module.exports = {
                                 });
                                 return;
                             }
+                            if (typeof headerLines[i] === "string") {
+                                const leadingCommentLength = leadingComments[i].value.length;
+                                const headerLineLength = headerLines[i].length;
+                                for (let j = 0; j < Math.min(leadingCommentLength, headerLineLength); j++) {
+                                    if (leadingComments[i].value[j] !== headerLines[i][j]) {
+                                        context.report({
+                                            loc: {
+                                                start: {
+                                                    column: "//".length + j,
+                                                    line: leadingComments[i].loc.start.line
+                                                },
+                                                end: leadingComments[i].loc.end
+                                            },
+                                            messageId: "headerLineMismatchAtPos",
+                                            data: {
+                                                expected: headerLines[i].substring(j)
+                                            },
+                                            fix: genReplaceFixer(
+                                                commentType,
+                                                context,
+                                                leadingComments,
+                                                fixLines,
+                                                eol,
+                                                numNewlines)
+                                        });
+                                        return;
+                                    }
+                                }
+                                if (leadingCommentLength < headerLineLength) {
+                                    context.report({
+                                        loc: {
+                                            start: leadingComments[i].loc.end,
+                                        },
+                                        messageId: "headerLineTooShort",
+                                        data: {
+                                            remainder: headerLines[i].substring(leadingCommentLength)
+                                        },
+                                        fix: canFix
+                                            ? genReplaceFixer(
+                                                commentType,
+                                                context,
+                                                leadingComments,
+                                                fixLines,
+                                                eol,
+                                                numNewlines)
+                                            : null
+                                    });
+                                    return;
+                                }
+                                if (leadingCommentLength > headerLineLength) {
+                                    context.report({
+                                        loc: {
+                                            start: {
+                                                column: "//".length + headerLineLength,
+                                                line: leadingComments[i].loc.start.line
+                                            },
+                                            end: leadingComments[i].loc.end,
+                                        },
+                                        messageId: "headerLineTooLong",
+                                        fix: canFix
+                                            ? genReplaceFixer(
+                                                commentType,
+                                                context,
+                                                leadingComments,
+                                                fixLines,
+                                                eol,
+                                                numNewlines)
+                                            : null
+                                    });
+                                    return;
+                                }
+                            } else {
+                                if (!match(leadingComments[i].value, headerLines[i])) {
+                                    context.report({
+                                        loc: {
+                                            start: {
+                                                column: "//".length,
+                                                line: leadingComments[i].loc.start.line,
+                                            },
+                                            end: leadingComments[i].loc.end,
+                                        },
+                                        messageId: "incorrectHeaderLine",
+                                        data: {
+                                            pattern: headerLines[i]
+                                        },
+                                        fix: canFix
+                                            ? genReplaceFixer(
+                                                commentType,
+                                                context,
+                                                leadingComments,
+                                                fixLines,
+                                                eol,
+                                                numNewlines)
+                                            : null
+                                    });
+                                    return;
+                                }
+                            }
                         }
                     }
 
-                    const actualLeadingEmptyLines = leadingEmptyLines(
-                        context.sourceCode.text.substring(leadingComments[headerLines.length - 1].range[1]));
+                    const actualLeadingEmptyLines =
+                        leadingEmptyLines(sourceCode.text.substring(leadingComments[headerLines.length - 1].range[1]));
                     const missingEmptyLines = numNewlines - actualLeadingEmptyLines;
                     if (missingEmptyLines > 0) {
                         context.report({
-                            loc: node.loc,
+                            loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
                             messageId: "noNewlineAfterHeader",
-                            fix: canFix ? genEmptyLinesFixer(leadingComments, eol, missingEmptyLines) : null
+                            data: {
+                                expected: numNewlines,
+                                actual: actualLeadingEmptyLines
+                            },
+                            fix: genEmptyLinesFixer(leadingComments, eol, missingEmptyLines)
                         });
                     }
                     return;
@@ -461,26 +604,116 @@ module.exports = {
                     leadingLines = leadingComments[0].value.split(/\r?\n/);
                 }
 
-                let hasError = false;
-                if (leadingLines.length > headerLines.length) {
-                    hasError = true;
-                }
-                for (let i = 0; !hasError && i < headerLines.length; i++) {
+                /** @type {null | string} */
+                let errorMessageId = null;
+                /** @type {null | Record<string, string | RegExp>} */
+                let errorMessageData = null;
+                /** @type {null | SourceLocation} */
+                let errorMessageLoc = null;
+                for (let i = 0; i < headerLines.length; i++) {
                     const leadingLine = leadingLines[i];
                     const headerLine = headerLines[i];
-                    if (!match(leadingLine, headerLine)) {
-                        hasError = true;
-                        break;
+                    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 = leadingComments[0].loc.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: leadingComments[0].loc.start.line + i
+                                },
+                                end: {
+                                    column: startColumn + 1,
+                                    line: leadingComments[0].loc.start.line + i
+                                }
+                            };
+                            errorMessageData = {
+                                remainder: headerLines[i].substring(leadingLine.length)
+                            };
+                            break;
+                        }
+                        if (leadingLine.length > headerLine.length) {
+                            errorMessageId = "headerLineTooLong";
+                            errorMessageLoc = {
+                                start: {
+                                    column: (i === 0 ? "/*".length : 0) + headerLine.length,
+                                    line: leadingComments[0].loc.start.line + i
+                                },
+                                end: {
+                                    column: (i === 0 ? "/*".length : 0) + leadingLine.length,
+                                    line: leadingComments[0].loc.start.line + i
+                                }
+                            };
+                            break;
+                        }
+                    } else {
+                        if (!match(leadingLine, headerLine)) {
+                            errorMessageId = "incorrectHeaderLine";
+                            errorMessageData = {
+                                pattern: headerLine
+                            };
+                            const columnOffset = i === 0 ? "/*".length : 0;
+                            errorMessageLoc = {
+                                start: {
+                                    column: columnOffset + 0,
+                                    line: leadingComments[0].loc.start.line + i
+                                },
+                                end: {
+                                    column: columnOffset + leadingLine.length,
+                                    line: leadingComments[0].loc.start.line + i
+                                }
+                            };
+                            break;
+                        }
                     }
                 }
 
-                if (hasError) {
+                if (!errorMessageId && leadingLines.length > headerLines.length) {
+                    errorMessageId = "headerTooLong";
+                    errorMessageLoc = {
+                        start: {
+                            column: (headerLines.length === 0 ? "/*".length : 0) + 0,
+                            line: leadingComments[0].loc.start.line + headerLines.length
+                        },
+                        end: {
+                            column: leadingComments[leadingComments.length - 1].loc.end.column - "*/".length,
+                            line: leadingComments[leadingComments.length - 1].loc.end.line
+                        }
+                    };
+                }
+
+                if (errorMessageId) {
                     if (canFix && headerLines.length > 1) {
                         fixLines = [fixLines.join(eol)];
                     }
                     context.report({
-                        loc: node.loc,
-                        messageId: "incorrectHeader",
+                        loc: errorMessageLoc,
+                        messageId: errorMessageId,
+                        data: errorMessageData,
                         fix: canFix
                             ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines)
                             : null
@@ -488,14 +721,18 @@ module.exports = {
                     return;
                 }
 
-                const actualLeadingEmptyLines = leadingEmptyLines(
-                    context.sourceCode.text.substring(leadingComments[0].range[1]));
+                const actualLeadingEmptyLines =
+                    leadingEmptyLines(sourceCode.text.substring(leadingComments[0].range[1]));
                 const missingEmptyLines = numNewlines - actualLeadingEmptyLines;
                 if (missingEmptyLines > 0) {
                     context.report({
-                        loc: node.loc,
+                        loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
                         messageId: "noNewlineAfterHeader",
-                        fix: canFix ? genEmptyLinesFixer(leadingComments, eol, missingEmptyLines) : null
+                        data: {
+                            expected: numNewlines,
+                            actual: actualLeadingEmptyLines
+                        },
+                        fix: genEmptyLinesFixer(leadingComments, eol, missingEmptyLines)
                     });
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tony.ganchev/eslint-plugin-header",
-  "version": "3.1.10",
+  "version": "3.1.12",
   "description": "ESLint plugin to ensure files begin with a given comment, usually a copyright or license notice.",
   "main": "index.js",
   "files": [
@@ -11,19 +11,21 @@
     "eslint": "npx eslint .",
     "lint": "npm run eslint && npm run markdownlint",
     "markdownlint": "npx markdownlint-cli *.md",
-    "test": "npm run lint && npm run unit",
-    "unit": "npx nyc --reporter=html --reporter=text --reporter=text-summary --reporter=lcov --check-coverage=true --statements=100 --branches=100 --lines=100 --functions=100 mocha tests/lib/*.js tests/lib/**/*.js"
+    "test": "npm run lint && npm run unit && npm run e2e",
+    "unit": "npx nyc --reporter=html --reporter=text --reporter=text-summary --reporter=lcov --check-coverage=true --statements=100 --branches=100 --lines=100 --functions=100 mocha tests/lib/*.js tests/lib/**/*.js",
+    "e2e": "npx mocha --timeout 60000 tests/e2e/*.js"
   },
   "devDependencies": {
-    "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.32.0",
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^9.39.2",
     "@eslint/markdown": "^7.5.1",
-    "@stylistic/eslint-plugin": "^5.5.0",
-    "eslint": "^9.32.0",
-    "eslint-plugin-eslint-plugin": "^7.2.0",
-    "eslint-plugin-jsdoc": "^52.0.4",
-    "eslint-plugin-n": "^17.23.1",
-    "mocha": "^11.7.1",
+    "@stylistic/eslint-plugin": "^5.7.0",
+    "eslint": "^9.39.2",
+    "eslint-plugin-eslint-plugin": "^7.3.0",
+    "eslint-plugin-jsdoc": "^62.1.0",
+    "eslint-plugin-n": "^17.23.2",
+    "markdownlint-cli": "^0.47.0",
+    "mocha": "^12.0.0-beta-5",
     "nyc": "^17.1.0",
     "testdouble": "^3.20.2"
   },
@@ -40,7 +42,7 @@
   },
   "author": "Stuart Knightley",
   "license": "MIT",
-  "contributors": [
+  "maintainers": [
     "Tony Ganchev"
   ]
 }