oxlint-plugin-eslint 1.52.0

package/rules/computed-property-spacing.cjs

@@ -0,0 +1,155 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/computed-property-spacing.js
+/**
+* @fileoverview Disallows or enforces spaces inside computed properties.
+* @author Jamund Ferguson
+* @deprecated in ESLint v8.53.0
+*/
+var require_computed_property_spacing = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "8.53.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "computed-property-spacing",
+						url: "https://eslint.style/rules/computed-property-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing inside computed property brackets",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/computed-property-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["always", "never"] }, {
+				type: "object",
+				properties: { enforceForClassMembers: {
+					type: "boolean",
+					default: !0
+				} },
+				additionalProperties: !1
+			}],
+			messages: {
+				unexpectedSpaceBefore: "There should be no space before '{{tokenValue}}'.",
+				unexpectedSpaceAfter: "There should be no space after '{{tokenValue}}'.",
+				missingSpaceBefore: "A space is required before '{{tokenValue}}'.",
+				missingSpaceAfter: "A space is required after '{{tokenValue}}'."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, propertyNameMustBeSpaced = context.options[0] === "always", enforceForClassMembers = !context.options[1] || context.options[1].enforceForClassMembers;
+			/**
+			* Reports that there shouldn't be a space after the first token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @param {Token} tokenAfter The token after `token`.
+			* @returns {void}
+			*/
+			function reportNoBeginningSpace(node, token, tokenAfter) {
+				context.report({
+					node,
+					loc: {
+						start: token.loc.end,
+						end: tokenAfter.loc.start
+					},
+					messageId: "unexpectedSpaceAfter",
+					data: { tokenValue: token.value },
+					fix(fixer) {
+						return fixer.removeRange([token.range[1], tokenAfter.range[0]]);
+					}
+				});
+			}
+			/**
+			* Reports that there shouldn't be a space before the last token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @param {Token} tokenBefore The token before `token`.
+			* @returns {void}
+			*/
+			function reportNoEndingSpace(node, token, tokenBefore) {
+				context.report({
+					node,
+					loc: {
+						start: tokenBefore.loc.end,
+						end: token.loc.start
+					},
+					messageId: "unexpectedSpaceBefore",
+					data: { tokenValue: token.value },
+					fix(fixer) {
+						return fixer.removeRange([tokenBefore.range[1], token.range[0]]);
+					}
+				});
+			}
+			/**
+			* Reports that there should be a space after the first token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportRequiredBeginningSpace(node, token) {
+				context.report({
+					node,
+					loc: token.loc,
+					messageId: "missingSpaceAfter",
+					data: { tokenValue: token.value },
+					fix(fixer) {
+						return fixer.insertTextAfter(token, " ");
+					}
+				});
+			}
+			/**
+			* Reports that there should be a space before the last token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportRequiredEndingSpace(node, token) {
+				context.report({
+					node,
+					loc: token.loc,
+					messageId: "missingSpaceBefore",
+					data: { tokenValue: token.value },
+					fix(fixer) {
+						return fixer.insertTextBefore(token, " ");
+					}
+				});
+			}
+			/**
+			* Returns a function that checks the spacing of a node on the property name
+			* that was passed in.
+			* @param {string} propertyName The property on the node to check for spacing
+			* @returns {Function} A function that will check spacing on a node
+			*/
+			function checkSpacing(propertyName) {
+				return function(node) {
+					if (!node.computed) return;
+					let property = node[propertyName], before = sourceCode.getTokenBefore(property, astUtils.isOpeningBracketToken), first = sourceCode.getTokenAfter(before, { includeComments: !0 }), after = sourceCode.getTokenAfter(property, astUtils.isClosingBracketToken), last = sourceCode.getTokenBefore(after, { includeComments: !0 });
+					astUtils.isTokenOnSameLine(before, first) && (propertyNameMustBeSpaced ? !sourceCode.isSpaceBetweenTokens(before, first) && astUtils.isTokenOnSameLine(before, first) && reportRequiredBeginningSpace(node, before) : sourceCode.isSpaceBetweenTokens(before, first) && reportNoBeginningSpace(node, before, first)), astUtils.isTokenOnSameLine(last, after) && (propertyNameMustBeSpaced ? !sourceCode.isSpaceBetweenTokens(last, after) && astUtils.isTokenOnSameLine(last, after) && reportRequiredEndingSpace(node, after) : sourceCode.isSpaceBetweenTokens(last, after) && reportNoEndingSpace(node, after, last));
+				};
+			}
+			let listeners = {
+				Property: checkSpacing("key"),
+				MemberExpression: checkSpacing("property")
+			};
+			return enforceForClassMembers && (listeners.MethodDefinition = listeners.PropertyDefinition = listeners.Property), listeners;
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/computed-property-spacing.cjs
+module.exports = require_computed_property_spacing().create;
+//#endregion

package/rules/consistent-return.cjs

@@ -0,0 +1,113 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_string_utils$1 = require("../common/string-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/consistent-return.js
+/**
+* @fileoverview Rule to flag consistent return values
+* @author Nicholas C. Zakas
+*/
+var require_consistent_return = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), { upperCaseFirst } = require_string_utils$1.t();
+	/**
+	* Checks all segments in a set and returns true if all are unreachable.
+	* @param {Set<CodePathSegment>} segments The segments to check.
+	* @returns {boolean} True if all segments are unreachable; false otherwise.
+	*/
+	function areAllSegmentsUnreachable(segments) {
+		for (let segment of segments) if (segment.reachable) return !1;
+		return !0;
+	}
+	/**
+	* Checks whether a given node is a `constructor` method in an ES6 class
+	* @param {ASTNode} node A node to check
+	* @returns {boolean} `true` if the node is a `constructor` method
+	*/
+	function isClassConstructor(node) {
+		return node.type === "FunctionExpression" && node.parent && node.parent.type === "MethodDefinition" && node.parent.kind === "constructor";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require `return` statements to either always or never specify values",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/consistent-return"
+			},
+			schema: [{
+				type: "object",
+				properties: { treatUndefinedAsUnspecified: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			defaultOptions: [{ treatUndefinedAsUnspecified: !1 }],
+			messages: {
+				missingReturn: "Expected to return a value at the end of {{name}}.",
+				missingReturnValue: "{{name}} expected a return value.",
+				unexpectedReturnValue: "{{name}} expected no return value."
+			}
+		},
+		create(context) {
+			let [{ treatUndefinedAsUnspecified }] = context.options, funcInfo = null;
+			/**
+			* Checks whether of not the implicit returning is consistent if the last
+			* code path segment is reachable.
+			* @param {ASTNode} node A program/function node to check.
+			* @returns {void}
+			*/
+			function checkLastSegment(node) {
+				let loc, name;
+				!funcInfo.hasReturnValue || areAllSegmentsUnreachable(funcInfo.currentSegments) || astUtils.isES5Constructor(node) || isClassConstructor(node) || (node.type === "Program" ? (loc = {
+					line: 1,
+					column: 0
+				}, name = "program") : loc = node.type === "ArrowFunctionExpression" ? context.sourceCode.getTokenBefore(node.body, astUtils.isArrowToken).loc : node.parent.type === "MethodDefinition" || node.parent.type === "Property" && node.parent.method ? node.parent.key.loc : (node.id || context.sourceCode.getFirstToken(node)).loc, name ||= astUtils.getFunctionNameWithKind(node), context.report({
+					node,
+					loc,
+					messageId: "missingReturn",
+					data: { name }
+				}));
+			}
+			return {
+				onCodePathStart(codePath, node) {
+					funcInfo = {
+						upper: funcInfo,
+						codePath,
+						hasReturn: !1,
+						hasReturnValue: !1,
+						messageId: "",
+						node,
+						currentSegments: /* @__PURE__ */ new Set()
+					};
+				},
+				onCodePathEnd() {
+					funcInfo = funcInfo.upper;
+				},
+				onUnreachableCodePathSegmentStart(segment) {
+					funcInfo.currentSegments.add(segment);
+				},
+				onUnreachableCodePathSegmentEnd(segment) {
+					funcInfo.currentSegments.delete(segment);
+				},
+				onCodePathSegmentStart(segment) {
+					funcInfo.currentSegments.add(segment);
+				},
+				onCodePathSegmentEnd(segment) {
+					funcInfo.currentSegments.delete(segment);
+				},
+				ReturnStatement(node) {
+					let argument = node.argument, hasReturnValue = !!argument;
+					treatUndefinedAsUnspecified && hasReturnValue && (hasReturnValue = !astUtils.isSpecificId(argument, "undefined") && argument.operator !== "void"), funcInfo.hasReturn ? funcInfo.hasReturnValue !== hasReturnValue && context.report({
+						node,
+						messageId: funcInfo.messageId,
+						data: funcInfo.data
+					}) : (funcInfo.hasReturn = !0, funcInfo.hasReturnValue = hasReturnValue, funcInfo.messageId = hasReturnValue ? "missingReturnValue" : "unexpectedReturnValue", funcInfo.data = { name: funcInfo.node.type === "Program" ? "Program" : upperCaseFirst(astUtils.getFunctionNameWithKind(funcInfo.node)) });
+				},
+				"Program:exit": checkLastSegment,
+				"FunctionDeclaration:exit": checkLastSegment,
+				"FunctionExpression:exit": checkLastSegment,
+				"ArrowFunctionExpression:exit": checkLastSegment
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/consistent-return.cjs
+module.exports = require_consistent_return().create;
+//#endregion

package/rules/consistent-this.cjs

@@ -0,0 +1,109 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/consistent-this.js
+/**
+* @fileoverview Rule to enforce consistent naming of "this" context variables
+* @author Raphael Pigulla
+*/
+var require_consistent_this = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce consistent naming when capturing the current execution context",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/consistent-this"
+			},
+			schema: {
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				uniqueItems: !0
+			},
+			defaultOptions: ["that"],
+			messages: {
+				aliasNotAssignedToThis: "Designated alias '{{name}}' is not assigned to 'this'.",
+				unexpectedAlias: "Unexpected alias '{{name}}' for 'this'."
+			}
+		},
+		create(context) {
+			let aliases = context.options, sourceCode = context.sourceCode;
+			/**
+			* Reports that a variable declarator or assignment expression is assigning
+			* a non-'this' value to the specified alias.
+			* @param {ASTNode} node The assigning node.
+			* @param {string} name the name of the alias that was incorrectly used.
+			* @returns {void}
+			*/
+			function reportBadAssignment(node, name) {
+				context.report({
+					node,
+					messageId: "aliasNotAssignedToThis",
+					data: { name }
+				});
+			}
+			/**
+			* Checks that an assignment to an identifier only assigns 'this' to the
+			* appropriate alias, and the alias is only assigned to 'this'.
+			* @param {ASTNode} node The assigning node.
+			* @param {Identifier} name The name of the variable assigned to.
+			* @param {Expression} value The value of the assignment.
+			* @returns {void}
+			*/
+			function checkAssignment(node, name, value) {
+				let isThis = value.type === "ThisExpression";
+				aliases.includes(name) ? (!isThis || node.operator && node.operator !== "=") && reportBadAssignment(node, name) : isThis && context.report({
+					node,
+					messageId: "unexpectedAlias",
+					data: { name }
+				});
+			}
+			/**
+			* Ensures that a variable declaration of the alias in a program or function
+			* is assigned to the correct value.
+			* @param {string} alias alias the check the assignment of.
+			* @param {Object} scope scope of the current code we are checking.
+			* @private
+			* @returns {void}
+			*/
+			function checkWasAssigned(alias, scope) {
+				let variable = scope.set.get(alias);
+				variable && (variable.defs.some((def) => def.node.type === "VariableDeclarator" && def.node.init !== null) || variable.references.some((reference) => {
+					let write = reference.writeExpr;
+					return reference.from === scope && write && write.type === "ThisExpression" && write.parent.operator === "=";
+				}) || variable.defs.map((def) => def.node).forEach((node) => {
+					reportBadAssignment(node, alias);
+				}));
+			}
+			/**
+			* Check each alias to ensure that is was assigned to the correct value.
+			* @param {ASTNode} node The node that represents the scope to check.
+			* @returns {void}
+			*/
+			function ensureWasAssigned(node) {
+				let scope = sourceCode.getScope(node), extraScope = node.type === "Program" && node.sourceType === "module" ? scope.childScopes[0] : null;
+				aliases.forEach((alias) => {
+					checkWasAssigned(alias, scope), extraScope && checkWasAssigned(alias, extraScope);
+				});
+			}
+			return {
+				"Program:exit": ensureWasAssigned,
+				"FunctionExpression:exit": ensureWasAssigned,
+				"FunctionDeclaration:exit": ensureWasAssigned,
+				VariableDeclarator(node) {
+					let id = node.id, isDestructuring = id.type === "ArrayPattern" || id.type === "ObjectPattern";
+					node.init !== null && !isDestructuring && checkAssignment(node, id.name, node.init);
+				},
+				AssignmentExpression(node) {
+					node.left.type === "Identifier" && checkAssignment(node, node.left.name, node.right);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/consistent-this.cjs
+module.exports = require_consistent_this().create;
+//#endregion

package/rules/constructor-super.cjs

@@ -0,0 +1,207 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/constructor-super.js
+/**
+* @fileoverview A rule to verify `super()` callings in constructor.
+* @author Toru Nagashima
+*/
+var require_constructor_super = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/**
+	* Checks whether or not a given node is a constructor.
+	* @param {ASTNode} node A node to check. This node type is one of
+	*   `Program`, `FunctionDeclaration`, `FunctionExpression`, and
+	*   `ArrowFunctionExpression`.
+	* @returns {boolean} `true` if the node is a constructor.
+	*/
+	function isConstructorFunction(node) {
+		return node.type === "FunctionExpression" && node.parent.type === "MethodDefinition" && node.parent.kind === "constructor";
+	}
+	/**
+	* Checks whether a given node can be a constructor or not.
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node can be a constructor.
+	*/
+	function isPossibleConstructor(node) {
+		if (!node) return !1;
+		switch (node.type) {
+			case "ClassExpression":
+			case "FunctionExpression":
+			case "ThisExpression":
+			case "MemberExpression":
+			case "CallExpression":
+			case "NewExpression":
+			case "ChainExpression":
+			case "YieldExpression":
+			case "TaggedTemplateExpression":
+			case "MetaProperty": return !0;
+			case "Identifier": return node.name !== "undefined";
+			case "AssignmentExpression":
+ /**
+			* All other assignment operators are mathematical assignment operators (arithmetic or bitwise).
+			* An assignment expression with a mathematical operator can either evaluate to a primitive value,
+			* or throw, depending on the operands. Thus, it cannot evaluate to a constructor function.
+			*/
+			return ["=", "&&="].includes(node.operator) ? isPossibleConstructor(node.right) : ["||=", "??="].includes(node.operator) ? isPossibleConstructor(node.left) || isPossibleConstructor(node.right) : !1;
+			case "LogicalExpression": return node.operator === "&&" ? isPossibleConstructor(node.right) : isPossibleConstructor(node.left) || isPossibleConstructor(node.right);
+			case "ConditionalExpression": return isPossibleConstructor(node.alternate) || isPossibleConstructor(node.consequent);
+			case "SequenceExpression": return isPossibleConstructor(node.expressions.at(-1));
+			default: return !1;
+		}
+	}
+	/**
+	* A class to store information about a code path segment.
+	*/
+	var SegmentInfo = class {
+		/**
+		* Indicates if super() is called in all code paths.
+		* @type {boolean}
+		*/
+		calledInEveryPaths = !1;
+		/**
+		* Indicates if super() is called in any code paths.
+		* @type {boolean}
+		*/
+		calledInSomePaths = !1;
+		/**
+		* The nodes which have been validated and don't need to be reconsidered.
+		* @type {ASTNode[]}
+		*/
+		validNodes = [];
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Require `super()` calls in constructors",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/constructor-super"
+			},
+			schema: [],
+			messages: {
+				missingSome: "Lacked a call of 'super()' in some code paths.",
+				missingAll: "Expected to call 'super()'.",
+				duplicate: "Unexpected duplicate 'super()'.",
+				badSuper: "Unexpected 'super()' because 'super' is not a constructor."
+			}
+		},
+		create(context) {
+			let funcInfo = null, segInfoMap = Object.create(null);
+			/**
+			* Gets the flag which shows `super()` is called in some paths.
+			* @param {CodePathSegment} segment A code path segment to get.
+			* @returns {boolean} The flag which shows `super()` is called in some paths
+			*/
+			function isCalledInSomePath(segment) {
+				return segment.reachable && segInfoMap[segment.id].calledInSomePaths;
+			}
+			/**
+			* Determines if a segment has been seen in the traversal.
+			* @param {CodePathSegment} segment A code path segment to check.
+			* @returns {boolean} `true` if the segment has been seen.
+			*/
+			function hasSegmentBeenSeen(segment) {
+				return !!segInfoMap[segment.id];
+			}
+			/**
+			* Gets the flag which shows `super()` is called in all paths.
+			* @param {CodePathSegment} segment A code path segment to get.
+			* @returns {boolean} The flag which shows `super()` is called in all paths.
+			*/
+			function isCalledInEveryPath(segment) {
+				return segment.reachable && segInfoMap[segment.id].calledInEveryPaths;
+			}
+			return {
+				onCodePathStart(codePath, node) {
+					if (isConstructorFunction(node)) {
+						let superClass = node.parent.parent.parent.superClass;
+						funcInfo = {
+							upper: funcInfo,
+							isConstructor: !0,
+							hasExtends: !!superClass,
+							superIsConstructor: isPossibleConstructor(superClass),
+							codePath,
+							currentSegments: /* @__PURE__ */ new Set()
+						};
+					} else funcInfo = {
+						upper: funcInfo,
+						isConstructor: !1,
+						hasExtends: !1,
+						superIsConstructor: !1,
+						codePath,
+						currentSegments: /* @__PURE__ */ new Set()
+					};
+				},
+				onCodePathEnd(codePath, node) {
+					let hasExtends = funcInfo.hasExtends;
+					if (funcInfo = funcInfo.upper, !hasExtends) return;
+					let returnedSegments = codePath.returnedSegments, calledInEveryPaths = returnedSegments.every(isCalledInEveryPath), calledInSomePaths = returnedSegments.some(isCalledInSomePath);
+					calledInEveryPaths || context.report({
+						messageId: calledInSomePaths ? "missingSome" : "missingAll",
+						node: node.parent
+					});
+				},
+				onCodePathSegmentStart(segment, node) {
+					if (funcInfo.currentSegments.add(segment), !(funcInfo.isConstructor && funcInfo.hasExtends)) return;
+					let info = segInfoMap[segment.id] = new SegmentInfo(), seenPrevSegments = segment.prevSegments.filter(hasSegmentBeenSeen);
+					seenPrevSegments.length > 0 && (info.calledInSomePaths = seenPrevSegments.some(isCalledInSomePath), info.calledInEveryPaths = seenPrevSegments.every(isCalledInEveryPath)), node.parent && node.parent.type === "ForStatement" && node.parent.update === node && (info.calledInEveryPaths = !0);
+				},
+				onUnreachableCodePathSegmentStart(segment) {
+					funcInfo.currentSegments.add(segment);
+				},
+				onUnreachableCodePathSegmentEnd(segment) {
+					funcInfo.currentSegments.delete(segment);
+				},
+				onCodePathSegmentEnd(segment) {
+					funcInfo.currentSegments.delete(segment);
+				},
+				onCodePathSegmentLoop(fromSegment, toSegment) {
+					funcInfo.isConstructor && funcInfo.hasExtends && funcInfo.codePath.traverseSegments({
+						first: toSegment,
+						last: fromSegment
+					}, (segment, controller) => {
+						let info = segInfoMap[segment.id];
+						if (!info) {
+							controller.skip();
+							return;
+						}
+						let seenPrevSegments = segment.prevSegments.filter(hasSegmentBeenSeen), calledInSomePreviousPaths = seenPrevSegments.some(isCalledInSomePath), calledInEveryPreviousPaths = seenPrevSegments.every(isCalledInEveryPath);
+						if (info.calledInSomePaths ||= calledInSomePreviousPaths, info.calledInEveryPaths ||= calledInEveryPreviousPaths, calledInSomePreviousPaths) {
+							let nodes = info.validNodes;
+							info.validNodes = [];
+							for (let i = 0; i < nodes.length; ++i) {
+								let node = nodes[i];
+								context.report({
+									messageId: "duplicate",
+									node
+								});
+							}
+						}
+					});
+				},
+				"CallExpression:exit"(node) {
+					if (!(funcInfo.isConstructor && funcInfo.hasExtends) || node.callee.type !== "Super") return;
+					let segments = funcInfo.currentSegments, duplicate = !1, info = null;
+					for (let segment of segments) segment.reachable && (info = segInfoMap[segment.id], duplicate ||= info.calledInSomePaths, info.calledInSomePaths = info.calledInEveryPaths = !0);
+					info && (duplicate ? context.report({
+						messageId: "duplicate",
+						node
+					}) : funcInfo.superIsConstructor ? info.validNodes.push(node) : context.report({
+						messageId: "badSuper",
+						node
+					}));
+				},
+				ReturnStatement(node) {
+					if (!(funcInfo.isConstructor && funcInfo.hasExtends) || !node.argument) return;
+					let segments = funcInfo.currentSegments;
+					for (let segment of segments) if (segment.reachable) {
+						let info = segInfoMap[segment.id];
+						info.calledInSomePaths = info.calledInEveryPaths = !0;
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/constructor-super.cjs
+module.exports = require_constructor_super().create;
+//#endregion