oxlint-plugin-eslint 1.52.0

package/rules/no-useless-rename.cjs

@@ -0,0 +1,94 @@
+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-useless-rename.js
+/**
+* @fileoverview Disallow renaming import, export, and destructured assignments to the same name.
+* @author Kai Cataldo
+*/
+var require_no_useless_rename = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{
+				ignoreDestructuring: !1,
+				ignoreImport: !1,
+				ignoreExport: !1
+			}],
+			docs: {
+				description: "Disallow renaming import, export, and destructured assignments to the same name",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-useless-rename"
+			},
+			fixable: "code",
+			schema: [{
+				type: "object",
+				properties: {
+					ignoreDestructuring: { type: "boolean" },
+					ignoreImport: { type: "boolean" },
+					ignoreExport: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: { unnecessarilyRenamed: "{{type}} {{name}} unnecessarily renamed." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ ignoreDestructuring, ignoreImport, ignoreExport }] = context.options;
+			/**
+			* Reports error for unnecessarily renamed assignments
+			* @param {ASTNode} node node to report
+			* @param {ASTNode} initial node with initial name value
+			* @param {string} type the type of the offending node
+			* @returns {void}
+			*/
+			function reportError(node, initial, type) {
+				let name = initial.type === "Identifier" ? initial.name : initial.value;
+				return context.report({
+					node,
+					messageId: "unnecessarilyRenamed",
+					data: {
+						name,
+						type
+					},
+					fix(fixer) {
+						let replacementNode = node.type === "Property" ? node.value : node.local;
+						return sourceCode.getCommentsInside(node).length > sourceCode.getCommentsInside(replacementNode).length || replacementNode.type === "AssignmentPattern" && astUtils.isParenthesised(sourceCode, replacementNode.left) ? null : fixer.replaceText(node, sourceCode.getText(replacementNode));
+					}
+				});
+			}
+			/**
+			* Checks whether a destructured assignment is unnecessarily renamed
+			* @param {ASTNode} node node to check
+			* @returns {void}
+			*/
+			function checkDestructured(node) {
+				if (!ignoreDestructuring) for (let property of node.properties) property.type !== "Property" || property.shorthand || property.computed || (property.key.type === "Identifier" && property.key.name || property.key.type === "Literal" && property.key.value) === (property.value.type === "AssignmentPattern" ? property.value.left.name : property.value.name) && reportError(property, property.key, "Destructuring assignment");
+			}
+			/**
+			* Checks whether an import is unnecessarily renamed
+			* @param {ASTNode} node node to check
+			* @returns {void}
+			*/
+			function checkImport(node) {
+				ignoreImport || node.imported.range[0] !== node.local.range[0] && astUtils.getModuleExportName(node.imported) === node.local.name && reportError(node, node.imported, "Import");
+			}
+			/**
+			* Checks whether an export is unnecessarily renamed
+			* @param {ASTNode} node node to check
+			* @returns {void}
+			*/
+			function checkExport(node) {
+				ignoreExport || node.local.range[0] !== node.exported.range[0] && astUtils.getModuleExportName(node.local) === astUtils.getModuleExportName(node.exported) && reportError(node, node.local, "Export");
+			}
+			return {
+				ObjectPattern: checkDestructured,
+				ImportSpecifier: checkImport,
+				ExportSpecifier: checkExport
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-useless-rename.cjs
+module.exports = require_no_useless_rename().create;
+//#endregion

package/rules/no-useless-return.cjs

@@ -0,0 +1,229 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_fix_tracker$1 = require("../common/fix-tracker.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-useless-return.js
+/**
+* @fileoverview Disallow redundant return statements
+* @author Teddy Katz
+*/
+var require_no_useless_return = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), FixTracker = require_fix_tracker$1.t();
+	/**
+	* Removes the given element from the array.
+	* @param {Array} array The source array to remove.
+	* @param {any} element The target item to remove.
+	* @returns {void}
+	*/
+	function remove(array, element) {
+		let index = array.indexOf(element);
+		index !== -1 && array.splice(index, 1);
+	}
+	/**
+	* Checks whether it can remove the given return statement or not.
+	* @param {ASTNode} node The return statement node to check.
+	* @returns {boolean} `true` if the node is removable.
+	*/
+	function isRemovable(node) {
+		return astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type);
+	}
+	/**
+	* Checks whether the given return statement is in a `finally` block or not.
+	* @param {ASTNode} node The return statement node to check.
+	* @returns {boolean} `true` if the node is in a `finally` block.
+	*/
+	function isInFinally(node) {
+		for (let currentNode = node; currentNode && currentNode.parent && !astUtils.isFunction(currentNode); currentNode = currentNode.parent) if (currentNode.parent.type === "TryStatement" && currentNode.parent.finalizer === currentNode) return !0;
+		return !1;
+	}
+	/**
+	* Checks all segments in a set and returns true if any are reachable.
+	* @param {Set<CodePathSegment>} segments The segments to check.
+	* @returns {boolean} True if any segment is reachable; false otherwise.
+	*/
+	function isAnySegmentReachable(segments) {
+		for (let segment of segments) if (segment.reachable) return !0;
+		return !1;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow redundant return statements",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-useless-return"
+			},
+			fixable: "code",
+			schema: [],
+			messages: { unnecessaryReturn: "Unnecessary return statement." }
+		},
+		create(context) {
+			let segmentInfoMap = /* @__PURE__ */ new WeakMap(), sourceCode = context.sourceCode, scopeInfo = null;
+			/**
+			* Checks whether the given segment is terminated by a return statement or not.
+			* @param {CodePathSegment} segment The segment to check.
+			* @returns {boolean} `true` if the segment is terminated by a return statement, or if it's still a part of unreachable.
+			*/
+			function isReturned(segment) {
+				let info = segmentInfoMap.get(segment);
+				return !info || info.returned;
+			}
+			/**
+			* Collects useless return statements from the given previous segments.
+			*
+			* A previous segment may be an unreachable segment.
+			* In that case, the information object of the unreachable segment is not
+			* initialized because `onCodePathSegmentStart` event is not notified for
+			* unreachable segments.
+			* This goes to the previous segments of the unreachable segment recursively
+			* if the unreachable segment was generated by a return statement. Otherwise,
+			* this ignores the unreachable segment.
+			*
+			* This behavior would simulate code paths for the case that the return
+			* statement does not exist.
+			* @param {ASTNode[]} uselessReturns The collected return statements.
+			* @param {CodePathSegment[]} prevSegments The previous segments to traverse.
+			* @param {WeakSet<CodePathSegment>} [providedTraversedSegments] A set of segments that have already been traversed in this call
+			* @returns {ASTNode[]} `uselessReturns`.
+			*/
+			function getUselessReturns(uselessReturns, prevSegments, providedTraversedSegments) {
+				let traversedSegments = providedTraversedSegments || /* @__PURE__ */ new WeakSet();
+				for (let segment of prevSegments) {
+					if (!segment.reachable) {
+						traversedSegments.has(segment) || (traversedSegments.add(segment), getUselessReturns(uselessReturns, segment.allPrevSegments.filter(isReturned), traversedSegments));
+						continue;
+					}
+					segmentInfoMap.has(segment) && uselessReturns.push(...segmentInfoMap.get(segment).uselessReturns);
+				}
+				return uselessReturns;
+			}
+			/**
+			* Removes the return statements on the given segment from the useless return
+			* statement list.
+			*
+			* This segment may be an unreachable segment.
+			* In that case, the information object of the unreachable segment is not
+			* initialized because `onCodePathSegmentStart` event is not notified for
+			* unreachable segments.
+			* This goes to the previous segments of the unreachable segment recursively
+			* if the unreachable segment was generated by a return statement. Otherwise,
+			* this ignores the unreachable segment.
+			*
+			* This behavior would simulate code paths for the case that the return
+			* statement does not exist.
+			* @param {CodePathSegment} segment The segment to get return statements.
+			* @param {Set<CodePathSegment>} usedUnreachableSegments A set of segments that have already been traversed in this call.
+			* @returns {void}
+			*/
+			function markReturnStatementsOnSegmentAsUsed(segment, usedUnreachableSegments) {
+				if (!segment.reachable) {
+					usedUnreachableSegments.add(segment), segment.allPrevSegments.filter(isReturned).filter((prevSegment) => !usedUnreachableSegments.has(prevSegment)).forEach((prevSegment) => markReturnStatementsOnSegmentAsUsed(prevSegment, usedUnreachableSegments));
+					return;
+				}
+				let info = segmentInfoMap.get(segment);
+				info && (info.uselessReturns = info.uselessReturns.filter((node) => {
+					if (scopeInfo.traversedTryBlockStatements && scopeInfo.traversedTryBlockStatements.length > 0) {
+						let returnInitialRange = node.range[0], returnFinalRange = node.range[1];
+						if (scopeInfo.traversedTryBlockStatements.some((tryBlockStatement) => {
+							let blockInitialRange = tryBlockStatement.range[0], blockFinalRange = tryBlockStatement.range[1];
+							return returnInitialRange >= blockInitialRange && returnFinalRange <= blockFinalRange;
+						})) return !0;
+					}
+					return remove(scopeInfo.uselessReturns, node), !1;
+				}));
+			}
+			/**
+			* Removes the return statements on the current segments from the useless
+			* return statement list.
+			*
+			* This function will be called at every statement except FunctionDeclaration,
+			* BlockStatement, and BreakStatement.
+			*
+			* - FunctionDeclarations are always executed whether it's returned or not.
+			* - BlockStatements do nothing.
+			* - BreakStatements go the next merely.
+			* @returns {void}
+			*/
+			function markReturnStatementsOnCurrentSegmentsAsUsed() {
+				scopeInfo.currentSegments.forEach((segment) => markReturnStatementsOnSegmentAsUsed(segment, /* @__PURE__ */ new Set()));
+			}
+			return {
+				onCodePathStart(codePath) {
+					scopeInfo = {
+						upper: scopeInfo,
+						uselessReturns: [],
+						traversedTryBlockStatements: [],
+						codePath,
+						currentSegments: /* @__PURE__ */ new Set()
+					};
+				},
+				onCodePathEnd() {
+					for (let node of scopeInfo.uselessReturns) context.report({
+						node,
+						loc: node.loc,
+						messageId: "unnecessaryReturn",
+						fix(fixer) {
+							return isRemovable(node) && !sourceCode.getCommentsInside(node).length ? new FixTracker(fixer, sourceCode).retainEnclosingFunction(node).remove(node) : null;
+						}
+					});
+					scopeInfo = scopeInfo.upper;
+				},
+				onCodePathSegmentStart(segment) {
+					scopeInfo.currentSegments.add(segment);
+					let info = {
+						uselessReturns: getUselessReturns([], segment.allPrevSegments),
+						returned: !1
+					};
+					segmentInfoMap.set(segment, info);
+				},
+				onUnreachableCodePathSegmentStart(segment) {
+					scopeInfo.currentSegments.add(segment);
+				},
+				onUnreachableCodePathSegmentEnd(segment) {
+					scopeInfo.currentSegments.delete(segment);
+				},
+				onCodePathSegmentEnd(segment) {
+					scopeInfo.currentSegments.delete(segment);
+				},
+				ReturnStatement(node) {
+					if (node.argument && markReturnStatementsOnCurrentSegmentsAsUsed(), !(node.argument || astUtils.isInLoop(node) || isInFinally(node) || !isAnySegmentReachable(scopeInfo.currentSegments))) {
+						for (let segment of scopeInfo.currentSegments) {
+							let info = segmentInfoMap.get(segment);
+							info && (info.uselessReturns.push(node), info.returned = !0);
+						}
+						scopeInfo.uselessReturns.push(node);
+					}
+				},
+				"TryStatement > BlockStatement.block:exit"(node) {
+					scopeInfo.traversedTryBlockStatements.push(node);
+				},
+				"TryStatement:exit"() {
+					scopeInfo.traversedTryBlockStatements.pop();
+				},
+				ClassDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
+				ContinueStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				DebuggerStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				DoWhileStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				EmptyStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				ExpressionStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				ForInStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				ForOfStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				ForStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				IfStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				ImportDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
+				LabeledStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				SwitchStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				ThrowStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				TryStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				VariableDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
+				WhileStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				WithStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
+				ExportNamedDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
+				ExportDefaultDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
+				ExportAllDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-useless-return.cjs
+module.exports = require_no_useless_return().create;
+//#endregion

package/rules/no-var.cjs

@@ -0,0 +1,235 @@
+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-var.js
+/**
+* @fileoverview Rule to check for the usage of var.
+* @author Jamund Ferguson
+*/
+var require_no_var = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Check whether a given variable is a global variable or not.
+	* @param {eslint-scope.Variable} variable The variable to check.
+	* @returns {boolean} `true` if the variable is a global variable.
+	*/
+	function isGlobal(variable) {
+		return !!variable.scope && variable.scope.type === "global";
+	}
+	/**
+	* Finds the nearest function scope or global scope walking up the scope
+	* hierarchy.
+	* @param {eslint-scope.Scope} scope The scope to traverse.
+	* @returns {eslint-scope.Scope} a function scope or global scope containing the given
+	*      scope.
+	*/
+	function getEnclosingFunctionScope(scope) {
+		let currentScope = scope;
+		for (; currentScope.type !== "function" && currentScope.type !== "global";) currentScope = currentScope.upper;
+		return currentScope;
+	}
+	/**
+	* Checks whether the given variable has any references from a more specific
+	* function expression (i.e. a closure).
+	* @param {eslint-scope.Variable} variable A variable to check.
+	* @returns {boolean} `true` if the variable is used from a closure.
+	*/
+	function isReferencedInClosure(variable) {
+		let enclosingFunctionScope = getEnclosingFunctionScope(variable.scope);
+		return variable.references.some((reference) => getEnclosingFunctionScope(reference.from) !== enclosingFunctionScope);
+	}
+	/**
+	* Checks whether the given node is the assignee of a loop.
+	* @param {ASTNode} node A VariableDeclaration node to check.
+	* @returns {boolean} `true` if the declaration is assigned as part of loop
+	*      iteration.
+	*/
+	function isLoopAssignee(node) {
+		return (node.parent.type === "ForOfStatement" || node.parent.type === "ForInStatement") && node === node.parent.left;
+	}
+	/**
+	* Checks whether the given variable declaration is immediately initialized.
+	* @param {ASTNode} node A VariableDeclaration node to check.
+	* @returns {boolean} `true` if the declaration has an initializer.
+	*/
+	function isDeclarationInitialized(node) {
+		return node.declarations.every((declarator) => declarator.init !== null);
+	}
+	let SCOPE_NODE_TYPE = /^(?:Program|BlockStatement|SwitchStatement|ForStatement|ForInStatement|ForOfStatement)$/u;
+	/**
+	* Gets the scope node which directly contains a given node.
+	* @param {ASTNode} node A node to get. This is a `VariableDeclaration` or
+	*      an `Identifier`.
+	* @returns {ASTNode} A scope node. This is one of `Program`, `BlockStatement`,
+	*      `SwitchStatement`, `ForStatement`, `ForInStatement`, and
+	*      `ForOfStatement`.
+	*/
+	function getScopeNode(node) {
+		for (let currentNode = node; currentNode; currentNode = currentNode.parent) if (SCOPE_NODE_TYPE.test(currentNode.type)) return currentNode;
+		/* c8 ignore next */
+		return null;
+	}
+	/**
+	* Checks whether a given variable is redeclared or not.
+	* @param {eslint-scope.Variable} variable A variable to check.
+	* @returns {boolean} `true` if the variable is redeclared.
+	*/
+	function isRedeclared(variable) {
+		return variable.defs.length >= 2;
+	}
+	/**
+	* Checks whether a given variable is used from outside of the specified scope.
+	* @param {ASTNode} scopeNode A scope node to check.
+	* @returns {Function} The predicate function which checks whether a given
+	*      variable is used from outside of the specified scope.
+	*/
+	function isUsedFromOutsideOf(scopeNode) {
+		/**
+		* Checks whether a given reference is inside of the specified scope or not.
+		* @param {eslint-scope.Reference} reference A reference to check.
+		* @returns {boolean} `true` if the reference is inside of the specified
+		*      scope.
+		*/
+		function isOutsideOfScope(reference) {
+			let scope = scopeNode.range, id = reference.identifier.range;
+			return id[0] < scope[0] || id[1] > scope[1];
+		}
+		return function(variable) {
+			return variable.references.some(isOutsideOfScope);
+		};
+	}
+	/**
+	* Creates the predicate function which checks whether a variable has their references in TDZ.
+	*
+	* The predicate function would return `true`:
+	*
+	* - if a reference is before the declarator. E.g. (var a = b, b = 1;)(var {a = b, b} = {};)
+	* - if a reference is in the expression of their default value.  E.g. (var {a = a} = {};)
+	* - if a reference is in the expression of their initializer.  E.g. (var a = a;)
+	* @param {ASTNode} node The initializer node of VariableDeclarator.
+	* @returns {Function} The predicate function.
+	* @private
+	*/
+	function hasReferenceInTDZ(node) {
+		let initStart = node.range[0], initEnd = node.range[1];
+		return (variable) => {
+			let id = variable.defs[0].name, idStart = id.range[0], defaultValue = id.parent.type === "AssignmentPattern" ? id.parent.right : null, defaultStart = defaultValue && defaultValue.range[0], defaultEnd = defaultValue && defaultValue.range[1];
+			return variable.references.some((reference) => {
+				let start = reference.identifier.range[0], end = reference.identifier.range[1];
+				return !reference.init && (start < idStart || defaultValue !== null && start >= defaultStart && end <= defaultEnd || !astUtils.isFunction(node) && start >= initStart && end <= initEnd);
+			});
+		};
+	}
+	/**
+	* Checks whether a given variable has name that is allowed for 'var' declarations,
+	* but disallowed for `let` declarations.
+	* @param {eslint-scope.Variable} variable The variable to check.
+	* @returns {boolean} `true` if the variable has a disallowed name.
+	*/
+	function hasNameDisallowedForLetDeclarations(variable) {
+		return variable.name === "let";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			dialects: ["typescript", "javascript"],
+			language: "javascript",
+			docs: {
+				description: "Require `let` or `const` instead of `var`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-var"
+			},
+			schema: [],
+			fixable: "code",
+			messages: { unexpectedVar: "Unexpected var, use let or const instead." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Checks whether the variables which are defined by the given declarator node have their references in TDZ.
+			* @param {ASTNode} declarator The VariableDeclarator node to check.
+			* @returns {boolean} `true` if one of the variables which are defined by the given declarator node have their references in TDZ.
+			*/
+			function hasSelfReferenceInTDZ(declarator) {
+				return declarator.init ? sourceCode.getDeclaredVariables(declarator).some(hasReferenceInTDZ(declarator.init)) : !1;
+			}
+			/**
+			* Checks whether it can fix a given variable declaration or not.
+			* It cannot fix if the following cases:
+			*
+			* - A variable is a global variable.
+			* - A variable is declared on a SwitchCase node.
+			* - A variable is redeclared.
+			* - A variable is used from outside the scope.
+			* - A variable is used from a closure within a loop.
+			* - A variable might be used before it is assigned within a loop.
+			* - A variable might be used in TDZ.
+			* - A variable is declared in statement position (e.g. a single-line `IfStatement`)
+			* - A variable has name that is disallowed for `let` declarations.
+			*
+			* ## A variable is declared on a SwitchCase node.
+			*
+			* If this rule modifies 'var' declarations on a SwitchCase node, it
+			* would generate the warnings of 'no-case-declarations' rule. And the
+			* 'eslint:recommended' preset includes 'no-case-declarations' rule, so
+			* this rule doesn't modify those declarations.
+			*
+			* ## A variable is redeclared.
+			*
+			* The language spec disallows redeclarations of `let` declarations.
+			* Those variables would cause syntax errors.
+			*
+			* ## A variable is used from outside the scope.
+			*
+			* The language spec disallows accesses from outside of the scope for
+			* `let` declarations. Those variables would cause reference errors.
+			*
+			* ## A variable is used from a closure within a loop.
+			*
+			* A `var` declaration within a loop shares the same variable instance
+			* across all loop iterations, while a `let` declaration creates a new
+			* instance for each iteration. This means if a variable in a loop is
+			* referenced by any closure, changing it from `var` to `let` would
+			* change the behavior in a way that is generally unsafe.
+			*
+			* ## A variable might be used before it is assigned within a loop.
+			*
+			* Within a loop, a `let` declaration without an initializer will be
+			* initialized to null, while a `var` declaration will retain its value
+			* from the previous iteration, so it is only safe to change `var` to
+			* `let` if we can statically determine that the variable is always
+			* assigned a value before its first access in the loop body. To keep
+			* the implementation simple, we only convert `var` to `let` within
+			* loops when the variable is a loop assignee or the declaration has an
+			* initializer.
+			* @param {ASTNode} node A variable declaration node to check.
+			* @returns {boolean} `true` if it can fix the node.
+			*/
+			function canFix(node) {
+				let variables = sourceCode.getDeclaredVariables(node), scopeNode = getScopeNode(node);
+				return !(node.parent.type === "SwitchCase" || node.declarations.some(hasSelfReferenceInTDZ) || variables.some(isGlobal) || variables.some(isRedeclared) || variables.some(isUsedFromOutsideOf(scopeNode)) || variables.some(hasNameDisallowedForLetDeclarations) || astUtils.isInLoop(node) && (variables.some(isReferencedInClosure) || !isLoopAssignee(node) && !isDeclarationInitialized(node)) || !isLoopAssignee(node) && !(node.parent.type === "ForStatement" && node.parent.init === node) && !astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type));
+			}
+			/**
+			* Reports a given variable declaration node.
+			* @param {ASTNode} node A variable declaration node to report.
+			* @returns {void}
+			*/
+			function report(node) {
+				context.report({
+					node,
+					messageId: "unexpectedVar",
+					fix(fixer) {
+						let varToken = sourceCode.getFirstToken(node, { filter: (t) => t.value === "var" });
+						return canFix(node) ? fixer.replaceText(varToken, "let") : null;
+					}
+				});
+			}
+			return { "VariableDeclaration:exit"(node) {
+				node.kind === "var" && (node.parent.type === "TSModuleBlock" && node.parent.parent.type === "TSModuleDeclaration" && node.parent.parent.global || report(node));
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-var.cjs
+module.exports = require_no_var().create;
+//#endregion

package/rules/no-void.cjs

@@ -0,0 +1,39 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-void.js
+/**
+* @fileoverview Rule to disallow use of void operator.
+* @author Mike Sidorov
+*/
+var require_no_void = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ allowAsStatement: !1 }],
+			docs: {
+				description: "Disallow `void` operators",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-void"
+			},
+			messages: { noVoid: "Expected 'undefined' and instead saw 'void'." },
+			schema: [{
+				type: "object",
+				properties: { allowAsStatement: { type: "boolean" } },
+				additionalProperties: !1
+			}]
+		},
+		create(context) {
+			let [{ allowAsStatement }] = context.options;
+			return { "UnaryExpression[operator=\"void\"]"(node) {
+				allowAsStatement && node.parent && node.parent.type === "ExpressionStatement" || context.report({
+					node,
+					messageId: "noVoid"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-void.cjs
+module.exports = require_no_void().create;
+//#endregion