oxlint-plugin-eslint 1.52.0

package/rules/no-tabs.cjs

@@ -0,0 +1,73 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-tabs.js
+/**
+* @fileoverview Rule to check for tabs inside a file
+* @author Gyandeep Singh
+* @deprecated in ESLint v8.53.0
+*/
+var require_no_tabs = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let tabRegex = /\t+/gu, anyNonWhitespaceRegex = /\S/u;
+	/** @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: "no-tabs",
+						url: "https://eslint.style/rules/no-tabs"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Disallow all tabs",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-tabs"
+			},
+			schema: [{
+				type: "object",
+				properties: { allowIndentationTabs: {
+					type: "boolean",
+					default: !1
+				} },
+				additionalProperties: !1
+			}],
+			messages: { unexpectedTab: "Unexpected tab character." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, allowIndentationTabs = context.options && context.options[0] && context.options[0].allowIndentationTabs;
+			return { Program(node) {
+				sourceCode.getLines().forEach((line, index) => {
+					let match;
+					for (; (match = tabRegex.exec(line)) !== null;) allowIndentationTabs && !anyNonWhitespaceRegex.test(line.slice(0, match.index)) || context.report({
+						node,
+						loc: {
+							start: {
+								line: index + 1,
+								column: match.index
+							},
+							end: {
+								line: index + 1,
+								column: match.index + match[0].length
+							}
+						},
+						messageId: "unexpectedTab"
+					});
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-tabs.cjs
+module.exports = require_no_tabs().create;
+//#endregion

package/rules/no-template-curly-in-string.cjs

@@ -0,0 +1,33 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-template-curly-in-string.js
+/**
+* @fileoverview Warn when using template string syntax in regular strings
+* @author Jeroen Engels
+*/
+var require_no_template_curly_in_string = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow template literal placeholder syntax in regular strings",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-template-curly-in-string"
+			},
+			schema: [],
+			messages: { unexpectedTemplateExpression: "Unexpected template string expression." }
+		},
+		create(context) {
+			let regex = /\$\{[^}]+\}/u;
+			return { Literal(node) {
+				typeof node.value == "string" && regex.test(node.value) && context.report({
+					node,
+					messageId: "unexpectedTemplateExpression"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-template-curly-in-string.cjs
+module.exports = require_no_template_curly_in_string().create;
+//#endregion

package/rules/no-ternary.cjs

@@ -0,0 +1,33 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-ternary.js
+/**
+* @fileoverview Rule to flag use of ternary operators.
+* @author Ian Christian Myers
+*/
+var require_no_ternary = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow ternary operators",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-ternary"
+			},
+			schema: [],
+			messages: { noTernaryOperator: "Ternary operator used." }
+		},
+		create(context) {
+			return { ConditionalExpression(node) {
+				context.report({
+					node,
+					messageId: "noTernaryOperator"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-ternary.cjs
+module.exports = require_no_ternary().create;
+//#endregion

package/rules/no-this-before-super.cjs

@@ -0,0 +1,177 @@
+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-this-before-super.js
+/**
+* @fileoverview A rule to disallow using `this`/`super` before `super()`.
+* @author Toru Nagashima
+*/
+var require_no_this_before_super = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* 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";
+	}
+	/**
+	*
+	*/
+	var SegmentInfo = class {
+		/**
+		* Indicates whether `super()` is called in all code paths.
+		* @type {boolean}
+		*/
+		superCalled = !1;
+		/**
+		* The array of invalid ThisExpression and Super nodes.
+		* @type {ASTNode[]}
+		*/
+		invalidNodes = [];
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow `this`/`super` before calling `super()` in constructors",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-this-before-super"
+			},
+			schema: [],
+			messages: { noBeforeSuper: "'{{kind}}' is not allowed before 'super()'." }
+		},
+		create(context) {
+			let funcInfo = null, segInfoMap = Object.create(null);
+			/**
+			* Gets whether or not `super()` is called in a given code path segment.
+			* @param {CodePathSegment} segment A code path segment to get.
+			* @returns {boolean} `true` if `super()` is called.
+			*/
+			function isCalled(segment) {
+				return !segment.reachable || segInfoMap[segment.id]?.superCalled;
+			}
+			/**
+			* Checks whether or not this is in a constructor.
+			* @returns {boolean} `true` if this is in a constructor.
+			*/
+			function isInConstructorOfDerivedClass() {
+				return !!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends);
+			}
+			/**
+			* Determines if every segment in a set has been called.
+			* @param {Set<CodePathSegment>} segments The segments to search.
+			* @returns {boolean} True if every segment has been called; false otherwise.
+			*/
+			function isEverySegmentCalled(segments) {
+				for (let segment of segments) if (!isCalled(segment)) return !1;
+				return !0;
+			}
+			/**
+			* Checks whether or not this is before `super()` is called.
+			* @returns {boolean} `true` if this is before `super()` is called.
+			*/
+			function isBeforeCallOfSuper() {
+				return isInConstructorOfDerivedClass() && !isEverySegmentCalled(funcInfo.currentSegments);
+			}
+			/**
+			* Sets a given node as invalid.
+			* @param {ASTNode} node A node to set as invalid. This is one of
+			*      a ThisExpression and a Super.
+			* @returns {void}
+			*/
+			function setInvalid(node) {
+				let segments = funcInfo.currentSegments;
+				for (let segment of segments) segment.reachable && segInfoMap[segment.id].invalidNodes.push(node);
+			}
+			/**
+			* Sets the current segment as `super` was called.
+			* @returns {void}
+			*/
+			function setSuperCalled() {
+				let segments = funcInfo.currentSegments;
+				for (let segment of segments) segment.reachable && (segInfoMap[segment.id].superCalled = !0);
+			}
+			return {
+				onCodePathStart(codePath, node) {
+					if (isConstructorFunction(node)) {
+						let classNode = node.parent.parent.parent;
+						funcInfo = {
+							upper: funcInfo,
+							isConstructor: !0,
+							hasExtends: !!(classNode.superClass && !astUtils.isNullOrUndefined(classNode.superClass)),
+							codePath,
+							currentSegments: /* @__PURE__ */ new Set()
+						};
+					} else funcInfo = {
+						upper: funcInfo,
+						isConstructor: !1,
+						hasExtends: !1,
+						codePath,
+						currentSegments: /* @__PURE__ */ new Set()
+					};
+				},
+				onCodePathEnd(codePath) {
+					let isDerivedClass = funcInfo.hasExtends;
+					if (funcInfo = funcInfo.upper, !isDerivedClass) return;
+					/**
+					* A collection of nodes to avoid duplicate reports.
+					* @type {Set<ASTNode>}
+					*/
+					let reported = /* @__PURE__ */ new Set();
+					codePath.traverseSegments((segment, controller) => {
+						let info = segInfoMap[segment.id], invalidNodes = info.invalidNodes.filter((node) => !reported.has(node));
+						for (let invalidNode of invalidNodes) reported.add(invalidNode), context.report({
+							messageId: "noBeforeSuper",
+							node: invalidNode,
+							data: { kind: invalidNode.type === "Super" ? "super" : "this" }
+						});
+						info.superCalled && controller.skip();
+					});
+				},
+				onCodePathSegmentStart(segment) {
+					funcInfo.currentSegments.add(segment), isInConstructorOfDerivedClass() && (segInfoMap[segment.id] = {
+						superCalled: segment.prevSegments.length > 0 && segment.prevSegments.every(isCalled),
+						invalidNodes: []
+					});
+				},
+				onUnreachableCodePathSegmentStart(segment) {
+					funcInfo.currentSegments.add(segment);
+				},
+				onUnreachableCodePathSegmentEnd(segment) {
+					funcInfo.currentSegments.delete(segment);
+				},
+				onCodePathSegmentEnd(segment) {
+					funcInfo.currentSegments.delete(segment);
+				},
+				onCodePathSegmentLoop(fromSegment, toSegment) {
+					isInConstructorOfDerivedClass() && funcInfo.codePath.traverseSegments({
+						first: toSegment,
+						last: fromSegment
+					}, (segment, controller) => {
+						let info = segInfoMap[segment.id] ?? new SegmentInfo();
+						info.superCalled ? controller.skip() : segment.prevSegments.length > 0 && segment.prevSegments.every(isCalled) && (info.superCalled = !0), segInfoMap[segment.id] = info;
+					});
+				},
+				ThisExpression(node) {
+					isBeforeCallOfSuper() && setInvalid(node);
+				},
+				Super(node) {
+					!astUtils.isCallee(node) && isBeforeCallOfSuper() && setInvalid(node);
+				},
+				"CallExpression:exit"(node) {
+					node.callee.type === "Super" && isBeforeCallOfSuper() && setSuperCalled();
+				},
+				"Program:exit"() {
+					segInfoMap = Object.create(null);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-this-before-super.cjs
+module.exports = require_no_this_before_super().create;
+//#endregion

package/rules/no-throw-literal.cjs

@@ -0,0 +1,40 @@
+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-throw-literal.js
+/**
+* @fileoverview Rule to restrict what can be thrown as an exception.
+* @author Dieter Oberkofler
+*/
+var require_no_throw_literal = /* @__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 throwing literals as exceptions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-throw-literal"
+			},
+			schema: [],
+			messages: {
+				object: "Expected an error object to be thrown.",
+				undef: "Do not throw undefined."
+			}
+		},
+		create(context) {
+			return { ThrowStatement(node) {
+				astUtils.couldBeError(node.argument) ? node.argument.type === "Identifier" && node.argument.name === "undefined" && context.report({
+					node,
+					messageId: "undef"
+				}) : context.report({
+					node,
+					messageId: "object"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-throw-literal.cjs
+module.exports = require_no_throw_literal().create;
+//#endregion

package/rules/no-trailing-spaces.cjs

@@ -0,0 +1,123 @@
+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-trailing-spaces.js
+/**
+* @fileoverview Disallow trailing spaces at the end of lines.
+* @author Nodeca Team <https://github.com/nodeca>
+* @deprecated in ESLint v8.53.0
+*/
+var require_no_trailing_spaces = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	/**
+	* @import { SourceLocation, SourceRange } from "@eslint/core";
+	*/
+	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: "no-trailing-spaces",
+						url: "https://eslint.style/rules/no-trailing-spaces"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Disallow trailing whitespace at the end of lines",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-trailing-spaces"
+			},
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: {
+					skipBlankLines: {
+						type: "boolean",
+						default: !1
+					},
+					ignoreComments: {
+						type: "boolean",
+						default: !1
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: { trailingSpace: "Trailing spaces not allowed." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, BLANK_CLASS = "[ 	\xA0           ​　]", SKIP_BLANK = `^${BLANK_CLASS}*$`, NONBLANK = `${BLANK_CLASS}+$`, options = context.options[0] || {}, skipBlankLines = options.skipBlankLines || !1, ignoreComments = options.ignoreComments || !1;
+			/**
+			* Report the error message
+			* @param {ASTNode} node node to report
+			* @param {SourceLocation} location range information
+			* @param {SourceRange} fixRange Range based on the whole program
+			* @returns {void}
+			*/
+			function report(node, location, fixRange) {
+				context.report({
+					node,
+					loc: location,
+					messageId: "trailingSpace",
+					fix(fixer) {
+						return fixer.removeRange(fixRange);
+					}
+				});
+			}
+			/**
+			* Given a list of comment nodes, return the line numbers for those comments.
+			* @param {Array} comments An array of comment nodes.
+			* @returns {number[]} An array of line numbers containing comments.
+			*/
+			function getCommentLineNumbers(comments) {
+				let lines = /* @__PURE__ */ new Set();
+				return comments.forEach((comment) => {
+					let endLine = comment.type === "Block" ? comment.loc.end.line - 1 : comment.loc.end.line;
+					for (let i = comment.loc.start.line; i <= endLine; i++) lines.add(i);
+				}), lines;
+			}
+			return { Program: function checkTrailingSpaces(node) {
+				let re = new RegExp(NONBLANK, "u"), skipMatch = new RegExp(SKIP_BLANK, "u"), lines = sourceCode.lines, linebreaks = sourceCode.getText().match(astUtils.createGlobalLinebreakMatcher()), commentLineNumbers = getCommentLineNumbers(sourceCode.getAllComments()), totalLength = 0;
+				for (let i = 0, ii = lines.length; i < ii; i++) {
+					let lineNumber = i + 1, linebreakLength = linebreaks && linebreaks[i] ? linebreaks[i].length : 1, lineLength = lines[i].length + linebreakLength, matches = re.exec(lines[i]);
+					if (matches) {
+						let location = {
+							start: {
+								line: lineNumber,
+								column: matches.index
+							},
+							end: {
+								line: lineNumber,
+								column: lineLength - linebreakLength
+							}
+						}, rangeStart = totalLength + location.start.column, rangeEnd = totalLength + location.end.column, containingNode = sourceCode.getNodeByRangeIndex(rangeStart);
+						if (containingNode && containingNode.type === "TemplateElement" && rangeStart > containingNode.parent.range[0] && rangeEnd < containingNode.parent.range[1]) {
+							totalLength += lineLength;
+							continue;
+						}
+						if (skipBlankLines && skipMatch.test(lines[i])) {
+							totalLength += lineLength;
+							continue;
+						}
+						let fixRange = [rangeStart, rangeEnd];
+						(!ignoreComments || !commentLineNumbers.has(lineNumber)) && report(node, location, fixRange);
+					}
+					totalLength += lineLength;
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-trailing-spaces.cjs
+module.exports = require_no_trailing_spaces().create;
+//#endregion

package/rules/no-unassigned-vars.cjs

@@ -0,0 +1,54 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-unassigned-vars.js
+/**
+* @fileoverview Rule to flag variables that are never assigned
+* @author Jacob Bandes-Storch <https://github.com/jtbandes>
+*/
+var require_no_unassigned_vars = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			dialects: ["typescript", "javascript"],
+			language: "javascript",
+			docs: {
+				description: "Disallow `let` or `var` variables that are read but never assigned",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-unassigned-vars"
+			},
+			schema: [],
+			messages: { unassigned: "'{{name}}' is always 'undefined' because it's never assigned." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, insideDeclareModule = !1;
+			return {
+				"TSModuleDeclaration[declare=true]"() {
+					insideDeclareModule = !0;
+				},
+				"TSModuleDeclaration[declare=true]:exit"() {
+					insideDeclareModule = !1;
+				},
+				VariableDeclarator(node) {
+					/** @type {import('estree').VariableDeclaration} */
+					let declaration = node.parent;
+					if (node.init || node.id.type !== "Identifier" || declaration.kind === "const" || declaration.declare || insideDeclareModule) return;
+					let [variable] = sourceCode.getDeclaredVariables(node);
+					if (!variable) return;
+					let hasRead = !1;
+					for (let reference of variable.references) {
+						if (reference.isWrite()) return;
+						reference.isRead() && (hasRead = !0);
+					}
+					hasRead && context.report({
+						node,
+						messageId: "unassigned",
+						data: { name: node.id.name }
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-unassigned-vars.cjs
+module.exports = require_no_unassigned_vars().create;
+//#endregion

package/rules/no-undef-init.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-undef-init.js
+/**
+* @fileoverview Rule to flag when initializing to undefined
+* @author Ilya Volodin
+*/
+var require_no_undef_init = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), CONSTANT_BINDINGS = new Set([
+		"const",
+		"using",
+		"await using"
+	]);
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow initializing variables to `undefined`",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-undef-init"
+			},
+			schema: [],
+			fixable: "code",
+			messages: { unnecessaryUndefinedInit: "It's not necessary to initialize '{{name}}' to undefined." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { VariableDeclarator(node) {
+				let name = sourceCode.getText(node.id), init = node.init && node.init.name, scope = sourceCode.getScope(node), undefinedVar = astUtils.getVariableByName(scope, "undefined"), shadowed = undefinedVar && undefinedVar.defs.length > 0, lastToken = sourceCode.getLastToken(node);
+				init === "undefined" && !CONSTANT_BINDINGS.has(node.parent.kind) && !shadowed && context.report({
+					node,
+					messageId: "unnecessaryUndefinedInit",
+					data: { name },
+					fix(fixer) {
+						return node.parent.kind === "var" || node.id.type === "ArrayPattern" || node.id.type === "ObjectPattern" || sourceCode.commentsExistBetween(node.id, lastToken) ? null : fixer.removeRange([node.id.range[1], node.range[1]]);
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-undef-init.cjs
+module.exports = require_no_undef_init().create;
+//#endregion

package/rules/no-undef.cjs

@@ -0,0 +1,51 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-undef.js
+/**
+* @fileoverview Rule to flag references to undeclared variables.
+* @author Mark Macdonald
+*/
+var require_no_undef = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/**
+	* Checks if the given node is the argument of a typeof operator.
+	* @param {ASTNode} node The AST node being checked.
+	* @returns {boolean} Whether or not the node is the argument of a typeof operator.
+	*/
+	function hasTypeOfOperator(node) {
+		let parent = node.parent;
+		return parent.type === "UnaryExpression" && parent.operator === "typeof";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{ typeof: !1 }],
+			docs: {
+				description: "Disallow the use of undeclared variables unless mentioned in `/*global */` comments",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-undef"
+			},
+			schema: [{
+				type: "object",
+				properties: { typeof: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: { undef: "'{{name}}' is not defined." }
+		},
+		create(context) {
+			let [{ typeof: considerTypeOf }] = context.options, sourceCode = context.sourceCode;
+			return { "Program:exit"(node) {
+				sourceCode.getScope(node).through.forEach((ref) => {
+					let identifier = ref.identifier;
+					!considerTypeOf && hasTypeOfOperator(identifier) || context.report({
+						node: identifier,
+						messageId: "undef",
+						data: identifier
+					});
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-undef.cjs
+module.exports = require_no_undef().create;
+//#endregion