Pull.

J'ai juste update le cutie.js, CONNARD
Ah oui, j'ai aussi add le info.js, qui est merdique d'ailleurs

node_modules/eslint/lib/rules/array-callback-return.js

@@ -233,7 +233,6 @@ module.exports = {
 			url: "https://eslint.org/docs/latest/rules/array-callback-return",
 		},
 
-		// eslint-disable-next-line eslint-plugin/require-meta-has-suggestions -- false positive
 		hasSuggestions: true,
 
 		schema: [

node_modules/eslint/lib/rules/dot-notation.js

@@ -15,7 +15,7 @@ const keywords = require("./utils/keywords");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/u;
+const validIdentifier = /^[a-zA-Z_$][\w$]*$/u;
 
 // `null` literal must be handled separately.
 const literalTypesToCheck = new Set(["string", "boolean"]);

node_modules/eslint/lib/rules/grouped-accessor-pairs.js

@@ -87,8 +87,6 @@ function isAccessorKind(node) {
 	return node.kind === "get" || node.kind === "set";
 }
 
-const DEFAULT_ORDER = "anyOrder";
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -98,7 +96,12 @@ module.exports = {
 	meta: {
 		type: "suggestion",
 
-		defaultOptions: [DEFAULT_ORDER],
+		defaultOptions: [
+			"anyOrder",
+			{
+				enforceForTSTypes: false,
+			},
+		],
 
 		docs: {
 			description:
@@ -129,10 +132,8 @@ module.exports = {
 	},
 
 	create(context) {
-		const order = context.options[0] ?? DEFAULT_ORDER;
-		const enforceForTSTypes =
-			context.options[1]?.enforceForTSTypes ?? false;
-		const sourceCode = context.sourceCode;
+		const [order, { enforceForTSTypes }] = context.options;
+		const { sourceCode } = context;
 
 		/**
 		 * Reports the given accessor pair.

node_modules/eslint/lib/rules/indent-legacy.js

@@ -1162,7 +1162,7 @@ module.exports = {
 		 * @returns {boolean} the result
 		 */
 		function isWrappedInParenthesis(node) {
-			const regex = /^return\s*?\(\s*?\);*?/u;
+			const regex = /^return\s*\(\s*\)/u;
 
 			const statementWithoutArgument = sourceCode
 				.getText(node)

node_modules/eslint/lib/rules/index.js

@@ -293,6 +293,7 @@ module.exports = new LazyLoadingRuleMap(
 		"prefer-rest-params": () => require("./prefer-rest-params"),
 		"prefer-spread": () => require("./prefer-spread"),
 		"prefer-template": () => require("./prefer-template"),
+		"preserve-caught-error": () => require("./preserve-caught-error"),
 		"quote-props": () => require("./quote-props"),
 		quotes: () => require("./quotes"),
 		radix: () => require("./radix"),

node_modules/eslint/lib/rules/no-alert.js

@@ -24,7 +24,7 @@ const {
  * @returns {boolean} Whether or not the name is prohibited.
  */
 function isProhibitedIdentifier(name) {
-	return /^(alert|confirm|prompt)$/u.test(name);
+	return /^(?:alert|confirm|prompt)$/u.test(name);
 }
 
 /**

node_modules/eslint/lib/rules/no-empty-function.js

@@ -105,6 +105,7 @@ module.exports = {
 	meta: {
 		dialects: ["javascript", "typescript"],
 		language: "javascript",
+		hasSuggestions: true,
 		type: "suggestion",
 
 		defaultOptions: [{ allow: [] }],
@@ -131,6 +132,7 @@ module.exports = {
 
 		messages: {
 			unexpected: "Unexpected empty {{name}}.",
+			suggestComment: "Add comment inside empty {{name}}.",
 		},
 	},
 
@@ -162,7 +164,7 @@ module.exports = {
 				}
 			}
 
-			if (/(g|s)etters|methods$/iu.test(kind)) {
+			if (/(?:g|s)etters|methods$/iu.test(kind)) {
 				if (
 					(node.parent.decorators?.length &&
 						allow.includes("decoratedFunctions")) ||
@@ -204,6 +206,23 @@ module.exports = {
 					loc: node.body.loc,
 					messageId: "unexpected",
 					data: { name },
+					suggest: [
+						{
+							messageId: "suggestComment",
+							data: { name },
+							fix(fixer) {
+								const range = [
+									node.body.range[0] + 1,
+									node.body.range[1] - 1,
+								];
+
+								return fixer.replaceTextRange(
+									range,
+									" /* empty */ ",
+								);
+							},
+						},
+					],
 				});
 			}
 		}

