eslint 9.22.0 → 9.23.0

package/lib/linter/apply-disable-directives.js

@@ -20,9 +20,7 @@
 
 const escapeRegExp = require("escape-string-regexp");
 const {
-    Legacy: {
-        ConfigOps
-    }
+	Legacy: { ConfigOps },
 } = require("@eslint/eslintrc/universal");
 
 /**
@@ -33,7 +31,7 @@ const {
  * itemA appears after itemB in the source file, or 0 if itemA and itemB have the same location.
  */
 function compareLocations(itemA, itemB) {
-    return itemA.line - itemB.line || itemA.column - itemB.column;
+	return itemA.line - itemB.line || itemA.column - itemB.column;
 }
 
 /**
@@ -42,19 +40,21 @@ function compareLocations(itemA, itemB) {
  * @returns {Directive[][]} Directives grouped by their parent comment.
  */
 function groupByParentDirective(directives) {
-    const groups = new Map();
+	const groups = new Map();
 
-    for (const directive of directives) {
-        const { unprocessedDirective: { parentDirective } } = directive;
+	for (const directive of directives) {
+		const {
+			unprocessedDirective: { parentDirective },
+		} = directive;
 
-        if (groups.has(parentDirective)) {
-            groups.get(parentDirective).push(directive);
-        } else {
-            groups.set(parentDirective, [directive]);
-        }
-    }
+		if (groups.has(parentDirective)) {
+			groups.get(parentDirective).push(directive);
+		} else {
+			groups.set(parentDirective, [directive]);
+		}
+	}
 
-    return [...groups.values()];
+	return [...groups.values()];
 }
 
 /**
@@ -64,93 +64,96 @@ function groupByParentDirective(directives) {
  * @param {SourceCode} sourceCode The source code object for the file being linted.
  * @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems.
  */
