oxlint-plugin-eslint 1.52.0

package/rules/getter-return.cjs

@@ -0,0 +1,129 @@
+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/getter-return.js
+/**
+* @fileoverview Enforces that a return statement is present in property getters.
+* @author Aladdin-ADD(hh_2013@foxmail.com)
+*/
+var require_getter_return = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;
+	/**
+	* 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: "problem",
+			defaultOptions: [{ allowImplicit: !1 }],
+			docs: {
+				description: "Enforce `return` statements in getters",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/getter-return"
+			},
+			fixable: null,
+			schema: [{
+				type: "object",
+				properties: { allowImplicit: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: {
+				expected: "Expected to return a value in {{name}}.",
+				expectedAlways: "Expected {{name}} to always return a value."
+			}
+		},
+		create(context) {
+			let [{ allowImplicit }] = context.options, sourceCode = context.sourceCode, funcInfo = {
+				upper: null,
+				codePath: null,
+				hasReturn: !1,
+				shouldCheck: !1,
+				node: null,
+				currentSegments: []
+			};
+			/**
+			* Checks whether or not the last code path segment is reachable.
+			* Then reports this function if the segment is reachable.
+			*
+			* If the last code path segment is reachable, there are paths which are not
+			* returned or thrown.
+			* @param {ASTNode} node A node to check.
+			* @returns {void}
+			*/
+			function checkLastSegment(node) {
+				funcInfo.shouldCheck && isAnySegmentReachable(funcInfo.currentSegments) && context.report({
+					node,
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					messageId: funcInfo.hasReturn ? "expectedAlways" : "expected",
+					data: { name: astUtils.getFunctionNameWithKind(funcInfo.node) }
+				});
+			}
+			/**
+			* Checks whether a node means a getter function.
+			* @param {ASTNode} node a node to check.
+			* @returns {boolean} if node means a getter, return true; else return false.
+			*/
+			function isGetter(node) {
+				let parent = node.parent;
+				if (TARGET_NODE_TYPE.test(node.type) && node.body.type === "BlockStatement") {
+					if (parent.kind === "get") return !0;
+					if (parent.type === "Property" && astUtils.getStaticPropertyName(parent) === "get" && parent.parent.type === "ObjectExpression") {
+						if (parent.parent.parent.type === "CallExpression") {
+							let callNode = parent.parent.parent.callee;
+							if (astUtils.isSpecificMemberAccess(callNode, "Object", "defineProperty") || astUtils.isSpecificMemberAccess(callNode, "Reflect", "defineProperty")) return !0;
+						}
+						if (parent.parent.parent.type === "Property" && parent.parent.parent.parent.type === "ObjectExpression" && parent.parent.parent.parent.parent.type === "CallExpression") {
+							let callNode = parent.parent.parent.parent.parent.callee;
+							return astUtils.isSpecificMemberAccess(callNode, "Object", "defineProperties") || astUtils.isSpecificMemberAccess(callNode, "Object", "create");
+						}
+					}
+				}
+				return !1;
+			}
+			return {
+				onCodePathStart(codePath, node) {
+					funcInfo = {
+						upper: funcInfo,
+						codePath,
+						hasReturn: !1,
+						shouldCheck: isGetter(node),
+						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) {
+					funcInfo.shouldCheck && (funcInfo.hasReturn = !0, !allowImplicit && !node.argument && context.report({
+						node,
+						messageId: "expected",
+						data: { name: astUtils.getFunctionNameWithKind(funcInfo.node) }
+					}));
+				},
+				"FunctionExpression:exit": checkLastSegment,
+				"ArrowFunctionExpression:exit": checkLastSegment
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/getter-return.cjs
+module.exports = require_getter_return().create;
+//#endregion

package/rules/global-require.cjs

@@ -0,0 +1,84 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/global-require.js
+/**
+* @fileoverview Rule for disallowing require() outside of the top-level module context
+* @author Jamund Ferguson
+* @deprecated in ESLint v7.0.0
+*/
+var require_global_require = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let ACCEPTABLE_PARENTS = new Set([
+		"AssignmentExpression",
+		"VariableDeclarator",
+		"MemberExpression",
+		"ExpressionStatement",
+		"CallExpression",
+		"ConditionalExpression",
+		"Program",
+		"VariableDeclaration",
+		"ChainExpression"
+	]);
+	/**
+	* Finds the eslint-scope reference in the given scope.
+	* @param {Object} scope The scope to search.
+	* @param {ASTNode} node The identifier node.
+	* @returns {Reference|null} Returns the found reference or null if none were found.
+	*/
+	function findReference(scope, node) {
+		let references = scope.references.filter((reference) => reference.identifier.range[0] === node.range[0] && reference.identifier.range[1] === node.range[1]);
+		/* c8 ignore next */
+		return references.length === 1 ? references[0] : null;
+	}
+	/**
+	* Checks if the given identifier node is shadowed in the given scope.
+	* @param {Object} scope The current scope.
+	* @param {ASTNode} node The identifier node to check.
+	* @returns {boolean} Whether or not the name is shadowed.
+	*/
+	function isShadowed(scope, node) {
+		let reference = findReference(scope, node);
+		return reference && reference.resolved && reference.resolved.defs.length > 0;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Node.js rules were moved out of ESLint core.",
+				url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+				deprecatedSince: "7.0.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "eslint-plugin-n now maintains deprecated Node.js-related rules.",
+					plugin: {
+						name: "eslint-plugin-n",
+						url: "https://github.com/eslint-community/eslint-plugin-n"
+					},
+					rule: {
+						name: "global-require",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/global-require.md"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Require `require()` calls to be placed at top-level module scope",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/global-require"
+			},
+			schema: [],
+			messages: { unexpected: "Unexpected require()." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { CallExpression(node) {
+				let currentScope = sourceCode.getScope(node);
+				node.callee.name === "require" && !isShadowed(currentScope, node.callee) && (sourceCode.getAncestors(node).every((parent) => ACCEPTABLE_PARENTS.has(parent.type)) || context.report({
+					node,
+					messageId: "unexpected"
+				}));
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/global-require.cjs
+module.exports = require_global_require().create;
+//#endregion

package/rules/grouped-accessor-pairs.cjs

@@ -0,0 +1,146 @@
+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/grouped-accessor-pairs.js
+/**
+* @fileoverview Rule to require grouped accessor pairs in object literals and classes
+* @author Milos Djermanovic
+*/
+var require_grouped_accessor_pairs = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Property name if it can be computed statically, otherwise the list of the tokens of the key node.
+	* @typedef {string|Token[]} Key
+	*/
+	/**
+	* Accessor nodes with the same key.
+	* @typedef {Object} AccessorData
+	* @property {Key} key Accessor's key
+	* @property {ASTNode[]} getters List of getter nodes.
+	* @property {ASTNode[]} setters List of setter nodes.
+	*/
+	/**
+	* Checks whether or not the given lists represent the equal tokens in the same order.
+	* Tokens are compared by their properties, not by instance.
+	* @param {Token[]} left First list of tokens.
+	* @param {Token[]} right Second list of tokens.
+	* @returns {boolean} `true` if the lists have same tokens.
+	*/
+	function areEqualTokenLists(left, right) {
+		if (left.length !== right.length) return !1;
+		for (let i = 0; i < left.length; i++) {
+			let leftToken = left[i], rightToken = right[i];
+			if (leftToken.type !== rightToken.type || leftToken.value !== rightToken.value) return !1;
+		}
+		return !0;
+	}
+	/**
+	* Checks whether or not the given keys are equal.
+	* @param {Key} left First key.
+	* @param {Key} right Second key.
+	* @returns {boolean} `true` if the keys are equal.
+	*/
+	function areEqualKeys(left, right) {
+		return typeof left == "string" && typeof right == "string" ? left === right : Array.isArray(left) && Array.isArray(right) ? areEqualTokenLists(left, right) : !1;
+	}
+	/**
+	* Checks whether or not a given node is of an accessor kind ('get' or 'set').
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node is of an accessor kind.
+	*/
+	function isAccessorKind(node) {
+		return node.kind === "get" || node.kind === "set";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: ["anyOrder", { enforceForTSTypes: !1 }],
+			docs: {
+				description: "Require grouped accessor pairs in object literals and classes",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/grouped-accessor-pairs"
+			},
+			schema: [{ enum: [
+				"anyOrder",
+				"getBeforeSet",
+				"setBeforeGet"
+			] }, {
+				type: "object",
+				properties: { enforceForTSTypes: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: {
+				notGrouped: "Accessor pair {{ formerName }} and {{ latterName }} should be grouped.",
+				invalidOrder: "Expected {{ latterName }} to be before {{ formerName }}."
+			}
+		},
+		create(context) {
+			let [order, { enforceForTSTypes }] = context.options, { sourceCode } = context;
+			/**
+			* Reports the given accessor pair.
+			* @param {string} messageId messageId to report.
+			* @param {ASTNode} formerNode getter/setter node that is defined before `latterNode`.
+			* @param {ASTNode} latterNode getter/setter node that is defined after `formerNode`.
+			* @returns {void}
+			* @private
+			*/
+			function report(messageId, formerNode, latterNode) {
+				context.report({
+					node: latterNode,
+					messageId,
+					loc: astUtils.getFunctionHeadLoc(latterNode.type === "TSMethodSignature" ? latterNode : latterNode.value, sourceCode),
+					data: {
+						formerName: astUtils.getFunctionNameWithKind(formerNode.type === "TSMethodSignature" ? formerNode : formerNode.value),
+						latterName: astUtils.getFunctionNameWithKind(latterNode.type === "TSMethodSignature" ? latterNode : latterNode.value)
+					}
+				});
+			}
+			/**
+			* Checks accessor pairs in the given list of nodes.
+			* @param {ASTNode[]} nodes The list to check.
+			* @param {Function} shouldCheck – Predicate that returns `true` if the node should be checked.
+			* @returns {void}
+			* @private
+			*/
+			function checkList(nodes, shouldCheck) {
+				let accessors = [], found = !1;
+				for (let i = 0; i < nodes.length; i++) {
+					let node = nodes[i];
+					if (shouldCheck(node) && isAccessorKind(node)) {
+						let name = astUtils.getStaticPropertyName(node), key = name === null ? sourceCode.getTokens(node.key) : name;
+						for (let j = 0; j < accessors.length; j++) {
+							let accessor = accessors[j];
+							if (areEqualKeys(accessor.key, key)) {
+								accessor.getters.push(...node.kind === "get" ? [node] : []), accessor.setters.push(...node.kind === "set" ? [node] : []), found = !0;
+								break;
+							}
+						}
+						found || accessors.push({
+							key,
+							getters: node.kind === "get" ? [node] : [],
+							setters: node.kind === "set" ? [node] : []
+						}), found = !1;
+					}
+				}
+				for (let { getters, setters } of accessors) if (getters.length === 1 && setters.length === 1) {
+					let [getter] = getters, [setter] = setters, getterIndex = nodes.indexOf(getter), setterIndex = nodes.indexOf(setter), formerNode = getterIndex < setterIndex ? getter : setter, latterNode = getterIndex < setterIndex ? setter : getter;
+					Math.abs(getterIndex - setterIndex) > 1 ? report("notGrouped", formerNode, latterNode) : (order === "getBeforeSet" && getterIndex > setterIndex || order === "setBeforeGet" && getterIndex < setterIndex) && report("invalidOrder", formerNode, latterNode);
+				}
+			}
+			return {
+				ObjectExpression(node) {
+					checkList(node.properties, (n) => n.type === "Property");
+				},
+				ClassBody(node) {
+					checkList(node.body, (n) => n.type === "MethodDefinition" && !n.static), checkList(node.body, (n) => n.type === "MethodDefinition" && n.static);
+				},
+				"TSTypeLiteral, TSInterfaceBody"(node) {
+					enforceForTSTypes && checkList(node.type === "TSTypeLiteral" ? node.members : node.body, (n) => n.type === "TSMethodSignature");
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/grouped-accessor-pairs.cjs
+module.exports = require_grouped_accessor_pairs().create;
+//#endregion

package/rules/guard-for-in.cjs

@@ -0,0 +1,39 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/guard-for-in.js
+/**
+* @fileoverview Rule to flag for-in loops without if statements inside
+* @author Nicholas C. Zakas
+*/
+var require_guard_for_in = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require `for-in` loops to include an `if` statement",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/guard-for-in"
+			},
+			schema: [],
+			messages: { wrap: "The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype." }
+		},
+		create(context) {
+			return { ForInStatement(node) {
+				let body = node.body;
+				if (body.type !== "EmptyStatement" && body.type !== "IfStatement" && !(body.type === "BlockStatement" && body.body.length === 0) && !(body.type === "BlockStatement" && body.body.length === 1 && body.body[0].type === "IfStatement")) {
+					if (body.type === "BlockStatement" && body.body.length >= 1 && body.body[0].type === "IfStatement") {
+						let i = body.body[0];
+						if (i.consequent.type === "ContinueStatement" || i.consequent.type === "BlockStatement" && i.consequent.body.length === 1 && i.consequent.body[0].type === "ContinueStatement") return;
+					}
+					context.report({
+						node,
+						messageId: "wrap"
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/guard-for-in.cjs
+module.exports = require_guard_for_in().create;
+//#endregion

package/rules/handle-callback-err.cjs

@@ -0,0 +1,86 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/handle-callback-err.js
+/**
+* @fileoverview Ensure handling of errors when we know they exist.
+* @author Jamund Ferguson
+* @deprecated in ESLint v7.0.0
+*/
+var require_handle_callback_err = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Node.js rules were moved out of ESLint core.",
+				url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+				deprecatedSince: "7.0.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "eslint-plugin-n now maintains deprecated Node.js-related rules.",
+					plugin: {
+						name: "eslint-plugin-n",
+						url: "https://github.com/eslint-community/eslint-plugin-n"
+					},
+					rule: {
+						name: "handle-callback-err",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/handle-callback-err.md"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Require error handling in callbacks",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/handle-callback-err"
+			},
+			schema: [{ type: "string" }],
+			messages: { expected: "Expected error to be handled." }
+		},
+		create(context) {
+			let errorArgument = context.options[0] || "err", sourceCode = context.sourceCode;
+			/**
+			* Checks if the given argument should be interpreted as a regexp pattern.
+			* @param {string} stringToCheck The string which should be checked.
+			* @returns {boolean} Whether or not the string should be interpreted as a pattern.
+			*/
+			function isPattern(stringToCheck) {
+				return stringToCheck[0] === "^";
+			}
+			/**
+			* Checks if the given name matches the configured error argument.
+			* @param {string} name The name which should be compared.
+			* @returns {boolean} Whether or not the given name matches the configured error variable name.
+			*/
+			function matchesConfiguredErrorName(name) {
+				return isPattern(errorArgument) ? new RegExp(errorArgument, "u").test(name) : name === errorArgument;
+			}
+			/**
+			* Get the parameters of a given function scope.
+			* @param {Object} scope The function scope.
+			* @returns {Array} All parameters of the given scope.
+			*/
+			function getParameters(scope) {
+				return scope.variables.filter((variable) => variable.defs[0] && variable.defs[0].type === "Parameter");
+			}
+			/**
+			* Check to see if we're handling the error object properly.
+			* @param {ASTNode} node The AST node to check.
+			* @returns {void}
+			*/
+			function checkForError(node) {
+				let firstParameter = getParameters(sourceCode.getScope(node))[0];
+				firstParameter && matchesConfiguredErrorName(firstParameter.name) && firstParameter.references.length === 0 && context.report({
+					node,
+					messageId: "expected"
+				});
+			}
+			return {
+				FunctionDeclaration: checkForError,
+				FunctionExpression: checkForError,
+				ArrowFunctionExpression: checkForError
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/handle-callback-err.cjs
+module.exports = require_handle_callback_err().create;
+//#endregion

package/rules/id-blacklist.cjs

@@ -0,0 +1,135 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/id-blacklist.js
+/**
+* @fileoverview Rule that warns when identifier names that are
+* specified in the configuration are used.
+* @author Keith Cirkel (http://keithcirkel.co.uk)
+* @deprecated in ESLint v7.5.0
+*/
+var require_id_blacklist = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/**
+	* Checks whether the given node represents assignment target in a normal assignment or destructuring.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} `true` if the node is assignment target.
+	*/
+	function isAssignmentTarget(node) {
+		let parent = node.parent;
+		return parent.type === "AssignmentExpression" && parent.left === node || parent.type === "ArrayPattern" || parent.type === "RestElement" || parent.type === "Property" && parent.value === node && parent.parent.type === "ObjectPattern" || parent.type === "AssignmentPattern" && parent.left === node;
+	}
+	/**
+	* Checks whether the given node represents an imported name that is renamed in the same import/export specifier.
+	*
+	* Examples:
+	* import { a as b } from 'mod'; // node `a` is renamed import
+	* export { a as b } from 'mod'; // node `a` is renamed import
+	* @param {ASTNode} node `Identifier` node to check.
+	* @returns {boolean} `true` if the node is a renamed import.
+	*/
+	function isRenamedImport(node) {
+		let parent = node.parent;
+		return parent.type === "ImportSpecifier" && parent.imported !== parent.local && parent.imported === node || parent.type === "ExportSpecifier" && parent.parent.source && parent.local !== parent.exported && parent.local === node;
+	}
+	/**
+	* Checks whether the given node is a renamed identifier node in an ObjectPattern destructuring.
+	*
+	* Examples:
+	* const { a : b } = foo; // node `a` is renamed node.
+	* @param {ASTNode} node `Identifier` node to check.
+	* @returns {boolean} `true` if the node is a renamed node in an ObjectPattern destructuring.
+	*/
+	function isRenamedInDestructuring(node) {
+		let parent = node.parent;
+		return !parent.computed && parent.type === "Property" && parent.parent.type === "ObjectPattern" && parent.value !== node && parent.key === node;
+	}
+	/**
+	* Checks whether the given node represents shorthand definition of a property in an object literal.
+	* @param {ASTNode} node `Identifier` node to check.
+	* @returns {boolean} `true` if the node is a shorthand property definition.
+	*/
+	function isShorthandPropertyDefinition(node) {
+		let parent = node.parent;
+		return parent.type === "Property" && parent.parent.type === "ObjectExpression" && parent.shorthand;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "The rule was renamed.",
+				url: "https://eslint.org/blog/2020/07/eslint-v7.5.0-released/#deprecating-id-blacklist",
+				deprecatedSince: "7.5.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{ rule: {
+					name: "id-denylist",
+					url: "https://eslint.org/docs/rules/id-denylist"
+				} }]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Disallow specified identifiers",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/id-blacklist"
+			},
+			schema: {
+				type: "array",
+				items: { type: "string" },
+				uniqueItems: !0
+			},
+			messages: { restricted: "Identifier '{{name}}' is restricted." }
+		},
+		create(context) {
+			let denyList = new Set(context.options), reportedNodes = /* @__PURE__ */ new Set(), sourceCode = context.sourceCode, globalScope;
+			/**
+			* Checks whether the given name is restricted.
+			* @param {string} name The name to check.
+			* @returns {boolean} `true` if the name is restricted.
+			* @private
+			*/
+			function isRestricted(name) {
+				return denyList.has(name);
+			}
+			/**
+			* Checks whether the given node represents a reference to a global variable that is not declared in the source code.
+			* These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
+			* @param {ASTNode} node `Identifier` node to check.
+			* @returns {boolean} `true` if the node is a reference to a global variable.
+			*/
+			function isReferenceToGlobalVariable(node) {
+				let variable = globalScope.set.get(node.name);
+				return variable && variable.defs.length === 0 && variable.references.some((ref) => ref.identifier === node);
+			}
+			/**
+			* Determines whether the given node should be checked.
+			* @param {ASTNode} node `Identifier` node.
+			* @returns {boolean} `true` if the node should be checked.
+			*/
+			function shouldCheck(node) {
+				let parent = node.parent;
+				return parent.type === "MemberExpression" && parent.property === node && !parent.computed ? isAssignmentTarget(parent) : parent.type !== "CallExpression" && parent.type !== "NewExpression" && !isRenamedImport(node) && !isRenamedInDestructuring(node) && !(isReferenceToGlobalVariable(node) && !isShorthandPropertyDefinition(node));
+			}
+			/**
+			* Reports an AST node as a rule violation.
+			* @param {ASTNode} node The node to report.
+			* @returns {void}
+			* @private
+			*/
+			function report(node) {
+				reportedNodes.has(node.range.toString()) || (context.report({
+					node,
+					messageId: "restricted",
+					data: { name: node.name }
+				}), reportedNodes.add(node.range.toString()));
+			}
+			return {
+				Program(node) {
+					globalScope = sourceCode.getScope(node);
+				},
+				Identifier(node) {
+					isRestricted(node.name) && shouldCheck(node) && report(node);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/id-blacklist.cjs
+module.exports = require_id_blacklist().create;
+//#endregion