node_modules/eslint/lib/rules/no-empty-static-block.js

@@ -11,6 +11,7 @@
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		hasSuggestions: true,
 		type: "suggestion",
 
 		docs: {
@@ -23,6 +24,7 @@ module.exports = {
 
 		messages: {
 			unexpected: "Unexpected empty static block.",
+			suggestComment: "Add comment inside empty static block.",
 		},
 	},
 
@@ -32,14 +34,36 @@ module.exports = {
 		return {
 			StaticBlock(node) {
 				if (node.body.length === 0) {
+					const openingBrace = sourceCode.getFirstToken(node, {
+						skip: 1,
+					});
 					const closingBrace = sourceCode.getLastToken(node);
 
 					if (
 						sourceCode.getCommentsBefore(closingBrace).length === 0
 					) {
 						context.report({
-							node,
+							loc: {
+								start: openingBrace.loc.start,
+								end: closingBrace.loc.end,
+							},
 							messageId: "unexpected",
+							suggest: [
+								{
+									messageId: "suggestComment",
+									fix(fixer) {
+										const range = [
+											openingBrace.range[1],
+											closingBrace.range[0],
+										];
+
+										return fixer.replaceTextRange(
+											range,
+											" /* empty */ ",
+										);
+									},
+								},
+							],
 						});
 					}
 				}

node_modules/eslint/lib/rules/no-empty.js

@@ -104,10 +104,47 @@ module.exports = {
 					typeof node.cases === "undefined" ||
 					node.cases.length === 0
 				) {
+					const openingBrace = sourceCode.getTokenAfter(
+						node.discriminant,
+						astUtils.isOpeningBraceToken,
+					);
+
+					const closingBrace = sourceCode.getLastToken(node);
+
+					if (
+						sourceCode.commentsExistBetween(
+							openingBrace,
+							closingBrace,
+						)
+					) {
+						return;
+					}
+
 					context.report({
 						node,
+						loc: {
+							start: openingBrace.loc.start,
+							end: closingBrace.loc.end,
+						},
 						messageId: "unexpected",
 						data: { type: "switch" },
+						suggest: [
+							{
+								messageId: "suggestComment",
+								data: { type: "switch" },
+								fix(fixer) {
+									const range = [
+										openingBrace.range[1],
+										closingBrace.range[0],
+									];
+
+									return fixer.replaceTextRange(
+										range,
+										" /* empty */ ",
+									);
+								},
+							},
+						],
 					});
 				}
 			},

node_modules/eslint/lib/rules/no-eval.js

@@ -226,7 +226,9 @@ module.exports = {
 
 			Program(node) {
 				const scope = sourceCode.getScope(node),
-					features = context.parserOptions.ecmaFeatures || {},
+					features =
+						context.languageOptions.parserOptions.ecmaFeatures ||
+						{},
 					strict =
 						scope.isStrict ||
 						node.sourceType === "module" ||

node_modules/eslint/lib/rules/no-irregular-whitespace.js

@@ -19,8 +19,8 @@ const astUtils = require("./utils/ast-utils");
 const ALL_IRREGULARS =
 	/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/u;
 const IRREGULAR_WHITESPACE =
-	/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/gmu;
-const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/gmu;
+	/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/gu;
+const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/gu;
 const LINE_BREAK = astUtils.createGlobalLinebreakMatcher();
 
 //------------------------------------------------------------------------------

node_modules/eslint/lib/rules/no-loss-of-precision.js

@@ -189,9 +189,32 @@ module.exports = {
 		 * @returns {boolean} true if they do not match
 		 */
 		function baseTenLosesPrecision(node) {
-			const normalizedRawNumber = convertNumberToScientificNotation(
-				getRaw(node),
-			);
+			const rawNumber = getRaw(node).toLowerCase();
+
+			/*
+			 * If trailing zeros equal the exponent, this is a valid representation
+			 * like "9.00e2" where 00 = 2 (meaning 9.00 * 10^2 = 900)
+			 * https://github.com/eslint/eslint/issues/19957
+			 */
+			if (rawNumber.includes(".") && rawNumber.includes("e")) {
+				const parts = rawNumber.split("e");
+				const coefficient = parts[0];
+				const exponent = parseInt(parts[1], 10);
+
+				// Count trailing zeros after decimal
+				const decimalParts = coefficient.split(".");
+				if (decimalParts.length === 2) {
+					const decimalPart = decimalParts[1];
+					const trailingZeros = decimalPart.match(/0*$/u)[0].length;
+
+					if (trailingZeros === exponent) {
+						return false;
+					}
+				}
+			}
+
+			const normalizedRawNumber =
+				convertNumberToScientificNotation(rawNumber);
 			const requestedPrecision = normalizedRawNumber
 				.split("e")[0]
 				.replace(".", "").length;

node_modules/eslint/lib/rules/no-misleading-character-class.js

@@ -278,6 +278,12 @@ module.exports = {
 	meta: {
 		type: "problem",
 
+		defaultOptions: [
+			{
+				allowEscape: false,
+			},
+		],
+
 		docs: {
 			description:
 				"Disallow characters which are made with multiple code points in character class syntax",
@@ -293,7 +299,6 @@ module.exports = {
 				properties: {
 					allowEscape: {
 						type: "boolean",
-						default: false,
 					},
 				},
 				additionalProperties: false,
@@ -313,7 +318,7 @@ module.exports = {
 		},
 	},
 	create(context) {
-		const allowEscape = context.options[0]?.allowEscape;
+		const [{ allowEscape }] = context.options;
 		const sourceCode = context.sourceCode;
 		const parser = new RegExpParser();
 		const checkedPatternNodes = new Set();

node_modules/eslint/lib/rules/no-mixed-spaces-and-tabs.js

@@ -99,6 +99,7 @@ module.exports = {
 					 * At least one space followed by a tab
 					 * before non-tab/-space characters begin.
 					 */
+					// eslint-disable-next-line regexp/no-empty-lookarounds-assertion -- False positive
 					regex = /^(?=(\t*))\1(?=( +))\2\t/u;
 				}
 

node_modules/eslint/lib/rules/no-octal.js

@@ -30,10 +30,7 @@ module.exports = {
 	create(context) {
 		return {
 			Literal(node) {
-				if (
-					typeof node.value === "number" &&
-					/^0[0-9]/u.test(node.raw)
-				) {
+				if (typeof node.value === "number" && /^0\d/u.test(node.raw)) {
 					context.report({
 						node,
 						messageId: "noOctal",

node_modules/eslint/lib/rules/no-trailing-spaces.js

@@ -82,7 +82,8 @@ module.exports = {
 	create(context) {
 		const sourceCode = context.sourceCode;
 
-		const BLANK_CLASS = "[ \t\u00a0\u2000-\u200b\u3000]",
+		const BLANK_CLASS =
+				"[ \t\u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u3000]",
 			SKIP_BLANK = `^${BLANK_CLASS}*$`,
 			NONBLANK = `${BLANK_CLASS}+$`;
 

node_modules/eslint/lib/rules/no-useless-escape.js

@@ -387,7 +387,7 @@ module.exports = {
 				const value = isTemplateElement
 					? sourceCode.getText(node)
 					: node.raw;
-				const pattern = /\\[^\d]/gu;
+				const pattern = /\\\D/gu;
 				let match;
 
 				while ((match = pattern.exec(value))) {

node_modules/eslint/lib/rules/prefer-regex-literals.js

@@ -522,7 +522,7 @@ module.exports = {
 						}
 
 						if (
-							!/^[-a-zA-Z0-9\\[\](){} \t\r\n\v\f!@#$%^&*+^_=/~`.><?,'"|:;]*$/u.test(
+							!/^[-\w\\[\](){} \t\r\n\v\f!@#$%^&*+=/~`.><?,'"|:;]*$/u.test(
 								regexContent,
 							)
 						) {

node_modules/eslint/lib/rules/preserve-caught-error.js

@@ -0,0 +1,539 @@
+/**
+ * @fileoverview Rule to preserve caught errors when re-throwing exceptions
+ * @author Amnish Singh Arora
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Types
+//------------------------------------------------------------------------------
+
+/** @typedef {import("estree").Node} ASTNode */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/*
+ * This is an indicator of an error cause node, that is too complicated to be detected and fixed.
+ * Eg, when error options is an `Identifier` or a `SpreadElement`.
+ */
+const UNKNOWN_CAUSE = Symbol("unknown_cause");
+
+const BUILT_IN_ERROR_TYPES = new Set([
+	"Error",
+	"EvalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError",
+	"AggregateError",
+]);
+
+/**
+ * Finds and returns information about the `cause` property of an error being thrown.
+ * @param {ASTNode} throwStatement `ThrowStatement` to be checked.
+ * @returns {{ value: ASTNode; multipleDefinitions: boolean; } | UNKNOWN_CAUSE | null}
+ * Information about the `cause` of the error being thrown, such as the value node and
+ * whether there are multiple definitions of `cause`. `null` if there is no `cause`.
+ */
+function getErrorCause(throwStatement) {
+	const throwExpression = throwStatement.argument;
+	/*
+	 * Determine which argument index holds the options object
+	 * `AggregateError` is a special case as it accepts the `options` object as third argument.
+	 */
+	const optionsIndex =
+		throwExpression.callee.name === "AggregateError" ? 2 : 1;
+
+	/*
+	 * Make sure there is no `SpreadElement` at or before the `optionsIndex`
+	 * as this messes up the effective order of arguments and makes it complicated
+	 * to track where the actual error options need to be at
+	 */
+	const spreadExpressionIndex = throwExpression.arguments.findIndex(
+		arg => arg.type === "SpreadElement",
+	);
+	if (spreadExpressionIndex >= 0 && spreadExpressionIndex <= optionsIndex) {
+		return UNKNOWN_CAUSE;
+	}
+
+	const errorOptions = throwExpression.arguments[optionsIndex];
+
+	if (errorOptions) {
+		if (errorOptions.type === "ObjectExpression") {
+			if (
+				errorOptions.properties.some(
+					prop => prop.type === "SpreadElement",
+				)
+			) {
+				/*
+				 * If there is a spread element as part of error options, it is too complicated
+				 * to verify if the cause is used properly and auto-fix.
+				 */
+				return UNKNOWN_CAUSE;
+			}
+
+			const causeProperties = errorOptions.properties.filter(
+				prop =>
+					prop.type === "Property" &&
+					prop.key.type === "Identifier" &&
+					prop.key.name === "cause" &&
+					!prop.computed, // It is hard to accurately identify the value of computed props
+			);
+
+			const causeProperty = causeProperties.at(-1);
+			return causeProperty
+				? {
+						value: causeProperty.value,
+						multipleDefinitions: causeProperties.length > 1,
+					}
+				: null;
+		}
+
+		// Error options exist, but too complicated to be analyzed/fixed
+		return UNKNOWN_CAUSE;
+	}
+
+	return null;
+}
+
+/**
+ * Finds and returns the `CatchClause` node, that the `node` is part of.
+ * @param {ASTNode} node The AST node to be evaluated.
+ * @returns {ASTNode | null } The closest parent `CatchClause` node, `null` if the `node` is not in a catch block.
+ */
+function findParentCatch(node) {
+	let currentNode = node;
+
+	while (currentNode && currentNode.type !== "CatchClause") {
+		if (
+			[
+				"FunctionDeclaration",
+				"FunctionExpression",
+				"ArrowFunctionExpression",
+				"StaticBlock",
+			].includes(currentNode.type)
+		) {
+			/*
+			 * Make sure the ThrowStatement is not made inside a function definition or a static block inside a high level catch.
+			 * In such cases, the caught error is not directly related to the Throw.
+			 *
+			 * For example,
+			 * try {
+			 * } catch (error) {
+			 * 	foo = {
+			 * 		bar() {
+			 *	 	throw new Error();
+			 * 	  }
+			 * };
+			 * }
+			 */
+			return null;
+		}
+		currentNode = currentNode.parent;
+	}
+
+	return currentNode;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				requireCatchParameter: false,
+			},
+		],
+
+		docs: {
+			description:
+				"Disallow losing originally caught error when re-throwing custom errors",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/preserve-caught-error", // URL to the documentation page for this rule
+		},
+		/*
+		 * TODO: We should allow passing `customErrorTypes` option once something like `typescript-eslint`'s
+		 * 		`TypeOrValueSpecifier` is implemented in core Eslint.
+		 *      See:
+		 * 		1. https://typescript-eslint.io/packages/type-utils/type-or-value-specifier/
+		 *      2. https://github.com/eslint/eslint/pull/19913#discussion_r2192608593
+		 *      3. https://github.com/eslint/eslint/discussions/16540
+		 */
+		schema: [
+			{
+				type: "object",
+				properties: {
+					requireCatchParameter: {
+						type: "boolean",
+						description:
+							"Requires the catch blocks to always have the caught error parameter so it is not discarded.",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		messages: {
+			missingCause:
+				"There is no `cause` attached to the symptom error being thrown.",
+			incorrectCause:
+				"The symptom error is being thrown with an incorrect `cause`.",
+			includeCause:
+				"Include the original caught error as the `cause` of the symptom error.",
+			missingCatchErrorParam:
+				"The caught error is not accessible because the catch clause lacks the error parameter. Start referencing the caught error using the catch parameter.",
+			partiallyLostError:
+				"Re-throws cannot preserve the caught error as a part of it is being lost due to destructuring.",
+			caughtErrorShadowed:
+				"The caught error is being attached as `cause`, but is shadowed by a closer scoped redeclaration.",
+		},
+		hasSuggestions: true,
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const [{ requireCatchParameter }] = context.options;
+
+		//----------------------------------------------------------------------
+		// Helpers
+		//----------------------------------------------------------------------
+
+		/**
+		 * Checks if a `ThrowStatement` is constructing and throwing a new `Error` object.
+		 *
+		 * Covers all the error types on `globalThis` that support `cause` property:
+		 * https://github.com/microsoft/TypeScript/blob/main/src/lib/es2022.error.d.ts
+		 * @param {ASTNode} throwStatement The `ThrowStatement` that needs to be checked.
+		 * @returns {boolean} `true` if a new "Error" is being thrown, else `false`.
+		 */
+		function isThrowingNewError(throwStatement) {
+			return (
+				(throwStatement.argument.type === "NewExpression" ||
+					throwStatement.argument.type === "CallExpression") &&
+				throwStatement.argument.callee.type === "Identifier" &&
+				BUILT_IN_ERROR_TYPES.has(throwStatement.argument.callee.name) &&
+				/*
+				 * Make sure the thrown Error is instance is one of the built-in global error types.
+				 * Custom imports could shadow this, which would lead to false positives.
+				 * e.g. import { Error } from "./my-custom-error.js";
+				 *      throw Error("Failed to perform error prone operations");
+				 */
+				sourceCode.isGlobalReference(throwStatement.argument.callee)
+			);
+		}
+
+		/**
+		 * Inserts `cause: <caughtErrorName>` into an inline options object expression.
+		 * @param {RuleFixer} fixer The fixer object.
+		 * @param {ASTNode} optionsNode The options object node.
+		 * @param {string} caughtErrorName The name of the caught error (e.g., "err").
+		 * @returns {Fix} The fix object.
+		 */
+		function insertCauseIntoOptions(fixer, optionsNode, caughtErrorName) {
+			const properties = optionsNode.properties;
+
+			if (properties.length === 0) {
+				// Insert inside empty braces: `{}` → `{ cause: err }`
+				return fixer.insertTextAfter(
+					sourceCode.getFirstToken(optionsNode),
+					`cause: ${caughtErrorName}`,
+				);
+			}
+
+			const lastProp = properties.at(-1);
+			return fixer.insertTextAfter(
+				lastProp,
+				`, cause: ${caughtErrorName}`,
+			);
+		}
+
+		//----------------------------------------------------------------------
+		// Public
+		//----------------------------------------------------------------------
+		return {
+			ThrowStatement(node) {
+				// Check if the throw is inside a catch block
+				const parentCatch = findParentCatch(node);
+				const throwStatement = node;
+
+				// Check if a new error is being thrown in a catch block
+				if (parentCatch && isThrowingNewError(throwStatement)) {
+					if (
+						parentCatch.param &&
+						parentCatch.param.type !== "Identifier"
+					) {
+						/*
+						 * When a part of the caught error is being lost at the parameter level, commonly due to destructuring.
+						 * e.g. catch({ message, ...rest })
+						 */
+						context.report({
+							messageId: "partiallyLostError",
+							node: parentCatch,
+						});
+						return;
+					}
+
+					const caughtError =
+						parentCatch.param?.type === "Identifier"
+							? parentCatch.param
+							: null;
+
+					// Check if there are throw statements and caught error is being ignored
+					if (!caughtError) {
+						if (requireCatchParameter) {
+							context.report({
+								node: throwStatement,
+								messageId: "missingCatchErrorParam",
+							});
+							return;
+						}
+						return;
+					}
+
+					// Check if there is a cause attached to the new error
+					const errorCauseInfo = getErrorCause(throwStatement);
+
+					if (errorCauseInfo === UNKNOWN_CAUSE) {
+						// Error options exist, but too complicated to be analyzed/fixed
+						return;
+					}
+
+					if (errorCauseInfo === null) {
+						// If there is no `cause` attached to the error being thrown.
+						context.report({
+							messageId: "missingCause",
+							node: throwStatement,
+							suggest: [
+								{
+									messageId: "includeCause",
+									fix(fixer) {
+										const throwExpression =
+											throwStatement.argument;
+										const args = throwExpression.arguments;
+										const errorType =
+											throwExpression.callee.name;
+
+										// AggregateError: errors, message, options
+										if (errorType === "AggregateError") {
+											const errorsArg = args[0];
+											const messageArg = args[1];
+											const optionsArg = args[2];
+
+											if (!errorsArg) {
+												// Case: `throw new AggregateError()` → insert all arguments
+												const lastToken =
+													sourceCode.getLastToken(
+														throwExpression,
+													);
+												const lastCalleeToken =
+													sourceCode.getLastToken(
+														throwExpression.callee,
+													);
+												const parenToken =
+													sourceCode.getFirstTokenBetween(
+														lastCalleeToken,
+														lastToken,
+														astUtils.isOpeningParenToken,
+													);
+
+												if (parenToken) {
+													return fixer.insertTextAfter(
+														parenToken,
+														`[], "", { cause: ${caughtError.name} }`,
+													);
+												}
+												return fixer.insertTextAfter(
+													throwExpression.callee,
+													`([], "", { cause: ${caughtError.name} })`,
+												);
+											}
+
+											if (!messageArg) {
+												// Case: `throw new AggregateError([])` → insert message and options
+												return fixer.insertTextAfter(
+													errorsArg,
+													`, "", { cause: ${caughtError.name} }`,
+												);
+											}
+
+											if (!optionsArg) {
+												// Case: `throw new AggregateError([], "")` → insert error options only
+												return fixer.insertTextAfter(
+													messageArg,
+													`, { cause: ${caughtError.name} }`,
+												);
+											}
+
+											if (
+												optionsArg.type ===
+												"ObjectExpression"
+											) {
+												return insertCauseIntoOptions(
+													fixer,
+													optionsArg,
+													caughtError.name,
+												);
+											}
+
+											// Complex dynamic options — skip
+											return null;
+										}
+
+										// Normal Error types
+										const messageArg = args[0];
+										const optionsArg = args[1];
+
+										if (!messageArg) {
+											// Case: `throw new Error()` → insert both message and options
+											const lastToken =
+												sourceCode.getLastToken(
+													throwExpression,
+												);
+											const lastCalleeToken =
+												sourceCode.getLastToken(
+													throwExpression.callee,
+												);
+											const parenToken =
+												sourceCode.getFirstTokenBetween(
+													lastCalleeToken,
+													lastToken,
+													astUtils.isOpeningParenToken,
+												);
+
+											if (parenToken) {
+												return fixer.insertTextAfter(
+													parenToken,
+													`"", { cause: ${caughtError.name} }`,
+												);
+											}
+											return fixer.insertTextAfter(
+												throwExpression.callee,
+												`("", { cause: ${caughtError.name} })`,
+											);
+										}
+										if (!optionsArg) {
+											// Case: `throw new Error("Some message")` → insert only options
+											return fixer.insertTextAfter(
+												messageArg,
+												`, { cause: ${caughtError.name} }`,
+											);
+										}
+
+										if (
+											optionsArg.type ===
+											"ObjectExpression"
+										) {
+											return insertCauseIntoOptions(
+												fixer,
+												optionsArg,
+												caughtError.name,
+											);
+										}
+
+										return null; // Identifier or spread — do not fix
+									},
+								},
+							],
+						});
+
+						// We don't need to check further
+						return;
+					}
+
+					const { value: thrownErrorCause } = errorCauseInfo;
+
+					// If there is an attached cause, verify that it matches the caught error
+					if (
+						!(
+							thrownErrorCause.type === "Identifier" &&
+							thrownErrorCause.name === caughtError.name
+						)
+					) {
+						const suggest = errorCauseInfo.multipleDefinitions
+							? null // If there are multiple `cause` definitions, a suggestion could be confusing.
+							: [
+									{
+										messageId: "includeCause",
+										fix(fixer) {
+											/*
+											 * In case `cause` is attached using object property shorthand or as a method or accessor.
+											 * e.g. throw Error("fail", { cause });
+											 *      throw Error("fail", { cause() { doSomething(); } });
+											 *      throw Error("fail", { get cause() { return error; } });
+											 */
+											if (
+												thrownErrorCause.parent
+													.method ||
+												thrownErrorCause.parent
+													.shorthand ||
+												thrownErrorCause.parent.kind !==
+													"init"
+											) {
+												return fixer.replaceText(
+													thrownErrorCause.parent,
+													`cause: ${caughtError.name}`,
+												);
+											}
+
+											return fixer.replaceText(
+												thrownErrorCause,
+												caughtError.name,
+											);
+										},
+									},
+								];
+						context.report({
+							messageId: "incorrectCause",
+							node: thrownErrorCause,
+							suggest,
+						});
+						return;
+					}
+
+					/*
+					 * If the attached cause matches the identifier name of the caught error,
+					 * make sure it is not being shadowed by a closer scoped redeclaration.
+					 *
+					 * e.g. try {
+					 *      doSomething();
+					 * 	  } catch (error) {
+					 * 	     if (whatever) {
+					 * 	       const error = anotherError;
+					 * 	       throw new Error("Something went wrong");
+					 * 	     }
+					 *   }
+					 */
+					let scope = sourceCode.getScope(throwStatement);
+					do {
+						const variable = scope.set.get(caughtError.name);
+						if (variable) {
+							break;
+						}
+						scope = scope.upper;
+					} while (scope);
+
+					if (scope?.block !== parentCatch) {
+						// Caught error is being shadowed
+						context.report({
+							messageId: "caughtErrorShadowed",
+							node: throwStatement,
+						});
+					}
+				}
+			},
+		};
+	},
+};

node_modules/eslint/lib/rules/require-unicode-regexp.js

@@ -47,6 +47,8 @@ module.exports = {
 	meta: {
 		type: "suggestion",
 
+		defaultOptions: [{}],
+
 		docs: {
 			description:
 				"Enforce the use of `u` or `v` flag on regular expressions",
@@ -79,7 +81,7 @@ module.exports = {
 	create(context) {
 		const sourceCode = context.sourceCode;
 
-		const { requireFlag } = context.options[0] ?? {};
+		const [{ requireFlag }] = context.options;
 
 		return {
 			"Literal[regex]"(node) {

node_modules/eslint/lib/rules/strict.js

@@ -101,7 +101,8 @@ module.exports = {
 	},
 
 	create(context) {
-		const ecmaFeatures = context.parserOptions.ecmaFeatures || {},
+		const ecmaFeatures =
+				context.languageOptions.parserOptions.ecmaFeatures || {},
 			scopes = [],
 			classScopes = [];
 		let [mode] = context.options;

node_modules/eslint/lib/rules/utils/ast-utils.js

@@ -58,7 +58,7 @@ const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u;
 
 // Tests the presence of at least one LegacyOctalEscapeSequence or NonOctalDecimalEscapeSequence in a raw string
 const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN =
-	/^(?:[^\\]|\\.)*\\(?:[1-9]|0[0-9])/su;
+	/^(?:[^\\]|\\.)*\\(?:[1-9]|0\d)/su;
 
 const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]);
 

node_modules/eslint/lib/rules/utils/char-source.js

@@ -85,7 +85,7 @@ function readHexSequence(reader, length) {
  * @returns {string} A code unit.
  */
 function readUnicodeSequence(reader) {
-	const regExp = /\{(?<hexDigits>[\dA-Fa-f]+)\}/uy;
+	const regExp = /\{(?<hexDigits>[\dA-F]+)\}/iuy;
 
 	regExp.lastIndex = reader.pos;
 	const match = regExp.exec(reader.source);

node_modules/eslint/lib/rules/yoda.js

@@ -20,7 +20,7 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} Whether or not it is a comparison operator.
  */
 function isComparisonOperator(operator) {
-	return /^(==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
+	return /^(?:==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
 }
 
 /**
@@ -29,7 +29,7 @@ function isComparisonOperator(operator) {
  * @returns {boolean} Whether or not it is an equality operator.
  */
 function isEqualityOperator(operator) {
-	return /^(==|===)$/u.test(operator);
+	return /^(?:==|===)$/u.test(operator);
 }
 
 /**