-function createIndividualDirectivesRemoval(directives, parentDirective, sourceCode) {
-
-    /*
-     * Get the list of the rules text without any surrounding whitespace. In order to preserve the original
-     * formatting, we don't want to change that whitespace.
-     *
-     *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
-     *                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-     */
-    const listText = parentDirective.value.trim();
-
-    // Calculate where it starts in the source code text
-    const listStart = sourceCode.text.indexOf(listText, sourceCode.getRange(parentDirective.node)[0]);
-
-    /*
-     * We can assume that `listText` contains multiple elements.
-     * Otherwise, this function wouldn't be called - if there is
-     * only one rule in the list, then the whole comment must be removed.
-     */
-
-    return directives.map(directive => {
-        const { ruleId } = directive;
-
-        const regex = new RegExp(String.raw`(?:^|\s*,\s*)(?<quote>['"]?)${escapeRegExp(ruleId)}\k<quote>(?:\s*,\s*|$)`, "u");
-        const match = regex.exec(listText);
-        const matchedText = match[0];
-        const matchStart = listStart + match.index;
-        const matchEnd = matchStart + matchedText.length;
-
-        const firstIndexOfComma = matchedText.indexOf(",");
-        const lastIndexOfComma = matchedText.lastIndexOf(",");
-
-        let removalStart, removalEnd;
-
-        if (firstIndexOfComma !== lastIndexOfComma) {
-
-            /*
-             * Since there are two commas, this must one of the elements in the middle of the list.
-             * Matched range starts where the previous rule name ends, and ends where the next rule name starts.
-             *
-             *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
-             *                                    ^^^^^^^^^^^^^^
-             *
-             * We want to remove only the content between the two commas, and also one of the commas.
-             *
-             *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
-             *                                     ^^^^^^^^^^^
-             */
-            removalStart = matchStart + firstIndexOfComma;
-            removalEnd = matchStart + lastIndexOfComma;
-
-        } else {
-
-            /*
-             * This is either the first element or the last element.
-             *
-             * If this is the first element, matched range starts where the first rule name starts
-             * and ends where the second rule name starts. This is exactly the range we want
-             * to remove so that the second rule name will start where the first one was starting
-             * and thus preserve the original formatting.
-             *
-             *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
-             *                            ^^^^^^^^^^^
-             *
-             * Similarly, if this is the last element, we've already matched the range we want to
-             * remove. The previous rule name will end where the last one was ending, relative
-             * to the content on the right side.
-             *
-             *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
-             *                                               ^^^^^^^^^^^^^
-             */
-            removalStart = matchStart;
-            removalEnd = matchEnd;
-        }
-
-        return {
-            description: `'${ruleId}'`,
-            fix: {
-                range: [
-                    removalStart,
-                    removalEnd
-                ],
-                text: ""
-            },
-            unprocessedDirective: directive.unprocessedDirective
-        };
-    });
+function createIndividualDirectivesRemoval(
+	directives,
+	parentDirective,
+	sourceCode,
+) {
+	/*
+	 * Get the list of the rules text without any surrounding whitespace. In order to preserve the original
+	 * formatting, we don't want to change that whitespace.
+	 *
+	 *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
+	 *                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+	 */
+	const listText = parentDirective.value.trim();
+
+	// Calculate where it starts in the source code text
+	const listStart = sourceCode.text.indexOf(
+		listText,
+		sourceCode.getRange(parentDirective.node)[0],
+	);
+
+	/*
+	 * We can assume that `listText` contains multiple elements.
+	 * Otherwise, this function wouldn't be called - if there is
+	 * only one rule in the list, then the whole comment must be removed.
+	 */
+
+	return directives.map(directive => {
+		const { ruleId } = directive;
+
+		const regex = new RegExp(
+			String.raw`(?:^|\s*,\s*)(?<quote>['"]?)${escapeRegExp(ruleId)}\k<quote>(?:\s*,\s*|$)`,
+			"u",
+		);
+		const match = regex.exec(listText);
+		const matchedText = match[0];
+		const matchStart = listStart + match.index;
+		const matchEnd = matchStart + matchedText.length;
+
+		const firstIndexOfComma = matchedText.indexOf(",");
+		const lastIndexOfComma = matchedText.lastIndexOf(",");
+
+		let removalStart, removalEnd;
+
+		if (firstIndexOfComma !== lastIndexOfComma) {
+			/*
+			 * Since there are two commas, this must one of the elements in the middle of the list.
+			 * Matched range starts where the previous rule name ends, and ends where the next rule name starts.
+			 *
+			 *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
+			 *                                    ^^^^^^^^^^^^^^
+			 *
+			 * We want to remove only the content between the two commas, and also one of the commas.
+			 *
+			 *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
+			 *                                     ^^^^^^^^^^^
+			 */
+			removalStart = matchStart + firstIndexOfComma;
+			removalEnd = matchStart + lastIndexOfComma;
+		} else {
+			/*
+			 * This is either the first element or the last element.
+			 *
+			 * If this is the first element, matched range starts where the first rule name starts
+			 * and ends where the second rule name starts. This is exactly the range we want
+			 * to remove so that the second rule name will start where the first one was starting
+			 * and thus preserve the original formatting.
+			 *
+			 *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
+			 *                            ^^^^^^^^^^^
+			 *
+			 * Similarly, if this is the last element, we've already matched the range we want to
+			 * remove. The previous rule name will end where the last one was ending, relative
+			 * to the content on the right side.
+			 *
+			 *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
+			 *                                               ^^^^^^^^^^^^^
+			 */
+			removalStart = matchStart;
+			removalEnd = matchEnd;
+		}
+
+		return {
+			description: `'${ruleId}'`,
+			fix: {
+				range: [removalStart, removalEnd],
+				text: "",
+			},
+			unprocessedDirective: directive.unprocessedDirective,
+		};
+	});
 }
 
 /**
@@ -161,19 +164,22 @@ function createIndividualDirectivesRemoval(directives, parentDirective, sourceCo
  * @returns {{ description, fix, unprocessedDirective }} Details for later creation of an output problem.
  */
 function createDirectiveRemoval(directives, node, sourceCode) {
-    const range = sourceCode.getRange(node);
-    const ruleIds = directives.filter(directive => directive.ruleId).map(directive => `'${directive.ruleId}'`);
-
-    return {
-        description: ruleIds.length <= 2
-            ? ruleIds.join(" or ")
-            : `${ruleIds.slice(0, ruleIds.length - 1).join(", ")}, or ${ruleIds.at(-1)}`,
-        fix: {
-            range,
-            text: " "
-        },
-        unprocessedDirective: directives[0].unprocessedDirective
-    };
+	const range = sourceCode.getRange(node);
+	const ruleIds = directives
+		.filter(directive => directive.ruleId)
+		.map(directive => `'${directive.ruleId}'`);
+
+	return {
+		description:
+			ruleIds.length <= 2
+				? ruleIds.join(" or ")
+				: `${ruleIds.slice(0, ruleIds.length - 1).join(", ")}, or ${ruleIds.at(-1)}`,
+		fix: {
+			range,
+			text: " ",
+		},
+		unprocessedDirective: directives[0].unprocessedDirective,
+	};
 }
 
 /**
@@ -183,22 +189,30 @@ function createDirectiveRemoval(directives, node, sourceCode) {
  * @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems.
  */
 function processUnusedDirectives(allDirectives, sourceCode) {
-    const directiveGroups = groupByParentDirective(allDirectives);
-
-    return directiveGroups.flatMap(
-        directives => {
-            const { parentDirective } = directives[0].unprocessedDirective;
-            const remainingRuleIds = new Set(parentDirective.ruleIds);
-
-            for (const directive of directives) {
-                remainingRuleIds.delete(directive.ruleId);
-            }
-
-            return remainingRuleIds.size
-                ? createIndividualDirectivesRemoval(directives, parentDirective, sourceCode)
-                : [createDirectiveRemoval(directives, parentDirective.node, sourceCode)];
-        }
-    );
+	const directiveGroups = groupByParentDirective(allDirectives);
+
+	return directiveGroups.flatMap(directives => {
+		const { parentDirective } = directives[0].unprocessedDirective;
+		const remainingRuleIds = new Set(parentDirective.ruleIds);
+
+		for (const directive of directives) {
+			remainingRuleIds.delete(directive.ruleId);
+		}
+
+		return remainingRuleIds.size
+			? createIndividualDirectivesRemoval(
+					directives,
+					parentDirective,
+					sourceCode,
+				)
+			: [
+					createDirectiveRemoval(
+						directives,
+						parentDirective.node,
+						sourceCode,
+					),
+				];
+	});
 }
 
 /**
@@ -207,87 +221,83 @@ function processUnusedDirectives(allDirectives, sourceCode) {
  * @returns {Set<Directive>} The used eslint-enable comments
  */
 function collectUsedEnableDirectives(directives) {
-
-    /**
-     * A Map of `eslint-enable` keyed by ruleIds that may be marked as used.
-     * If `eslint-enable` does not have a ruleId, the key will be `null`.
-     * @type {Map<string|null, Directive>}
-     */
-    const enabledRules = new Map();
-
-    /**
-     * A Set of `eslint-enable` marked as used.
-     * It is also the return value of `collectUsedEnableDirectives` function.
-     * @type {Set<Directive>}
-     */
-    const usedEnableDirectives = new Set();
-
-    /*
-     * Checks the directives backwards to see if the encountered `eslint-enable` is used by the previous `eslint-disable`,
-     * and if so, stores the `eslint-enable` in `usedEnableDirectives`.
-     */
-    for (let index = directives.length - 1; index >= 0; index--) {
-        const directive = directives[index];
-
-        if (directive.type === "disable") {
-            if (enabledRules.size === 0) {
-                continue;
-            }
-            if (directive.ruleId === null) {
-
-                // If encounter `eslint-disable` without ruleId,
-                // mark all `eslint-enable` currently held in enabledRules as used.
-                // e.g.
-                //    /* eslint-disable */ <- current directive
-                //    /* eslint-enable rule-id1 */ <- used
-                //    /* eslint-enable rule-id2 */ <- used
-                //    /* eslint-enable */ <- used
-                for (const enableDirective of enabledRules.values()) {
-                    usedEnableDirectives.add(enableDirective);
-                }
-                enabledRules.clear();
-            } else {
-                const enableDirective = enabledRules.get(directive.ruleId);
-
-                if (enableDirective) {
-
-                    // If encounter `eslint-disable` with ruleId, and there is an `eslint-enable` with the same ruleId in enabledRules,
-                    // mark `eslint-enable` with ruleId as used.
-                    // e.g.
-                    //    /* eslint-disable rule-id */ <- current directive
-                    //    /* eslint-enable rule-id */ <- used
-                    usedEnableDirectives.add(enableDirective);
-                } else {
-                    const enabledDirectiveWithoutRuleId = enabledRules.get(null);
-
-                    if (enabledDirectiveWithoutRuleId) {
-
-                        // If encounter `eslint-disable` with ruleId, and there is no `eslint-enable` with the same ruleId in enabledRules,
-                        // mark `eslint-enable` without ruleId as used.
-                        // e.g.
-                        //    /* eslint-disable rule-id */ <- current directive
-                        //    /* eslint-enable */ <- used
-                        usedEnableDirectives.add(enabledDirectiveWithoutRuleId);
-                    }
-                }
-            }
-        } else if (directive.type === "enable") {
-            if (directive.ruleId === null) {
-
-                // If encounter `eslint-enable` without ruleId, the `eslint-enable` that follows it are unused.
-                // So clear enabledRules.
-                // e.g.
-                //    /* eslint-enable */ <- current directive
-                //    /* eslint-enable rule-id *// <- unused
-                //    /* eslint-enable */ <- unused
-                enabledRules.clear();
-                enabledRules.set(null, directive);
-            } else {
-                enabledRules.set(directive.ruleId, directive);
-            }
-        }
-    }
-    return usedEnableDirectives;
+	/**
+	 * A Map of `eslint-enable` keyed by ruleIds that may be marked as used.
+	 * If `eslint-enable` does not have a ruleId, the key will be `null`.
+	 * @type {Map<string|null, Directive>}
+	 */
+	const enabledRules = new Map();
+
+	/**
+	 * A Set of `eslint-enable` marked as used.
+	 * It is also the return value of `collectUsedEnableDirectives` function.
+	 * @type {Set<Directive>}
+	 */
+	const usedEnableDirectives = new Set();
+
+	/*
+	 * Checks the directives backwards to see if the encountered `eslint-enable` is used by the previous `eslint-disable`,
+	 * and if so, stores the `eslint-enable` in `usedEnableDirectives`.
+	 */
+	for (let index = directives.length - 1; index >= 0; index--) {
+		const directive = directives[index];
+
+		if (directive.type === "disable") {
+			if (enabledRules.size === 0) {
+				continue;
+			}
+			if (directive.ruleId === null) {
+				// If encounter `eslint-disable` without ruleId,
+				// mark all `eslint-enable` currently held in enabledRules as used.
+				// e.g.
+				//    /* eslint-disable */ <- current directive
+				//    /* eslint-enable rule-id1 */ <- used
+				//    /* eslint-enable rule-id2 */ <- used
+				//    /* eslint-enable */ <- used
+				for (const enableDirective of enabledRules.values()) {
+					usedEnableDirectives.add(enableDirective);
+				}
+				enabledRules.clear();
+			} else {
+				const enableDirective = enabledRules.get(directive.ruleId);
+
+				if (enableDirective) {
+					// If encounter `eslint-disable` with ruleId, and there is an `eslint-enable` with the same ruleId in enabledRules,
+					// mark `eslint-enable` with ruleId as used.
+					// e.g.
+					//    /* eslint-disable rule-id */ <- current directive
+					//    /* eslint-enable rule-id */ <- used
+					usedEnableDirectives.add(enableDirective);
+				} else {
+					const enabledDirectiveWithoutRuleId =
+						enabledRules.get(null);
+
+					if (enabledDirectiveWithoutRuleId) {
+						// If encounter `eslint-disable` with ruleId, and there is no `eslint-enable` with the same ruleId in enabledRules,
+						// mark `eslint-enable` without ruleId as used.
+						// e.g.
+						//    /* eslint-disable rule-id */ <- current directive
+						//    /* eslint-enable */ <- used
+						usedEnableDirectives.add(enabledDirectiveWithoutRuleId);
+					}
+				}
+			}
+		} else if (directive.type === "enable") {
+			if (directive.ruleId === null) {
+				// If encounter `eslint-enable` without ruleId, the `eslint-enable` that follows it are unused.
+				// So clear enabledRules.
+				// e.g.
+				//    /* eslint-enable */ <- current directive
+				//    /* eslint-enable rule-id *// <- unused
+				//    /* eslint-enable */ <- unused
+				enabledRules.clear();
+				enabledRules.set(null, directive);
+			} else {
+				enabledRules.set(directive.ruleId, directive);
+			}
+		}
+	}
+	return usedEnableDirectives;
 }
 
 /**
@@ -301,105 +311,132 @@ function collectUsedEnableDirectives(directives) {
  * of problems (including suppressed ones) and unused eslint-disable directives
  */
 function applyDirectives(options) {
-    const problems = [];
-    const usedDisableDirectives = new Set();
-    const { sourceCode } = options;
-
-    for (const problem of options.problems) {
-        let disableDirectivesForProblem = [];
-        let nextDirectiveIndex = 0;
-
-        while (
-            nextDirectiveIndex < options.directives.length &&
-            compareLocations(options.directives[nextDirectiveIndex], problem) <= 0
-        ) {
-            const directive = options.directives[nextDirectiveIndex++];
-
-            if (directive.ruleId === null || directive.ruleId === problem.ruleId) {
-                switch (directive.type) {
-                    case "disable":
-                        disableDirectivesForProblem.push(directive);
-                        break;
-
-                    case "enable":
-                        disableDirectivesForProblem = [];
-                        break;
-
-                    // no default
-                }
-            }
-        }
-
-        if (disableDirectivesForProblem.length > 0) {
-            const suppressions = disableDirectivesForProblem.map(directive => ({
-                kind: "directive",
-                justification: directive.unprocessedDirective.justification
-            }));
-
-            if (problem.suppressions) {
-                problem.suppressions = problem.suppressions.concat(suppressions);
-            } else {
-                problem.suppressions = suppressions;
-                usedDisableDirectives.add(disableDirectivesForProblem.at(-1));
-            }
-        }
-
-        problems.push(problem);
-    }
-
-    const unusedDisableDirectivesToReport = options.directives
-        .filter(directive => directive.type === "disable" && !usedDisableDirectives.has(directive) && !options.rulesToIgnore.has(directive.ruleId));
-
-
-    const unusedEnableDirectivesToReport = new Set(
-        options.directives.filter(directive => directive.unprocessedDirective.type === "enable" && !options.rulesToIgnore.has(directive.ruleId))
-    );
-
-    /*
-     * If directives has the eslint-enable directive,
-     * check whether the eslint-enable comment is used.
-     */
-    if (unusedEnableDirectivesToReport.size > 0) {
-        for (const directive of collectUsedEnableDirectives(options.directives)) {
-            unusedEnableDirectivesToReport.delete(directive);
-        }
-    }
-
-    const processed = processUnusedDirectives(unusedDisableDirectivesToReport, sourceCode)
-        .concat(processUnusedDirectives(unusedEnableDirectivesToReport, sourceCode));
-    const columnOffset = options.language.columnStart === 1 ? 0 : 1;
-    const lineOffset = options.language.lineStart === 1 ? 0 : 1;
-
-    const unusedDirectives = processed
-        .map(({ description, fix, unprocessedDirective }) => {
-            const { parentDirective, type, line, column } = unprocessedDirective;
-
-            let message;
-
-            if (type === "enable") {
-                message = description
-                    ? `Unused eslint-enable directive (no matching eslint-disable directives were found for ${description}).`
-                    : "Unused eslint-enable directive (no matching eslint-disable directives were found).";
-            } else {
-                message = description
-                    ? `Unused eslint-disable directive (no problems were reported from ${description}).`
-                    : "Unused eslint-disable directive (no problems were reported).";
-            }
-
-            const loc = sourceCode.getLoc(parentDirective.node);
-
-            return {
-                ruleId: null,
-                message,
-                line: type === "disable-next-line" ? loc.start.line + lineOffset : line,
-                column: type === "disable-next-line" ? loc.start.column + columnOffset : column,
-                severity: options.reportUnusedDisableDirectives === "warn" ? 1 : 2,
-                nodeType: null,
-                ...options.disableFixes ? {} : { fix }
-            };
-        });
-
-    return { problems, unusedDirectives };
+	const problems = [];
+	const usedDisableDirectives = new Set();
+	const { sourceCode } = options;
+
+	for (const problem of options.problems) {
+		let disableDirectivesForProblem = [];
+		let nextDirectiveIndex = 0;
+
+		while (
+			nextDirectiveIndex < options.directives.length &&
+			compareLocations(options.directives[nextDirectiveIndex], problem) <=
+				0
+		) {
+			const directive = options.directives[nextDirectiveIndex++];
+
+			if (
+				directive.ruleId === null ||
+				directive.ruleId === problem.ruleId
+			) {
+				switch (directive.type) {
+					case "disable":
+						disableDirectivesForProblem.push(directive);
+						break;
+
+					case "enable":
+						disableDirectivesForProblem = [];
+						break;
+
+					// no default
+				}
+			}
+		}
+
+		if (disableDirectivesForProblem.length > 0) {
+			const suppressions = disableDirectivesForProblem.map(directive => ({
+				kind: "directive",
+				justification: directive.unprocessedDirective.justification,
+			}));
+
+			if (problem.suppressions) {
+				problem.suppressions =
+					problem.suppressions.concat(suppressions);
+			} else {
+				problem.suppressions = suppressions;
+				usedDisableDirectives.add(disableDirectivesForProblem.at(-1));
+			}
+		}
+
+		problems.push(problem);
+	}
+
+	const unusedDisableDirectivesToReport = options.directives.filter(
+		directive =>
+			directive.type === "disable" &&
+			!usedDisableDirectives.has(directive) &&
+			!options.rulesToIgnore.has(directive.ruleId),
+	);
+
+	const unusedEnableDirectivesToReport = new Set(
+		options.directives.filter(
+			directive =>
+				directive.unprocessedDirective.type === "enable" &&
+				!options.rulesToIgnore.has(directive.ruleId),
+		),
+	);
+
+	/*
+	 * If directives has the eslint-enable directive,
+	 * check whether the eslint-enable comment is used.
+	 */
+	if (unusedEnableDirectivesToReport.size > 0) {
+		for (const directive of collectUsedEnableDirectives(
+			options.directives,
+		)) {
+			unusedEnableDirectivesToReport.delete(directive);
+		}
+	}
+
+	const processed = processUnusedDirectives(
+		unusedDisableDirectivesToReport,
+		sourceCode,
+	).concat(
+		processUnusedDirectives(unusedEnableDirectivesToReport, sourceCode),
+	);
+	const columnOffset = options.language.columnStart === 1 ? 0 : 1;
+	const lineOffset = options.language.lineStart === 1 ? 0 : 1;
+
+	const unusedDirectives = processed.map(
+		({ description, fix, unprocessedDirective }) => {
+			const { parentDirective, type, line, column } =
+				unprocessedDirective;
+
+			let message;
+
+			if (type === "enable") {
+				message = description
+					? `Unused eslint-enable directive (no matching eslint-disable directives were found for ${description}).`
+					: "Unused eslint-enable directive (no matching eslint-disable directives were found).";
+			} else {
+				message = description
+					? `Unused eslint-disable directive (no problems were reported from ${description}).`
+					: "Unused eslint-disable directive (no problems were reported).";
+			}
+
+			const loc = sourceCode.getLoc(parentDirective.node);
+
+			return {
+				ruleId: null,
+				message,
+				line:
+					type === "disable-next-line"
+						? loc.start.line + lineOffset
+						: line,
+				column:
+					type === "disable-next-line"
+						? loc.start.column + columnOffset
+						: column,
+				severity:
+					options.reportUnusedDisableDirectives === "warn" ? 1 : 2,
+				nodeType: null,
+				...(options.disableFixes ? {} : { fix }),
+			};
+		},
+	);
+
+	return { problems, unusedDirectives };
 }
 
 /**
@@ -426,77 +463,124 @@ function applyDirectives(options) {
  * @returns {{ruleId: (string|null), line: number, column: number, suppressions?: {kind: string, justification: string}}[]}
  * An object with a list of reported problems, the suppressed of which contain the suppression information.
  */
-module.exports = ({ language, sourceCode, directives, disableFixes, problems, configuredRules, ruleFilter, reportUnusedDisableDirectives = "off" }) => {
-    const blockDirectives = directives
-        .filter(directive => directive.type === "disable" || directive.type === "enable")
-        .map(directive => Object.assign({}, directive, { unprocessedDirective: directive }))
-        .sort(compareLocations);
-
-    const lineDirectives = directives.flatMap(directive => {
-        switch (directive.type) {
-            case "disable":
-            case "enable":
-                return [];
-
-            case "disable-line":
-                return [
-                    { type: "disable", line: directive.line, column: 1, ruleId: directive.ruleId, unprocessedDirective: directive },
-                    { type: "enable", line: directive.line + 1, column: 0, ruleId: directive.ruleId, unprocessedDirective: directive }
-                ];
-
-            case "disable-next-line":
-                return [
-                    { type: "disable", line: directive.line + 1, column: 1, ruleId: directive.ruleId, unprocessedDirective: directive },
-                    { type: "enable", line: directive.line + 2, column: 0, ruleId: directive.ruleId, unprocessedDirective: directive }
-                ];
-
-            default:
-                throw new TypeError(`Unrecognized directive type '${directive.type}'`);
-        }
-    }).sort(compareLocations);
-
-    // This determines a list of rules that are not being run by the given ruleFilter, if present.
-    const rulesToIgnore = configuredRules && ruleFilter
-        ? new Set(Object.keys(configuredRules).filter(ruleId => {
-            const severity = ConfigOps.getRuleSeverity(configuredRules[ruleId]);
-
-            // Ignore for disabled rules.
-            if (severity === 0) {
-                return false;
-            }
-
-            return !ruleFilter({ severity, ruleId });
-        }))
-        : new Set();
-
-    // If no ruleId is supplied that means this directive is applied to all rules, so we can't determine if it's unused if any rules are filtered out.
-    if (rulesToIgnore.size > 0) {
-        rulesToIgnore.add(null);
-    }
-
-    const blockDirectivesResult = applyDirectives({
-        language,
-        sourceCode,
-        problems,
-        directives: blockDirectives,
-        disableFixes,
-        reportUnusedDisableDirectives,
-        rulesToIgnore
-    });
-    const lineDirectivesResult = applyDirectives({
-        language,
-        sourceCode,
-        problems: blockDirectivesResult.problems,
-        directives: lineDirectives,
-        disableFixes,
-        reportUnusedDisableDirectives,
-        rulesToIgnore
-    });
-
-    return reportUnusedDisableDirectives !== "off"
-        ? lineDirectivesResult.problems
-            .concat(blockDirectivesResult.unusedDirectives)
-            .concat(lineDirectivesResult.unusedDirectives)
-            .sort(compareLocations)
-        : lineDirectivesResult.problems;
+module.exports = ({
+	language,
+	sourceCode,
+	directives,
+	disableFixes,
+	problems,
+	configuredRules,
+	ruleFilter,
+	reportUnusedDisableDirectives = "off",
+}) => {
+	const blockDirectives = directives
+		.filter(
+			directive =>
+				directive.type === "disable" || directive.type === "enable",
+		)
+		.map(directive =>
+			Object.assign({}, directive, { unprocessedDirective: directive }),
+		)
+		.sort(compareLocations);
+
+	const lineDirectives = directives
+		.flatMap(directive => {
+			switch (directive.type) {
+				case "disable":
+				case "enable":
+					return [];
+
+				case "disable-line":
+					return [
+						{
+							type: "disable",
+							line: directive.line,
+							column: 1,
+							ruleId: directive.ruleId,
+							unprocessedDirective: directive,
+						},
+						{
+							type: "enable",
+							line: directive.line + 1,
+							column: 0,
+							ruleId: directive.ruleId,
+							unprocessedDirective: directive,
+						},
+					];
+
+				case "disable-next-line":
+					return [
+						{
+							type: "disable",
+							line: directive.line + 1,
+							column: 1,
+							ruleId: directive.ruleId,
+							unprocessedDirective: directive,
+						},
+						{
+							type: "enable",
+							line: directive.line + 2,
+							column: 0,
+							ruleId: directive.ruleId,
+							unprocessedDirective: directive,
+						},
+					];
+
+				default:
+					throw new TypeError(
+						`Unrecognized directive type '${directive.type}'`,
+					);
+			}
+		})
+		.sort(compareLocations);
+
+	// This determines a list of rules that are not being run by the given ruleFilter, if present.
+	const rulesToIgnore =
+		configuredRules && ruleFilter
+			? new Set(
+					Object.keys(configuredRules).filter(ruleId => {
+						const severity = ConfigOps.getRuleSeverity(
+							configuredRules[ruleId],
+						);
+
+						// Ignore for disabled rules.
+						if (severity === 0) {
+							return false;
+						}
+
+						return !ruleFilter({ severity, ruleId });
+					}),
+				)
+			: new Set();
+
+	// If no ruleId is supplied that means this directive is applied to all rules, so we can't determine if it's unused if any rules are filtered out.
+	if (rulesToIgnore.size > 0) {
+		rulesToIgnore.add(null);
+	}
+
+	const blockDirectivesResult = applyDirectives({
+		language,
+		sourceCode,
+		problems,
+		directives: blockDirectives,
+		disableFixes,
+		reportUnusedDisableDirectives,
+		rulesToIgnore,
+	});
+	const lineDirectivesResult = applyDirectives({
+		language,
+		sourceCode,
+		problems: blockDirectivesResult.problems,
+		directives: lineDirectives,
+		disableFixes,
+		reportUnusedDisableDirectives,
+		rulesToIgnore,
+	});
+
+	return reportUnusedDisableDirectives !== "off"
+		? lineDirectivesResult.problems
+				.concat(blockDirectivesResult.unusedDirectives)
+				.concat(lineDirectivesResult.unusedDirectives)
+				.sort(compareLocations)
+		: lineDirectivesResult.problems;
 };