oxlint-plugin-eslint 1.52.0

package/rules/no-irregular-whitespace.cjs

@@ -0,0 +1,157 @@
+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/no-irregular-whitespace.js
+/**
+* @fileoverview Rule to disallow whitespace that is not a tab or space, whitespace inside strings and comments are allowed
+* @author Jonathan Kingston
+* @author Christophe Porteneuve
+*/
+var require_no_irregular_whitespace = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), 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, IRREGULAR_WHITESPACE = /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/gu, IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/gu, LINE_BREAK = astUtils.createGlobalLinebreakMatcher();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{
+				skipComments: !1,
+				skipJSXText: !1,
+				skipRegExps: !1,
+				skipStrings: !0,
+				skipTemplates: !1
+			}],
+			docs: {
+				description: "Disallow irregular whitespace",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-irregular-whitespace"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					skipComments: { type: "boolean" },
+					skipStrings: { type: "boolean" },
+					skipTemplates: { type: "boolean" },
+					skipRegExps: { type: "boolean" },
+					skipJSXText: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: { noIrregularWhitespace: "Irregular whitespace not allowed." }
+		},
+		create(context) {
+			let [{ skipComments, skipStrings, skipRegExps, skipTemplates, skipJSXText }] = context.options, sourceCode = context.sourceCode, commentNodes = sourceCode.getAllComments(), errors = [];
+			/**
+			* Removes errors that occur inside the given node
+			* @param {ASTNode} node to check for matching errors.
+			* @returns {void}
+			* @private
+			*/
+			function removeWhitespaceError(node) {
+				let locStart = node.loc.start, locEnd = node.loc.end;
+				errors = errors.filter(({ loc: { start: errorLocStart } }) => errorLocStart.line < locStart.line || errorLocStart.line === locStart.line && errorLocStart.column < locStart.column || errorLocStart.line === locEnd.line && errorLocStart.column >= locEnd.column || errorLocStart.line > locEnd.line);
+			}
+			/**
+			* Checks literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+			* @param {ASTNode} node to check for matching errors.
+			* @returns {void}
+			* @private
+			*/
+			function removeInvalidNodeErrorsInLiteral(node) {
+				let shouldCheckStrings = skipStrings && typeof node.value == "string", shouldCheckRegExps = skipRegExps && !!node.regex;
+				(shouldCheckStrings || shouldCheckRegExps) && ALL_IRREGULARS.test(node.raw) && removeWhitespaceError(node);
+			}
+			/**
+			* Checks template string literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+			* @param {ASTNode} node to check for matching errors.
+			* @returns {void}
+			* @private
+			*/
+			function removeInvalidNodeErrorsInTemplateLiteral(node) {
+				typeof node.value.raw == "string" && ALL_IRREGULARS.test(node.value.raw) && removeWhitespaceError(node);
+			}
+			/**
+			* Checks comment nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+			* @param {ASTNode} node to check for matching errors.
+			* @returns {void}
+			* @private
+			*/
+			function removeInvalidNodeErrorsInComment(node) {
+				ALL_IRREGULARS.test(node.value) && removeWhitespaceError(node);
+			}
+			/**
+			* Checks JSX nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+			* @param {ASTNode} node to check for matching errors.
+			* @returns {void}
+			* @private
+			*/
+			function removeInvalidNodeErrorsInJSXText(node) {
+				ALL_IRREGULARS.test(node.raw) && removeWhitespaceError(node);
+			}
+			/**
+			* Checks the program source for irregular whitespace
+			* @param {ASTNode} node The program node
+			* @returns {void}
+			* @private
+			*/
+			function checkForIrregularWhitespace(node) {
+				sourceCode.lines.forEach((sourceLine, lineIndex) => {
+					let lineNumber = lineIndex + 1, match;
+					for (; (match = IRREGULAR_WHITESPACE.exec(sourceLine)) !== null;) errors.push({
+						node,
+						messageId: "noIrregularWhitespace",
+						loc: {
+							start: {
+								line: lineNumber,
+								column: match.index
+							},
+							end: {
+								line: lineNumber,
+								column: match.index + match[0].length
+							}
+						}
+					});
+				});
+			}
+			/**
+			* Checks the program source for irregular line terminators
+			* @param {ASTNode} node The program node
+			* @returns {void}
+			* @private
+			*/
+			function checkForIrregularLineTerminators(node) {
+				let source = sourceCode.getText(), sourceLines = sourceCode.lines, linebreaks = source.match(LINE_BREAK), lastLineIndex = -1, match;
+				for (; (match = IRREGULAR_LINE_TERMINATORS.exec(source)) !== null;) {
+					let lineIndex = linebreaks.indexOf(match[0], lastLineIndex + 1) || 0;
+					errors.push({
+						node,
+						messageId: "noIrregularWhitespace",
+						loc: {
+							start: {
+								line: lineIndex + 1,
+								column: sourceLines[lineIndex].length
+							},
+							end: {
+								line: lineIndex + 2,
+								column: 0
+							}
+						}
+					}), lastLineIndex = lineIndex;
+				}
+			}
+			/**
+			* A no-op function to act as placeholder for comment accumulation when the `skipComments` option is `false`.
+			* @returns {void}
+			* @private
+			*/
+			function noop() {}
+			let nodes = {};
+			return ALL_IRREGULARS.test(sourceCode.getText()) ? (nodes.Program = function(node) {
+				checkForIrregularWhitespace(node), checkForIrregularLineTerminators(node);
+			}, nodes.Literal = removeInvalidNodeErrorsInLiteral, nodes.TemplateElement = skipTemplates ? removeInvalidNodeErrorsInTemplateLiteral : noop, nodes.JSXText = skipJSXText ? removeInvalidNodeErrorsInJSXText : noop, nodes["Program:exit"] = function() {
+				skipComments && commentNodes.forEach(removeInvalidNodeErrorsInComment), errors.forEach((error) => context.report(error));
+			}) : nodes.Program = noop, nodes;
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-irregular-whitespace.cjs
+module.exports = require_no_irregular_whitespace().create;
+//#endregion

package/rules/no-iterator.cjs

@@ -0,0 +1,34 @@
+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/no-iterator.js
+/**
+* @fileoverview Rule to flag usage of __iterator__ property
+* @author Ian Christian Myers
+*/
+var require_no_iterator = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { getStaticPropertyName } = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow the use of the `__iterator__` property",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-iterator"
+			},
+			schema: [],
+			messages: { noIterator: "Reserved name '__iterator__'." }
+		},
+		create(context) {
+			return { MemberExpression(node) {
+				getStaticPropertyName(node) === "__iterator__" && context.report({
+					node,
+					messageId: "noIterator"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-iterator.cjs
+module.exports = require_no_iterator().create;
+//#endregion

package/rules/no-label-var.cjs

@@ -0,0 +1,46 @@
+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/no-label-var.js
+/**
+* @fileoverview Rule to flag labels that are the same as an identifier
+* @author Ian Christian Myers
+*/
+var require_no_label_var = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow labels that share a name with a variable",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-label-var"
+			},
+			schema: [],
+			messages: { identifierClashWithLabel: "Found identifier with same name as label." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Check if the identifier is present inside current scope
+			* @param {Object} scope current scope
+			* @param {string} name To evaluate
+			* @returns {boolean} True if its present
+			* @private
+			*/
+			function findIdentifier(scope, name) {
+				return astUtils.getVariableByName(scope, name) !== null;
+			}
+			return { LabeledStatement(node) {
+				findIdentifier(sourceCode.getScope(node), node.label.name) && context.report({
+					node,
+					messageId: "identifierClashWithLabel"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-label-var.cjs
+module.exports = require_no_label_var().create;
+//#endregion

package/rules/no-labels.cjs

@@ -0,0 +1,106 @@
+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/no-labels.js
+/**
+* @fileoverview Disallow Labeled Statements
+* @author Nicholas C. Zakas
+*/
+var require_no_labels = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{
+				allowLoop: !1,
+				allowSwitch: !1
+			}],
+			docs: {
+				description: "Disallow labeled statements",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-labels"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					allowLoop: { type: "boolean" },
+					allowSwitch: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				unexpectedLabel: "Unexpected labeled statement.",
+				unexpectedLabelInBreak: "Unexpected label in break statement.",
+				unexpectedLabelInContinue: "Unexpected label in continue statement."
+			}
+		},
+		create(context) {
+			let [{ allowLoop, allowSwitch }] = context.options, scopeInfo = null;
+			/**
+			* Gets the kind of a given node.
+			* @param {ASTNode} node A node to get.
+			* @returns {string} The kind of the node.
+			*/
+			function getBodyKind(node) {
+				return astUtils.isLoop(node) ? "loop" : node.type === "SwitchStatement" ? "switch" : "other";
+			}
+			/**
+			* Checks whether the label of a given kind is allowed or not.
+			* @param {string} kind A kind to check.
+			* @returns {boolean} `true` if the kind is allowed.
+			*/
+			function isAllowed(kind) {
+				switch (kind) {
+					case "loop": return allowLoop;
+					case "switch": return allowSwitch;
+					default: return !1;
+				}
+			}
+			/**
+			* Checks whether a given name is a label of a loop or not.
+			* @param {string} label A name of a label to check.
+			* @returns {boolean} `true` if the name is a label of a loop.
+			*/
+			function getKind(label) {
+				let info = scopeInfo;
+				for (; info;) {
+					if (info.label === label) return info.kind;
+					info = info.upper;
+				}
+				/* c8 ignore next */
+				return "other";
+			}
+			return {
+				LabeledStatement(node) {
+					scopeInfo = {
+						label: node.label.name,
+						kind: getBodyKind(node.body),
+						upper: scopeInfo
+					};
+				},
+				"LabeledStatement:exit"(node) {
+					isAllowed(scopeInfo.kind) || context.report({
+						node,
+						messageId: "unexpectedLabel"
+					}), scopeInfo = scopeInfo.upper;
+				},
+				BreakStatement(node) {
+					node.label && !isAllowed(getKind(node.label.name)) && context.report({
+						node,
+						messageId: "unexpectedLabelInBreak"
+					});
+				},
+				ContinueStatement(node) {
+					node.label && !isAllowed(getKind(node.label.name)) && context.report({
+						node,
+						messageId: "unexpectedLabelInContinue"
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-labels.cjs
+module.exports = require_no_labels().create;
+//#endregion

package/rules/no-lone-blocks.cjs

@@ -0,0 +1,75 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-lone-blocks.js
+/**
+* @fileoverview Rule to flag blocks with no reason to exist
+* @author Brandon Mills
+*/
+var require_no_lone_blocks = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow unnecessary nested blocks",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-lone-blocks"
+			},
+			schema: [],
+			messages: {
+				redundantBlock: "Block is redundant.",
+				redundantNestedBlock: "Nested block is redundant."
+			}
+		},
+		create(context) {
+			let loneBlocks = [], ruleDef, sourceCode = context.sourceCode;
+			/**
+			* Reports a node as invalid.
+			* @param {ASTNode} node The node to be reported.
+			* @returns {void}
+			*/
+			function report(node) {
+				let messageId = node.parent.type === "BlockStatement" || node.parent.type === "StaticBlock" ? "redundantNestedBlock" : "redundantBlock";
+				context.report({
+					node,
+					messageId
+				});
+			}
+			/**
+			* Checks for any occurrence of a BlockStatement in a place where lists of statements can appear
+			* @param {ASTNode} node The node to check
+			* @returns {boolean} True if the node is a lone block.
+			*/
+			function isLoneBlock(node) {
+				return node.parent.type === "BlockStatement" || node.parent.type === "StaticBlock" || node.parent.type === "Program" || node.parent.type === "SwitchCase" && !(node.parent.consequent[0] === node && node.parent.consequent.length === 1);
+			}
+			/**
+			* Checks the enclosing block of the current node for block-level bindings,
+			* and "marks it" as valid if any.
+			* @param {ASTNode} node The current node to check.
+			* @returns {void}
+			*/
+			function markLoneBlock(node) {
+				if (loneBlocks.length === 0) return;
+				let block = node.parent;
+				loneBlocks.at(-1) === block && loneBlocks.pop();
+			}
+			return ruleDef = { BlockStatement(node) {
+				isLoneBlock(node) && report(node);
+			} }, context.languageOptions.ecmaVersion >= 2015 && (ruleDef = {
+				BlockStatement(node) {
+					isLoneBlock(node) && loneBlocks.push(node);
+				},
+				"BlockStatement:exit"(node) {
+					loneBlocks.length > 0 && loneBlocks.at(-1) === node ? (loneBlocks.pop(), report(node)) : (node.parent.type === "BlockStatement" || node.parent.type === "StaticBlock") && node.parent.body.length === 1 && report(node);
+				}
+			}, ruleDef.VariableDeclaration = function(node) {
+				node.kind !== "var" && markLoneBlock(node);
+			}, ruleDef.FunctionDeclaration = function(node) {
+				sourceCode.getScope(node).isStrict && markLoneBlock(node);
+			}, ruleDef.ClassDeclaration = markLoneBlock), ruleDef;
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-lone-blocks.cjs
+module.exports = require_no_lone_blocks().create;
+//#endregion

package/rules/no-lonely-if.cjs

@@ -0,0 +1,42 @@
+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/no-lonely-if.js
+/**
+* @fileoverview Rule to disallow if as the only statement in an else block
+* @author Brandon Mills
+*/
+var require_no_lonely_if = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow `if` statements as the only statement in `else` blocks",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-lonely-if"
+			},
+			schema: [],
+			fixable: "code",
+			messages: { unexpectedLonelyIf: "Unexpected if as the only statement in an else block." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { IfStatement(node) {
+				let parent = node.parent, grandparent = parent.parent;
+				parent && parent.type === "BlockStatement" && parent.body.length === 1 && !astUtils.areBracesNecessary(parent, sourceCode) && grandparent && grandparent.type === "IfStatement" && parent === grandparent.alternate && context.report({
+					node,
+					messageId: "unexpectedLonelyIf",
+					fix(fixer) {
+						let openingElseCurly = sourceCode.getFirstToken(parent), closingElseCurly = sourceCode.getLastToken(parent), elseKeyword = sourceCode.getTokenBefore(openingElseCurly), tokenAfterElseBlock = sourceCode.getTokenAfter(closingElseCurly), lastIfToken = sourceCode.getLastToken(node.consequent), sourceText = sourceCode.getText();
+						return sourceText.slice(openingElseCurly.range[1], node.range[0]).trim() || sourceText.slice(node.range[1], closingElseCurly.range[0]).trim() || node.consequent.type !== "BlockStatement" && lastIfToken.value !== ";" && tokenAfterElseBlock && (node.consequent.loc.end.line === tokenAfterElseBlock.loc.start.line || /^[([/+`-]/u.test(tokenAfterElseBlock.value) || lastIfToken.value === "++" || lastIfToken.value === "--") ? null : fixer.replaceTextRange([openingElseCurly.range[0], closingElseCurly.range[1]], (elseKeyword.range[1] === openingElseCurly.range[0] ? " " : "") + sourceCode.getText(node));
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-lonely-if.cjs
+module.exports = require_no_lonely_if().create;
+//#endregion

package/rules/no-loop-func.cjs

@@ -0,0 +1,143 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-loop-func.js
+/**
+* @fileoverview Rule to flag creation of function inside a loop
+* @author Ilya Volodin
+*/
+var require_no_loop_func = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let CONSTANT_BINDINGS = new Set([
+		"const",
+		"using",
+		"await using"
+	]);
+	/**
+	* Identifies is a node is a FunctionExpression which is part of an IIFE
+	* @param {ASTNode} node Node to test
+	* @returns {boolean} True if it's an IIFE
+	*/
+	function isIIFE(node) {
+		return (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && node.parent && node.parent.type === "CallExpression" && node.parent.callee === node;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			dialects: ["typescript", "javascript"],
+			language: "javascript",
+			docs: {
+				description: "Disallow function declarations that contain unsafe references inside loop statements",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-loop-func"
+			},
+			schema: [],
+			messages: { unsafeRefs: "Function declared in a loop contains unsafe references to variable(s) {{ varNames }}." }
+		},
+		create(context) {
+			let SKIPPED_IIFE_NODES = /* @__PURE__ */ new Set(), sourceCode = context.sourceCode;
+			/**
+			* Gets the containing loop node of a specified node.
+			*
+			* We don't need to check nested functions, so this ignores those, with the exception of IIFE.
+			* `Scope.through` contains references of nested functions.
+			* @param {ASTNode} node An AST node to get.
+			* @returns {ASTNode|null} The containing loop node of the specified node, or
+			*      `null`.
+			*/
+			function getContainingLoopNode(node) {
+				for (let currentNode = node; currentNode.parent; currentNode = currentNode.parent) {
+					let parent = currentNode.parent;
+					switch (parent.type) {
+						case "WhileStatement":
+						case "DoWhileStatement": return parent;
+						case "ForStatement":
+							if (parent.init !== currentNode) return parent;
+							break;
+						case "ForInStatement":
+						case "ForOfStatement":
+							if (parent.right !== currentNode) return parent;
+							break;
+						case "ArrowFunctionExpression":
+						case "FunctionExpression":
+						case "FunctionDeclaration":
+							if (SKIPPED_IIFE_NODES.has(parent)) break;
+							return null;
+						default: break;
+					}
+				}
+				return null;
+			}
+			/**
+			* Gets the containing loop node of a given node.
+			* If the loop was nested, this returns the most outer loop.
+			* @param {ASTNode} node A node to get. This is a loop node.
+			* @param {ASTNode|null} excludedNode A node that the result node should not
+			*      include.
+			* @returns {ASTNode} The most outer loop node.
+			*/
+			function getTopLoopNode(node, excludedNode) {
+				let border = excludedNode ? excludedNode.range[1] : 0, retv = node, containingLoopNode = node;
+				for (; containingLoopNode && containingLoopNode.range[0] >= border;) retv = containingLoopNode, containingLoopNode = getContainingLoopNode(containingLoopNode);
+				return retv;
+			}
+			/**
+			* Checks whether a given reference which refers to an upper scope's variable is
+			* safe or not.
+			* @param {ASTNode} loopNode A containing loop node.
+			* @param {eslint-scope.Reference} reference A reference to check.
+			* @returns {boolean} `true` if the reference is safe or not.
+			*/
+			function isSafe(loopNode, reference) {
+				let variable = reference.resolved, definition = variable && variable.defs[0], declaration = definition && definition.parent, kind = declaration && declaration.type === "VariableDeclaration" ? declaration.kind : "";
+				if (CONSTANT_BINDINGS.has(kind) || kind === "let" && declaration.range[0] > loopNode.range[0] && declaration.range[1] < loopNode.range[1]) return !0;
+				let border = getTopLoopNode(loopNode, kind === "let" ? declaration : null).range[0];
+				/**
+				* Checks whether a given reference is safe or not.
+				* The reference is every reference of the upper scope's variable we are
+				* looking now.
+				*
+				* It's safe if the reference matches one of the following condition.
+				* - is readonly.
+				* - doesn't exist inside a local function and after the border.
+				* @param {eslint-scope.Reference} upperRef A reference to check.
+				* @returns {boolean} `true` if the reference is safe.
+				*/
+				function isSafeReference(upperRef) {
+					let id = upperRef.identifier;
+					return !upperRef.isWrite() || variable.scope.variableScope === upperRef.from.variableScope && id.range[0] < border;
+				}
+				return !!variable && variable.references.every(isSafeReference);
+			}
+			/**
+			* Reports functions which match the following condition:
+			*
+			* - has a loop node in ancestors.
+			* - has any references which refers to an unsafe variable.
+			* @param {ASTNode} node The AST node to check.
+			* @returns {void}
+			*/
+			function checkForLoops(node) {
+				let loopNode = getContainingLoopNode(node);
+				if (!loopNode) return;
+				let references = sourceCode.getScope(node).through;
+				if (!(node.async || node.generator) && isIIFE(node) && !(node.type === "FunctionExpression" && node.id && references.some((r) => r.identifier.name === node.id.name))) {
+					SKIPPED_IIFE_NODES.add(node);
+					return;
+				}
+				let unsafeRefs = [...new Set(references.filter((r) => r.resolved && !isSafe(loopNode, r)).map((r) => r.identifier.name))];
+				unsafeRefs.length > 0 && context.report({
+					node,
+					messageId: "unsafeRefs",
+					data: { varNames: `'${unsafeRefs.join("', '")}'` }
+				});
+			}
+			return {
+				ArrowFunctionExpression: checkForLoops,
+				FunctionExpression: checkForLoops,
+				FunctionDeclaration: checkForLoops
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-loop-func.cjs
+module.exports = require_no_loop_func().create;
+//#endregion