@conorroberts/utils 0.0.78 → 0.0.82

package/dist/oxlint/index.mjs

@@ -15,7 +15,7 @@ import { definePlugin, defineRule } from "oxlint";
 * @property {boolean} returnsJsx
 */
 const JSX_NODE_TYPES$2 = new Set(["JSXElement", "JSXFragment"]);
-const FUNCTION_NODE_TYPES$4 = new Set([
+const FUNCTION_NODE_TYPES$5 = new Set([
 	"FunctionDeclaration",
 	"FunctionExpression",
 	"ArrowFunctionExpression"
@@ -24,12 +24,12 @@ const FUNCTION_NODE_TYPES$4 = new Set([
 * @param {unknown} node
 * @returns {node is ESTNode & { type: string }}
 */
-const isNode$4 = (node) => Boolean(node && typeof node === "object" && "type" in node);
+const isNode$5 = (node) => Boolean(node && typeof node === "object" && "type" in node);
 /**
 * @param {unknown} node
 * @returns {node is FunctionLikeNode}
 */
-const isFunctionLike$4 = (node) => isNode$4(node) && FUNCTION_NODE_TYPES$4.has(node.type);
+const isFunctionLike$5 = (node) => isNode$5(node) && FUNCTION_NODE_TYPES$5.has(node.type);
 /**
 * @param {unknown} name
 * @returns {name is string}
@@ -50,13 +50,13 @@ const getFunctionName$2 = (node) => {
 		if (node.id.type === "Identifier") return node.id.name;
 	}
 	const parent = node.parent;
-	if (!parent || !isNode$4(parent)) return "";
+	if (!parent || !isNode$5(parent)) return "";
 	if (parent.type === "VariableDeclarator") return parent.id && parent.id.type === "Identifier" ? parent.id.name : "";
 	if (parent.type === "AssignmentExpression") return parent.left && parent.left.type === "Identifier" ? parent.left.name : "";
 	if (parent.type === "Property" || parent.type === "MethodDefinition") return "";
 	if (parent.type === "CallExpression") {
 		const callParent = parent.parent;
-		if (callParent && isNode$4(callParent)) {
+		if (callParent && isNode$5(callParent)) {
 			if (callParent.type === "VariableDeclarator") return callParent.id && callParent.id.type === "Identifier" ? callParent.id.name : "";
 			if (callParent.type === "AssignmentExpression") return callParent.left && callParent.left.type === "Identifier" ? callParent.left.name : "";
 		}
@@ -67,25 +67,25 @@ const getFunctionName$2 = (node) => {
 * @param {ESTExpression | null | undefined} root
 */
 const expressionContainsJsx$2 = (root) => {
-	if (!root || !isNode$4(root)) return false;
+	if (!root || !isNode$5(root)) return false;
 	const stack = [root];
 	while (stack.length > 0) {
 		const current = stack.pop();
-		if (!current || !isNode$4(current)) continue;
+		if (!current || !isNode$5(current)) continue;
 		if (JSX_NODE_TYPES$2.has(current.type)) return true;
-		if (FUNCTION_NODE_TYPES$4.has(current.type) && current !== root) continue;
+		if (FUNCTION_NODE_TYPES$5.has(current.type) && current !== root) continue;
 		for (const key of Object.keys(current)) {
 			if (key === "parent") continue;
 			const value = current[key];
 			if (!value) continue;
 			if (Array.isArray(value)) {
-				for (const element of value) if (isNode$4(element)) stack.push(element);
-			} else if (isNode$4(value)) stack.push(value);
+				for (const element of value) if (isNode$5(element)) stack.push(element);
+			} else if (isNode$5(value)) stack.push(value);
 		}
 	}
 	return false;
 };
-const rule$13 = defineRule({
+const rule$14 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -126,20 +126,20 @@ const rule$13 = defineRule({
 			const fnCtx = currentFunction();
 			if (!fnCtx) return;
 			const argument = node.argument;
-			if (!argument || isFunctionLike$4(argument)) return;
+			if (!argument || isFunctionLike$5(argument)) return;
 			if (expressionContainsJsx$2(argument)) fnCtx.returnsJsx = true;
 		};
 		return {
 			FunctionDeclaration(node) {
-				if (isFunctionLike$4(node)) enterFunction(node);
+				if (isFunctionLike$5(node)) enterFunction(node);
 			},
 			"FunctionDeclaration:exit": exitFunction,
 			FunctionExpression(node) {
-				if (isFunctionLike$4(node)) enterFunction(node);
+				if (isFunctionLike$5(node)) enterFunction(node);
 			},
 			"FunctionExpression:exit": exitFunction,
 			ArrowFunctionExpression(node) {
-				if (isFunctionLike$4(node)) enterFunction(node);
+				if (isFunctionLike$5(node)) enterFunction(node);
 			},
 			"ArrowFunctionExpression:exit": exitFunction,
 			ReturnStatement(node) {
@@ -148,11 +148,11 @@ const rule$13 = defineRule({
 		};
 	}
 });
-const jsxComponentPascalCaseRule = rule$13;
+const jsxComponentPascalCaseRule = rule$14;
 
 //#endregion
 //#region src/oxlint-plugins/no-array-type.js
-const rule$12 = defineRule({
+const rule$13 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -171,7 +171,7 @@ const rule$12 = defineRule({
 		} };
 	}
 });
-const noArrayTypeRule = rule$12;
+const noArrayTypeRule = rule$13;
 
 //#endregion
 //#region src/oxlint-plugins/no-component-date-instantiation.js
@@ -190,7 +190,7 @@ const noArrayTypeRule = rule$12;
 * @property {boolean} returnsJsx
 * @property {NewExpressionNode[]} dateInstantiations
 */
-const FUNCTION_NODE_TYPES$3 = new Set([
+const FUNCTION_NODE_TYPES$4 = new Set([
 	"FunctionDeclaration",
 	"FunctionExpression",
 	"ArrowFunctionExpression"
@@ -199,12 +199,12 @@ const FUNCTION_NODE_TYPES$3 = new Set([
 * @param {unknown} node
 * @returns {node is ESTNode & { type: string }}
 */
-const isNode$3 = (node) => Boolean(node && typeof node === "object" && "type" in node);
+const isNode$4 = (node) => Boolean(node && typeof node === "object" && "type" in node);
 /**
 * @param {unknown} node
 * @returns {node is FunctionLikeNode}
 */
-const isFunctionLike$3 = (node) => isNode$3(node) && FUNCTION_NODE_TYPES$3.has(node.type);
+const isFunctionLike$4 = (node) => isNode$4(node) && FUNCTION_NODE_TYPES$4.has(node.type);
 /**
 * Check if a function name follows React component naming convention (PascalCase)
 * @param {unknown} name
@@ -222,7 +222,7 @@ const getFunctionName$1 = (node) => {
 		if (node.id.type === "Identifier") return node.id.name;
 	}
 	const parent = node.parent;
-	if (!parent || !isNode$3(parent)) return "";
+	if (!parent || !isNode$4(parent)) return "";
 	if (parent.type === "VariableDeclarator") return parent.id && parent.id.type === "Identifier" ? parent.id.name : "";
 	if (parent.type === "AssignmentExpression") return parent.left && parent.left.type === "Identifier" ? parent.left.name : "";
 	if (parent.type === "Property" || parent.type === "MethodDefinition") return parent.key && parent.key.type === "Identifier" ? parent.key.name : "";
@@ -234,7 +234,7 @@ const getFunctionName$1 = (node) => {
 * @returns {boolean}
 */
 const isJSXNode = (node) => {
-	if (!node || !isNode$3(node)) return false;
+	if (!node || !isNode$4(node)) return false;
 	return node.type === "JSXElement" || node.type === "JSXFragment";
 };
 /**
@@ -246,7 +246,7 @@ const isDateInstantiation = (node) => {
 	if (node.callee.type === "Identifier" && node.callee.name === "Date") return true;
 	return false;
 };
-const rule$11 = defineRule({
+const rule$12 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -303,15 +303,15 @@ const rule$11 = defineRule({
 		};
 		return {
 			FunctionDeclaration(node) {
-				if (isFunctionLike$3(node)) enterFunction(node);
+				if (isFunctionLike$4(node)) enterFunction(node);
 			},
 			"FunctionDeclaration:exit": exitFunction,
 			FunctionExpression(node) {
-				if (isFunctionLike$3(node)) enterFunction(node);
+				if (isFunctionLike$4(node)) enterFunction(node);
 			},
 			"FunctionExpression:exit": exitFunction,
 			ArrowFunctionExpression(node) {
-				if (isFunctionLike$3(node)) enterFunction(node);
+				if (isFunctionLike$4(node)) enterFunction(node);
 			},
 			"ArrowFunctionExpression:exit": exitFunction,
 			ReturnStatement(node) {
@@ -323,7 +323,7 @@ const rule$11 = defineRule({
 		};
 	}
 });
-const noComponentDateInstantiationRule = rule$11;
+const noComponentDateInstantiationRule = rule$12;
 
 //#endregion
 //#region src/oxlint-plugins/no-inline-components.js
@@ -358,7 +358,7 @@ const noComponentDateInstantiationRule = rule$11;
 * @property {NestedFunctionRecord[]} nestedJsxChildren
 */
 const JSX_NODE_TYPES$1 = new Set(["JSXElement", "JSXFragment"]);
-const FUNCTION_NODE_TYPES$2 = new Set([
+const FUNCTION_NODE_TYPES$3 = new Set([
 	"FunctionDeclaration",
 	"FunctionExpression",
 	"ArrowFunctionExpression"
@@ -372,23 +372,23 @@ const isComponentName = (name) => typeof name === "string" && /^[A-Z]/.test(name
 * @param {unknown} node
 * @returns {node is ESTNode & { type: string }}
 */
-const isNode$2 = (node) => Boolean(node && typeof node === "object" && "type" in node);
+const isNode$3 = (node) => Boolean(node && typeof node === "object" && "type" in node);
 /**
 * @param {unknown} node
 * @returns {node is FunctionLikeNode}
 */
-const isFunctionLike$2 = (node) => isNode$2(node) && FUNCTION_NODE_TYPES$2.has(node.type);
+const isFunctionLike$3 = (node) => isNode$3(node) && FUNCTION_NODE_TYPES$3.has(node.type);
 /**
 * @param {ESTNode | null | undefined} node
 * @returns {FunctionLikeNode | null}
 */
-const getEnclosingFunction$1 = (node) => {
+const getEnclosingFunction = (node) => {
 	const findFunction = (current) => {
 		if (!current) return null;
-		if (isFunctionLike$2(current)) return current;
-		return findFunction(isNode$2(current) ? current.parent ?? null : null);
+		if (isFunctionLike$3(current)) return current;
+		return findFunction(isNode$3(current) ? current.parent ?? null : null);
 	};
-	return findFunction(isNode$2(node) ? node.parent ?? null : null);
+	return findFunction(isNode$3(node) ? node.parent ?? null : null);
 };
 /**
 * @param {FunctionLikeNode} node
@@ -397,16 +397,16 @@ const isFunctionUsedAsJsxProp = (node) => {
 	const checkJsxProp = (current) => {
 		if (!current) return false;
 		if (current.type === "JSXAttribute") return true;
-		if (isFunctionLike$2(current)) return false;
-		return checkJsxProp(isNode$2(current) ? current.parent ?? null : null);
+		if (isFunctionLike$3(current)) return false;
+		return checkJsxProp(isNode$3(current) ? current.parent ?? null : null);
 	};
-	return checkJsxProp(isNode$2(node) ? node.parent ?? null : null);
+	return checkJsxProp(isNode$3(node) ? node.parent ?? null : null);
 };
 /**
 * @param {FunctionLikeNode} node
 */
 const isFunctionImmediatelyInvoked = (node) => {
-	const parent = isNode$2(node) ? node.parent ?? null : null;
+	const parent = isNode$3(node) ? node.parent ?? null : null;
 	if (!parent) return false;
 	if (parent.type === "CallExpression" && parent.callee === node) return true;
 	return false;
@@ -415,20 +415,20 @@ const isFunctionImmediatelyInvoked = (node) => {
 * @param {ESTExpression | null | undefined} root
 */
 const expressionContainsJsx$1 = (root) => {
-	if (!root || !isNode$2(root)) return false;
+	if (!root || !isNode$3(root)) return false;
 	const stack = [root];
 	while (stack.length > 0) {
 		const current = stack.pop();
-		if (!current || !isNode$2(current)) continue;
+		if (!current || !isNode$3(current)) continue;
 		if (JSX_NODE_TYPES$1.has(current.type)) return true;
-		if (FUNCTION_NODE_TYPES$2.has(current.type) && current !== root) continue;
+		if (FUNCTION_NODE_TYPES$3.has(current.type) && current !== root) continue;
 		for (const key of Object.keys(current)) {
 			if (key === "parent") continue;
 			const value = current[key];
 			if (!value) continue;
 			if (Array.isArray(value)) {
-				for (const element of value) if (isNode$2(element)) stack.push(element);
-			} else if (isNode$2(value)) stack.push(value);
+				for (const element of value) if (isNode$3(element)) stack.push(element);
+			} else if (isNode$3(value)) stack.push(value);
 		}
 	}
 	return false;
@@ -440,7 +440,7 @@ const expressionContainsJsx$1 = (root) => {
 const expressionProducesJsx = (root, bindingNames) => {
 	if (!root) return false;
 	if (expressionContainsJsx$1(root)) return true;
-	if (!isNode$2(root)) return false;
+	if (!isNode$3(root)) return false;
 	const type = root.type;
 	if (type === "Identifier") return bindingNames.has(root.name);
 	if (type === "ConditionalExpression") return expressionProducesJsx(root.consequent, bindingNames) || expressionProducesJsx(root.alternate, bindingNames);
@@ -466,7 +466,7 @@ const expressionProducesJsx = (root, bindingNames) => {
 * @param {string[]} names
 */
 const collectBindingNames = (pattern, names) => {
-	if (!pattern || !isNode$2(pattern)) return;
+	if (!pattern || !isNode$3(pattern)) return;
 	const type = pattern.type;
 	if (type === "Identifier") {
 		names.push(pattern.name);
@@ -503,13 +503,13 @@ const getFunctionName = (node) => {
 		if (node.id.type === "Identifier") return node.id.name;
 	}
 	const parent = node.parent;
-	if (!parent || !isNode$2(parent)) return "";
+	if (!parent || !isNode$3(parent)) return "";
 	if (parent.type === "VariableDeclarator") return parent.id && parent.id.type === "Identifier" ? parent.id.name : "";
 	if (parent.type === "AssignmentExpression") return parent.left && parent.left.type === "Identifier" ? parent.left.name : "";
 	if (parent.type === "Property" || parent.type === "MethodDefinition") return parent.key && parent.key.type === "Identifier" ? parent.key.name : "";
 	if (parent.type === "CallExpression") {
 		const callParent = parent.parent;
-		if (callParent && isNode$2(callParent)) {
+		if (callParent && isNode$3(callParent)) {
 			if (callParent.type === "VariableDeclarator") return callParent.id && callParent.id.type === "Identifier" ? callParent.id.name : "";
 			if (callParent.type === "AssignmentExpression") return callParent.left && callParent.left.type === "Identifier" ? callParent.left.name : "";
 		}
@@ -540,7 +540,7 @@ const createNestedFunctionMessage = (childName, parentName) => `JSX-returning ${
 * @param {string} name
 */
 const createIIFEMessage = (name) => `JSX-returning ${describeNested(name)} should not be declared as an immediately invoked function expression (IIFE). Extract it to a named function at module scope.`;
-const rule$10 = defineRule({
+const rule$11 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -601,7 +601,7 @@ const rule$10 = defineRule({
 			const fnCtx = currentFunction();
 			if (!fnCtx) return;
 			const argument = node.argument;
-			if (!argument || isFunctionLike$2(argument)) return;
+			if (!argument || isFunctionLike$3(argument)) return;
 			if (expressionProducesJsx(argument, fnCtx.jsxBindingNames)) fnCtx.returnsJsx = true;
 		};
 		/** @param {VariableDeclaratorNode} node */
@@ -609,7 +609,7 @@ const rule$10 = defineRule({
 			const fnCtx = currentFunction();
 			if (!fnCtx) return;
 			const init = node.init;
-			if (!init || isFunctionLike$2(init)) return;
+			if (!init || isFunctionLike$3(init)) return;
 			if (!expressionContainsJsx$1(init)) return;
 			const names = [];
 			collectBindingNames(node.id, names);
@@ -625,7 +625,7 @@ const rule$10 = defineRule({
 			const fnCtx = currentFunction();
 			if (!fnCtx) return;
 			const right = node.right;
-			if (!right || isFunctionLike$2(right)) return;
+			if (!right || isFunctionLike$3(right)) return;
 			if (!expressionContainsJsx$1(right)) return;
 			const names = [];
 			if (node.left && node.left.type === "Identifier") {
@@ -662,15 +662,15 @@ const rule$10 = defineRule({
 		};
 		return {
 			FunctionDeclaration(node) {
-				if (isFunctionLike$2(node)) enterFunction(node);
+				if (isFunctionLike$3(node)) enterFunction(node);
 			},
 			"FunctionDeclaration:exit": exitFunction,
 			FunctionExpression(node) {
-				if (isFunctionLike$2(node)) enterFunction(node);
+				if (isFunctionLike$3(node)) enterFunction(node);
 			},
 			"FunctionExpression:exit": exitFunction,
 			ArrowFunctionExpression(node) {
-				if (isFunctionLike$2(node)) enterFunction(node);
+				if (isFunctionLike$3(node)) enterFunction(node);
 			},
 			"ArrowFunctionExpression:exit": exitFunction,
 			ReturnStatement(node) {
@@ -688,7 +688,7 @@ const rule$10 = defineRule({
 		};
 	}
 });
-const noInlineComponentsRule = rule$10;
+const noInlineComponentsRule = rule$11;
 
 //#endregion
 //#region src/oxlint-plugins/no-component-pure-functions.js
@@ -698,7 +698,7 @@ const noInlineComponentsRule = rule$10;
 * @typedef {import("oxlint").ESTree.Function | import("oxlint").ESTree.ArrowFunctionExpression} FunctionLikeNode
 * @typedef {import("oxlint").ESTree.VariableDeclarator} VariableDeclaratorNode
 */
-const FUNCTION_NODE_TYPES$1 = new Set([
+const FUNCTION_NODE_TYPES$2 = new Set([
 	"FunctionDeclaration",
 	"FunctionExpression",
 	"ArrowFunctionExpression"
@@ -707,18 +707,18 @@ const FUNCTION_NODE_TYPES$1 = new Set([
 * @param {unknown} node
 * @returns {node is ESTNode & { type: string }}
 */
-const isNode$1 = (node) => Boolean(node && typeof node === "object" && "type" in node);
+const isNode$2 = (node) => Boolean(node && typeof node === "object" && "type" in node);
 /**
 * @param {unknown} node
 * @returns {node is FunctionLikeNode}
 */
-const isFunctionLike$1 = (node) => isNode$1(node) && FUNCTION_NODE_TYPES$1.has(node.type);
+const isFunctionLike$2 = (node) => isNode$2(node) && FUNCTION_NODE_TYPES$2.has(node.type);
 /**
 * Checks if a node is a React Hook call (e.g., useState, useEffect, useCallback)
 * @param {ESTNode} node
 * @returns {boolean}
 */
-const isReactHookCall = (node) => {
+const isReactHookCall$1 = (node) => {
 	if (node.type !== "CallExpression") return false;
 	const callee = node.callee;
 	if (!callee) return false;
@@ -731,21 +731,21 @@ const isReactHookCall = (node) => {
 * @param {ESTNode} node
 * @returns {boolean}
 */
-const containsJSX = (node) => {
-	if (!node || !isNode$1(node)) return false;
+const containsJSX$1 = (node) => {
+	if (!node || !isNode$2(node)) return false;
 	const stack = [node];
 	while (stack.length > 0) {
 		const current = stack.pop();
-		if (!current || !isNode$1(current)) continue;
+		if (!current || !isNode$2(current)) continue;
 		if (current.type === "JSXElement" || current.type === "JSXFragment") return true;
-		if (isFunctionLike$1(current) && current !== node) continue;
+		if (isFunctionLike$2(current) && current !== node) continue;
 		for (const key of Object.keys(current)) {
 			if (key === "parent") continue;
 			const value = current[key];
 			if (!value) continue;
 			if (Array.isArray(value)) {
-				for (const element of value) if (isNode$1(element)) stack.push(element);
-			} else if (isNode$1(value)) stack.push(value);
+				for (const element of value) if (isNode$2(element)) stack.push(element);
+			} else if (isNode$2(value)) stack.push(value);
 		}
 	}
 	return false;
@@ -757,26 +757,26 @@ const containsJSX = (node) => {
 * @param {Set<string>} localNames - Names of local variables and parameters
 * @returns {boolean}
 */
-const accessesEnclosingScope = (node, localNames) => {
+const accessesEnclosingScope$1 = (node, localNames) => {
 	if (!node.body) return false;
 	const body = node.body;
-	if (body.type !== "BlockStatement") return checkExpressionForScopeAccess(body, localNames);
-	return checkNodeForScopeAccess(body, localNames);
+	if (body.type !== "BlockStatement") return checkExpressionForScopeAccess$1(body, localNames);
+	return checkNodeForScopeAccess$1(body, localNames);
 };
 /**
 * @param {ESTNode} node
 * @param {Set<string>} localNames
 * @returns {boolean}
 */
-const checkNodeForScopeAccess = (node, localNames) => {
-	if (!node || !isNode$1(node)) return false;
+const checkNodeForScopeAccess$1 = (node, localNames) => {
+	if (!node || !isNode$2(node)) return false;
 	const stack = [node];
 	while (stack.length > 0) {
 		const current = stack.pop();
-		if (!current || !isNode$1(current)) continue;
+		if (!current || !isNode$2(current)) continue;
 		if (current.type === "Identifier") {
 			const parent = current.parent;
-			if (parent && isNode$1(parent) && (parent.type === "VariableDeclarator" || parent.type === "FunctionDeclaration" || parent.type === "Property" && parent.key === current)) continue;
+			if (parent && isNode$2(parent) && (parent.type === "VariableDeclarator" || parent.type === "FunctionDeclaration" || parent.type === "Property" && parent.key === current)) continue;
 			if (!localNames.has(current.name)) {
 				if (!new Set([
 					"console",
@@ -811,14 +811,14 @@ const checkNodeForScopeAccess = (node, localNames) => {
 				]).has(current.name)) return true;
 			}
 		}
-		if (isFunctionLike$1(current) && current !== node) continue;
+		if (isFunctionLike$2(current) && current !== node) continue;
 		for (const key of Object.keys(current)) {
 			if (key === "parent") continue;
 			const value = current[key];
 			if (!value) continue;
 			if (Array.isArray(value)) {
-				for (const element of value) if (isNode$1(element)) stack.push(element);
-			} else if (isNode$1(value)) stack.push(value);
+				for (const element of value) if (isNode$2(element)) stack.push(element);
+			} else if (isNode$2(value)) stack.push(value);
 		}
 	}
 	return false;
@@ -828,19 +828,19 @@ const checkNodeForScopeAccess = (node, localNames) => {
 * @param {Set<string>} localNames
 * @returns {boolean}
 */
-const checkExpressionForScopeAccess = (node, localNames) => {
-	return checkNodeForScopeAccess(node, localNames);
+const checkExpressionForScopeAccess$1 = (node, localNames) => {
+	return checkNodeForScopeAccess$1(node, localNames);
 };
 /**
 * Collects all local variable names including parameters
 * @param {FunctionLikeNode} node
 * @returns {Set<string>}
 */
-const collectLocalNames = (node) => {
+const collectLocalNames$1 = (node) => {
 	const names = /* @__PURE__ */ new Set();
-	if (node.params) for (const param of node.params) collectPatternNames(param, names);
+	if (node.params) for (const param of node.params) collectPatternNames$1(param, names);
 	if (node.body && node.body.type === "BlockStatement") {
-		for (const statement of node.body.body) if (statement.type === "VariableDeclaration") for (const declarator of statement.declarations) collectPatternNames(declarator.id, names);
+		for (const statement of node.body.body) if (statement.type === "VariableDeclaration") for (const declarator of statement.declarations) collectPatternNames$1(declarator.id, names);
 	}
 	return names;
 };
@@ -848,8 +848,8 @@ const collectLocalNames = (node) => {
 * @param {import("oxlint").ESTree.Pattern} pattern
 * @param {Set<string>} names
 */
-const collectPatternNames = (pattern, names) => {
-	if (!pattern || !isNode$1(pattern)) return;
+const collectPatternNames$1 = (pattern, names) => {
+	if (!pattern || !isNode$2(pattern)) return;
 	if (pattern.type === "Identifier") {
 		names.add(pattern.name);
 		return;
@@ -857,24 +857,24 @@ const collectPatternNames = (pattern, names) => {
 	if (pattern.type === "ArrayPattern") {
 		for (const element of pattern.elements) {
 			if (!element) continue;
-			if (element.type === "RestElement") collectPatternNames(element.argument, names);
-			else collectPatternNames(element, names);
+			if (element.type === "RestElement") collectPatternNames$1(element.argument, names);
+			else collectPatternNames$1(element, names);
 		}
 		return;
 	}
 	if (pattern.type === "ObjectPattern") {
 		for (const property of pattern.properties) {
 			if (!property) continue;
-			if (property.type === "Property") collectPatternNames(property.value, names);
-			else if (property.type === "RestElement") collectPatternNames(property.argument, names);
+			if (property.type === "Property") collectPatternNames$1(property.value, names);
+			else if (property.type === "RestElement") collectPatternNames$1(property.argument, names);
 		}
 		return;
 	}
 	if (pattern.type === "AssignmentPattern") {
-		collectPatternNames(pattern.left, names);
+		collectPatternNames$1(pattern.left, names);
 		return;
 	}
-	if (pattern.type === "RestElement") collectPatternNames(pattern.argument, names);
+	if (pattern.type === "RestElement") collectPatternNames$1(pattern.argument, names);
 };
 /**
 * Checks if a function is likely a React component
@@ -883,28 +883,28 @@ const collectPatternNames = (pattern, names) => {
 */
 const isReactComponent = (node) => {
 	if (!isComponentName(getFunctionName(node))) return false;
-	return containsJSX(node) || containsHooks(node);
+	return containsJSX$1(node) || containsHooks$1(node);
 };
 /**
 * Checks if a function contains React Hook calls
 * @param {FunctionLikeNode} node
 * @returns {boolean}
 */
-const containsHooks = (node) => {
+const containsHooks$1 = (node) => {
 	if (!node.body) return false;
 	const stack = [node.body];
 	while (stack.length > 0) {
 		const current = stack.pop();
-		if (!current || !isNode$1(current)) continue;
-		if (isReactHookCall(current)) return true;
-		if (isFunctionLike$1(current) && current !== node.body) continue;
+		if (!current || !isNode$2(current)) continue;
+		if (isReactHookCall$1(current)) return true;
+		if (isFunctionLike$2(current) && current !== node.body) continue;
 		for (const key of Object.keys(current)) {
 			if (key === "parent") continue;
 			const value = current[key];
 			if (!value) continue;
 			if (Array.isArray(value)) {
-				for (const element of value) if (isNode$1(element)) stack.push(element);
-			} else if (isNode$1(value)) stack.push(value);
+				for (const element of value) if (isNode$2(element)) stack.push(element);
+			} else if (isNode$2(value)) stack.push(value);
 		}
 	}
 	return false;
@@ -914,10 +914,10 @@ const containsHooks = (node) => {
 * @param {FunctionLikeNode} node
 * @returns {boolean}
 */
-const isWrappedInHook = (node) => {
+const isWrappedInHook$1 = (node) => {
 	const parent = node.parent;
-	if (!parent || !isNode$1(parent)) return false;
-	if (parent.type === "CallExpression" && isReactHookCall(parent)) return true;
+	if (!parent || !isNode$2(parent)) return false;
+	if (parent.type === "CallExpression" && isReactHookCall$1(parent)) return true;
 	return false;
 };
 /**
@@ -925,14 +925,14 @@ const isWrappedInHook = (node) => {
 * @param {FunctionLikeNode} node
 * @returns {boolean}
 */
-const isPureFunction = (node) => {
-	if (containsJSX(node)) return false;
-	if (containsHooks(node)) return false;
-	if (isWrappedInHook(node)) return false;
-	if (accessesEnclosingScope(node, collectLocalNames(node))) return false;
+const isPureFunction$1 = (node) => {
+	if (containsJSX$1(node)) return false;
+	if (containsHooks$1(node)) return false;
+	if (isWrappedInHook$1(node)) return false;
+	if (accessesEnclosingScope$1(node, collectLocalNames$1(node))) return false;
 	return true;
 };
-const rule$9 = defineRule({
+const rule$10 = defineRule({
 	meta: {
 		type: "suggestion",
 		docs: {
@@ -947,11 +947,11 @@ const rule$9 = defineRule({
 		*/
 		const handleVariableDeclarator = (node) => {
 			const init = node.init;
-			if (!init || !isFunctionLike$1(init)) return;
-			const enclosingFunction = getEnclosingFunction$1(node);
+			if (!init || !isFunctionLike$2(init)) return;
+			const enclosingFunction = getEnclosingFunction(node);
 			if (!enclosingFunction) return;
 			if (!isReactComponent(enclosingFunction)) return;
-			if (!isPureFunction(init)) return;
+			if (!isPureFunction$1(init)) return;
 			const functionName = node.id && node.id.type === "Identifier" ? node.id.name : "this function";
 			const componentName = getFunctionName(enclosingFunction);
 			context.report({
@@ -964,12 +964,12 @@ const rule$9 = defineRule({
 		} };
 	}
 });
-const noComponentPureFunctionsRule = rule$9;
+const noComponentPureFunctionsRule = rule$10;
 
 //#endregion
 //#region src/oxlint-plugins/no-delete.js
 /** @typedef {import("oxlint").ESTree.Node} ESTNode */
-const rule$8 = defineRule({
+const rule$9 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -988,7 +988,7 @@ const rule$8 = defineRule({
 		} };
 	}
 });
-const noDeleteRule = rule$8;
+const noDeleteRule = rule$9;
 
 //#endregion
 //#region src/oxlint-plugins/no-emoji.js
@@ -1018,7 +1018,7 @@ const getEmojiPreview = (text) => {
 	const preview = uniqueEmojis.slice(0, 3).join(" ");
 	return uniqueEmojis.length > 3 ? `${preview} ...` : preview;
 };
-const rule$7 = defineRule({
+const rule$8 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -1069,12 +1069,12 @@ const rule$7 = defineRule({
 		};
 	}
 });
-const noEmojiRule = rule$7;
+const noEmojiRule = rule$8;
 
 //#endregion
 //#region src/oxlint-plugins/no-finally.js
 /** @typedef {import("oxlint").ESTree.Node} ESTNode */
-const rule$6 = defineRule({
+const rule$7 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -1093,12 +1093,12 @@ const rule$6 = defineRule({
 		} };
 	}
 });
-const noFinallyRule = rule$6;
+const noFinallyRule = rule$7;
 
 //#endregion
 //#region src/oxlint-plugins/no-iife.js
 /** @typedef {import("oxlint").ESTree.Node} ESTNode */
-const rule$5 = defineRule({
+const rule$6 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -1118,7 +1118,274 @@ const rule$5 = defineRule({
 		} };
 	}
 });
-const noIifeRule = rule$5;
+const noIifeRule = rule$6;
+
+//#endregion
+//#region src/oxlint-plugins/no-nested-pure-functions.js
+/**
+* @typedef {import("oxlint").Context} RuleContext
+* @typedef {import("oxlint").ESTree.Node} ESTNode
+* @typedef {import("oxlint").ESTree.Function | import("oxlint").ESTree.ArrowFunctionExpression} FunctionLikeNode
+* @typedef {import("oxlint").ESTree.VariableDeclarator} VariableDeclaratorNode
+*/
+const FUNCTION_NODE_TYPES$1 = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* @param {unknown} node
+* @returns {node is ESTNode & { type: string }}
+*/
+const isNode$1 = (node) => Boolean(node && typeof node === "object" && "type" in node);
+/**
+* @param {unknown} node
+* @returns {node is FunctionLikeNode}
+*/
+const isFunctionLike$1 = (node) => isNode$1(node) && FUNCTION_NODE_TYPES$1.has(node.type);
+/**
+* Checks if a node is a React Hook call (e.g., useState, useEffect, useCallback)
+* @param {ESTNode} node
+* @returns {boolean}
+*/
+const isReactHookCall = (node) => {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (!callee) return false;
+	if (callee.type === "Identifier" && callee.name.startsWith("use")) return true;
+	if (callee.type === "MemberExpression" && callee.object && callee.object.type === "Identifier" && callee.object.name === "React" && callee.property && callee.property.type === "Identifier" && callee.property.name.startsWith("use")) return true;
+	return false;
+};
+/**
+* Checks if a node contains JSX
+* @param {ESTNode} node
+* @returns {boolean}
+*/
+const containsJSX = (node) => {
+	if (!node || !isNode$1(node)) return false;
+	const stack = [node];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || !isNode$1(current)) continue;
+		if (current.type === "JSXElement" || current.type === "JSXFragment") return true;
+		if (isFunctionLike$1(current) && current !== node) continue;
+		for (const key of Object.keys(current)) {
+			if (key === "parent") continue;
+			const value = current[key];
+			if (!value) continue;
+			if (Array.isArray(value)) {
+				for (const element of value) if (isNode$1(element)) stack.push(element);
+			} else if (isNode$1(value)) stack.push(value);
+		}
+	}
+	return false;
+};
+/**
+* Checks if a function accesses variables from its enclosing scope
+* (excluding function parameters and locally declared variables)
+* @param {FunctionLikeNode} node
+* @param {Set<string>} localNames - Names of local variables and parameters
+* @returns {boolean}
+*/
+const accessesEnclosingScope = (node, localNames) => {
+	if (!node.body) return false;
+	const body = node.body;
+	if (body.type !== "BlockStatement") return checkExpressionForScopeAccess(body, localNames);
+	return checkNodeForScopeAccess(body, localNames);
+};
+/**
+* @param {ESTNode} node
+* @param {Set<string>} localNames
+* @returns {boolean}
+*/
+const checkNodeForScopeAccess = (node, localNames) => {
+	if (!node || !isNode$1(node)) return false;
+	const stack = [node];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || !isNode$1(current)) continue;
+		if (current.type === "Identifier") {
+			const parent = current.parent;
+			if (parent && isNode$1(parent) && (parent.type === "VariableDeclarator" || parent.type === "FunctionDeclaration" || parent.type === "Property" && parent.key === current)) continue;
+			if (!localNames.has(current.name)) {
+				if (!new Set([
+					"console",
+					"Math",
+					"Date",
+					"JSON",
+					"Object",
+					"Array",
+					"String",
+					"Number",
+					"Boolean",
+					"parseInt",
+					"parseFloat",
+					"isNaN",
+					"isFinite",
+					"undefined",
+					"null",
+					"true",
+					"false",
+					"Infinity",
+					"NaN",
+					"Map",
+					"Set",
+					"WeakMap",
+					"WeakSet",
+					"Promise",
+					"Symbol",
+					"Error",
+					"TypeError",
+					"ReferenceError",
+					"SyntaxError"
+				]).has(current.name)) return true;
+			}
+		}
+		if (isFunctionLike$1(current) && current !== node) continue;
+		for (const key of Object.keys(current)) {
+			if (key === "parent") continue;
+			const value = current[key];
+			if (!value) continue;
+			if (Array.isArray(value)) {
+				for (const element of value) if (isNode$1(element)) stack.push(element);
+			} else if (isNode$1(value)) stack.push(value);
+		}
+	}
+	return false;
+};
+/**
+* @param {ESTNode} node
+* @param {Set<string>} localNames
+* @returns {boolean}
+*/
+const checkExpressionForScopeAccess = (node, localNames) => {
+	return checkNodeForScopeAccess(node, localNames);
+};
+/**
+* Collects all local variable names including parameters
+* @param {FunctionLikeNode} node
+* @returns {Set<string>}
+*/
+const collectLocalNames = (node) => {
+	const names = /* @__PURE__ */ new Set();
+	if (node.params) for (const param of node.params) collectPatternNames(param, names);
+	if (node.body && node.body.type === "BlockStatement") {
+		for (const statement of node.body.body) if (statement.type === "VariableDeclaration") for (const declarator of statement.declarations) collectPatternNames(declarator.id, names);
+	}
+	return names;
+};
+/**
+* @param {import("oxlint").ESTree.Pattern} pattern
+* @param {Set<string>} names
+*/
+const collectPatternNames = (pattern, names) => {
+	if (!pattern || !isNode$1(pattern)) return;
+	if (pattern.type === "Identifier") {
+		names.add(pattern.name);
+		return;
+	}
+	if (pattern.type === "ArrayPattern") {
+		for (const element of pattern.elements) {
+			if (!element) continue;
+			if (element.type === "RestElement") collectPatternNames(element.argument, names);
+			else collectPatternNames(element, names);
+		}
+		return;
+	}
+	if (pattern.type === "ObjectPattern") {
+		for (const property of pattern.properties) {
+			if (!property) continue;
+			if (property.type === "Property") collectPatternNames(property.value, names);
+			else if (property.type === "RestElement") collectPatternNames(property.argument, names);
+		}
+		return;
+	}
+	if (pattern.type === "AssignmentPattern") {
+		collectPatternNames(pattern.left, names);
+		return;
+	}
+	if (pattern.type === "RestElement") collectPatternNames(pattern.argument, names);
+};
+/**
+* Checks if a function contains React Hook calls
+* @param {FunctionLikeNode} node
+* @returns {boolean}
+*/
+const containsHooks = (node) => {
+	if (!node.body) return false;
+	const stack = [node.body];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || !isNode$1(current)) continue;
+		if (isReactHookCall(current)) return true;
+		if (isFunctionLike$1(current) && current !== node.body) continue;
+		for (const key of Object.keys(current)) {
+			if (key === "parent") continue;
+			const value = current[key];
+			if (!value) continue;
+			if (Array.isArray(value)) {
+				for (const element of value) if (isNode$1(element)) stack.push(element);
+			} else if (isNode$1(value)) stack.push(value);
+		}
+	}
+	return false;
+};
+/**
+* Checks if a function is wrapped in a React Hook (useCallback, useMemo, etc.)
+* @param {FunctionLikeNode} node
+* @returns {boolean}
+*/
+const isWrappedInHook = (node) => {
+	const parent = node.parent;
+	if (!parent || !isNode$1(parent)) return false;
+	if (parent.type === "CallExpression" && isReactHookCall(parent)) return true;
+	return false;
+};
+/**
+* Checks if a function is pure (doesn't access enclosing scope, hooks, or JSX)
+* @param {FunctionLikeNode} node
+* @returns {boolean}
+*/
+const isPureFunction = (node) => {
+	if (containsJSX(node)) return false;
+	if (containsHooks(node)) return false;
+	if (isWrappedInHook(node)) return false;
+	if (accessesEnclosingScope(node, collectLocalNames(node))) return false;
+	return true;
+};
+const rule$5 = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prevent declaring named pure functions inside other functions. Pure functions should be extracted to module scope for better performance and reusability.",
+			recommended: false
+		},
+		schema: []
+	},
+	createOnce(context) {
+		/**
+		* @param {VariableDeclaratorNode} node
+		*/
+		const handleVariableDeclarator = (node) => {
+			const init = node.init;
+			if (!init || !isFunctionLike$1(init)) return;
+			if (!node.id || node.id.type !== "Identifier") return;
+			const functionName = node.id.name;
+			const enclosingFunction = getEnclosingFunction(node);
+			if (!enclosingFunction) return;
+			if (!isPureFunction(init)) return;
+			const enclosingFunctionName = getFunctionName(enclosingFunction);
+			context.report({
+				node: init,
+				message: `Named pure function '${functionName}' should not be declared inside '${enclosingFunctionName}'. Extract it to module scope.`
+			});
+		};
+		return { VariableDeclarator(node) {
+			if (node.type === "VariableDeclarator") handleVariableDeclarator(node);
+		} };
+	}
+});
+const noNestedPureFunctionsRule = rule$5;
 
 //#endregion
 //#region src/oxlint-plugins/no-promise-then.js
@@ -1239,38 +1506,11 @@ const noSwitchRule = defineRule({
 //#endregion
 //#region src/oxlint-plugins/no-top-level-let.js
 /** @typedef {import("oxlint").ESTree.Node} ESTNode */
-/**
-* Get the enclosing function node for a given node
-* @param {ESTNode} node
-* @returns {ESTNode | null}
-*/
-const getEnclosingFunction = (node) => {
-	const findFunction = (current) => {
-		if (!current) return null;
-		if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") return current;
-		return findFunction(current.parent);
-	};
-	return findFunction(node.parent);
-};
-/**
-* Check if a node is inside a loop
-* @param {ESTNode} node
-* @param {ESTNode} stopAt - Stop searching when we reach this node
-* @returns {boolean}
-*/
-const isInsideLoop = (node, stopAt) => {
-	const checkLoop = (current) => {
-		if (!current || current === stopAt) return false;
-		if (current.type === "ForStatement" || current.type === "ForInStatement" || current.type === "ForOfStatement" || current.type === "WhileStatement" || current.type === "DoWhileStatement") return true;
-		return checkLoop(current.parent);
-	};
-	return checkLoop(node.parent);
-};
 const rule$2 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
-			description: "Disallow top-level `let` declarations inside functions to prevent conditional reassignment.",
+			description: "Disallow `let` keyword everywhere except in for loop initializers.",
 			recommended: false
 		},
 		schema: []
@@ -1280,14 +1520,14 @@ const rule$2 = defineRule({
 			if (rawNode.type !== "VariableDeclaration") return;
 			const node = rawNode;
 			if (node.kind !== "let") return;
-			const fn = getEnclosingFunction(node);
-			if (!fn || fn.type !== "FunctionDeclaration" && fn.type !== "FunctionExpression" && fn.type !== "ArrowFunctionExpression") return;
 			const parent = node.parent;
-			if (!parent || parent.type !== "BlockStatement" || parent.parent !== fn) return;
-			if (isInsideLoop(node, fn)) return;
+			if (parent) {
+				if (parent.type === "ForStatement" && parent.init === node) return;
+				if ((parent.type === "ForInStatement" || parent.type === "ForOfStatement") && parent.left === node) return;
+			}
 			context.report({
 				node,
-				message: "Avoid using `let` at the top level of functions; prefer `const` with extracted functions to avoid conditional reassignment. Extract conditional logic into a separate function that returns the appropriate value."
+				message: "Avoid using `let`; prefer `const` or use `let` only in for loop initializers."
 			});
 		} };
 	}
@@ -1514,6 +1754,7 @@ const plugin = definePlugin({
 		"no-finally": noFinallyRule,
 		"no-iife": noIifeRule,
 		"no-inline-components": noInlineComponentsRule,
+		"no-nested-pure-functions": noNestedPureFunctionsRule,
 		"no-promise-then": noPromiseThenRule,
 		"no-react-namespace": noReactNamespaceRule,
 		"no-switch": noSwitchRule,