@conorroberts/utils 0.0.67 → 0.0.69

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$3 = new Set([
+const FUNCTION_NODE_TYPES$4 = new Set([
 	"FunctionDeclaration",
 	"FunctionExpression",
 	"ArrowFunctionExpression"
@@ -24,12 +24,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);
 /**
 * @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$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 "";
 	if (parent.type === "CallExpression") {
 		const callParent = parent.parent;
-		if (callParent && isNode$3(callParent)) {
+		if (callParent && isNode$4(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$3(root)) return false;
+	if (!root || !isNode$4(root)) return false;
 	const stack = [root];
 	while (stack.length > 0) {
 		const current = stack.pop();
-		if (!current || !isNode$3(current)) continue;
+		if (!current || !isNode$4(current)) continue;
 		if (JSX_NODE_TYPES$2.has(current.type)) return true;
-		if (FUNCTION_NODE_TYPES$3.has(current.type) && current !== root) continue;
+		if (FUNCTION_NODE_TYPES$4.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$3(element)) stack.push(element);
-			} else if (isNode$3(value)) stack.push(value);
+				for (const element of value) if (isNode$4(element)) stack.push(element);
+			} else if (isNode$4(value)) stack.push(value);
 		}
 	}
 	return false;
 };
-const rule$10 = defineRule({
+const rule$11 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -126,20 +126,20 @@ const rule$10 = defineRule({
 			const fnCtx = currentFunction();
 			if (!fnCtx) return;
 			const argument = node.argument;
-			if (!argument || isFunctionLike$3(argument)) return;
+			if (!argument || isFunctionLike$4(argument)) return;
 			if (expressionContainsJsx$2(argument)) fnCtx.returnsJsx = true;
 		};
 		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) {
@@ -148,11 +148,11 @@ const rule$10 = defineRule({
 		};
 	}
 });
-const jsxComponentPascalCaseRule = rule$10;
+const jsxComponentPascalCaseRule = rule$11;
 
 //#endregion
 //#region src/oxlint-plugins/no-array-type.js
-const rule$9 = defineRule({
+const rule$10 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -171,7 +171,7 @@ const rule$9 = defineRule({
 		} };
 	}
 });
-const noArrayTypeRule = rule$9;
+const noArrayTypeRule = rule$10;
 
 //#endregion
 //#region src/oxlint-plugins/no-component-date-instantiation.js
@@ -190,7 +190,7 @@ const noArrayTypeRule = rule$9;
 * @property {boolean} returnsJsx
 * @property {NewExpressionNode[]} dateInstantiations
 */
-const FUNCTION_NODE_TYPES$2 = new Set([
+const FUNCTION_NODE_TYPES$3 = new Set([
 	"FunctionDeclaration",
 	"FunctionExpression",
 	"ArrowFunctionExpression"
@@ -199,18 +199,18 @@ const FUNCTION_NODE_TYPES$2 = new Set([
 * @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);
 /**
 * Check if a function name follows React component naming convention (PascalCase)
 * @param {unknown} name
 * @returns {name is string}
 */
-const isComponentName = (name) => typeof name === "string" && /^[A-Z]/.test(name);
+const isComponentName$1 = (name) => typeof name === "string" && /^[A-Z]/.test(name);
 /**
 * Get the name of a function node
 * @param {FunctionLikeNode} node
@@ -222,7 +222,7 @@ const getFunctionName$1 = (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 : "";
@@ -234,7 +234,7 @@ const getFunctionName$1 = (node) => {
 * @returns {boolean}
 */
 const isJSXNode = (node) => {
-	if (!node || !isNode$2(node)) return false;
+	if (!node || !isNode$3(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$8 = defineRule({
+const rule$9 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -280,7 +280,7 @@ const rule$8 = defineRule({
 			const fnCtx = functionStack.pop();
 			if (!fnCtx) return;
 			if (!fnCtx.returnsJsx) return;
-			if (!isComponentName(fnCtx.name)) return;
+			if (!isComponentName$1(fnCtx.name)) return;
 			for (const dateNode of fnCtx.dateInstantiations) context.report({
 				node: dateNode,
 				message: `Avoid instantiating Date in the top scope of component '${fnCtx.name}'. Date instances change on every render. Move it inside an effect, event handler, or use useMemo/useCallback.`
@@ -303,15 +303,15 @@ const rule$8 = 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) {
@@ -323,136 +323,7 @@ const rule$8 = defineRule({
 		};
 	}
 });
-const noComponentDateInstantiationRule = rule$8;
-
-//#endregion
-//#region src/oxlint-plugins/no-delete.js
-/** @typedef {import("oxlint").ESTree.Node} ESTNode */
-const rule$7 = defineRule({
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow the 'delete' operator",
-			recommended: true
-		},
-		schema: []
-	},
-	createOnce(context) {
-		return { UnaryExpression(node) {
-			if (node.type !== "UnaryExpression") return;
-			if (node.operator === "delete") context.report({
-				node,
-				message: "Use of 'delete' operator is disallowed. Use object destructuring or set properties to undefined instead."
-			});
-		} };
-	}
-});
-const noDeleteRule = rule$7;
-
-//#endregion
-//#region src/oxlint-plugins/no-emoji.js
-/** @typedef {import("oxlint").ESTree.Node} ESTNode */
-/**
-* Regex pattern to match emojis
-* Covers most common emoji ranges in Unicode
-*/
-const EMOJI_REGEX = /[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1F000}-\u{1F02F}\u{1F0A0}-\u{1F0FF}\u{1F100}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{1F900}-\u{1F9FF}\u{1FA00}-\u{1FA6F}\u{1FA70}-\u{1FAFF}\u{FE00}-\u{FE0F}\u{203C}\u{2049}\u{20E3}\u{2139}\u{2194}-\u{2199}\u{21A9}-\u{21AA}\u{231A}-\u{231B}\u{2328}\u{23CF}\u{23E9}-\u{23F3}\u{23F8}-\u{23FA}\u{24C2}\u{25AA}-\u{25AB}\u{25B6}\u{25C0}\u{25FB}-\u{25FE}\u{2600}-\u{2604}\u{260E}\u{2611}\u{2614}-\u{2615}\u{2618}\u{261D}\u{2620}\u{2622}-\u{2623}\u{2626}\u{262A}\u{262E}-\u{262F}\u{2638}-\u{263A}\u{2640}\u{2642}\u{2648}-\u{2653}\u{265F}-\u{2660}\u{2663}\u{2665}-\u{2666}\u{2668}\u{267B}\u{267E}-\u{267F}\u{2692}-\u{2697}\u{2699}\u{269B}-\u{269C}\u{26A0}-\u{26A1}\u{26A7}\u{26AA}-\u{26AB}\u{26B0}-\u{26B1}\u{26BD}-\u{26BE}\u{26C4}-\u{26C5}\u{26C8}\u{26CE}\u{26CF}\u{26D1}\u{26D3}-\u{26D4}\u{26E9}-\u{26EA}\u{26F0}-\u{26F5}\u{26F7}-\u{26FA}\u{26FD}\u{2702}\u{2705}\u{2708}-\u{270D}\u{270F}\u{2712}\u{2714}\u{2716}\u{271D}\u{2721}\u{2728}\u{2733}-\u{2734}\u{2744}\u{2747}\u{274C}\u{274E}\u{2753}-\u{2755}\u{2757}\u{2763}-\u{2764}\u{2795}-\u{2797}\u{27A1}\u{27B0}\u{27BF}\u{2934}-\u{2935}\u{2B05}-\u{2B07}\u{2B1B}-\u{2B1C}\u{2B50}\u{2B55}\u{3030}\u{303D}\u{3297}\u{3299}]/gu;
-/**
-* Find emojis in a string
-* @param {string} text
-* @returns {RegExpMatchArray | null}
-*/
-const findEmojis = (text) => {
-	return text.match(EMOJI_REGEX);
-};
-/**
-* Get a preview of the emoji found
-* @param {string} text
-* @returns {string}
-*/
-const getEmojiPreview = (text) => {
-	const emojis = findEmojis(text);
-	if (!emojis || emojis.length === 0) return "";
-	const uniqueEmojis = [...new Set(emojis)];
-	const preview = uniqueEmojis.slice(0, 3).join(" ");
-	return uniqueEmojis.length > 3 ? `${preview} ...` : preview;
-};
-const rule$6 = defineRule({
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow the use of emojis in code. Use icons from a component library instead.",
-			recommended: true
-		},
-		schema: []
-	},
-	createOnce(context) {
-		return {
-			StringLiteral(node) {
-				if (node.type !== "StringLiteral") return;
-				const emojis = findEmojis(node.value);
-				if (emojis && emojis.length > 0) {
-					const preview = getEmojiPreview(node.value);
-					context.report({
-						node,
-						message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`
-					});
-				}
-			},
-			TemplateLiteral(node) {
-				if (node.type !== "TemplateLiteral") return;
-				for (const quasi of node.quasis) {
-					if (quasi.type !== "TemplateElement") continue;
-					const text = quasi.value.raw;
-					const emojis = findEmojis(text);
-					if (emojis && emojis.length > 0) {
-						const preview = getEmojiPreview(text);
-						context.report({
-							node: quasi,
-							message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`
-						});
-					}
-				}
-			},
-			JSXText(node) {
-				if (node.type !== "JSXText") return;
-				const emojis = findEmojis(node.value);
-				if (emojis && emojis.length > 0) {
-					const preview = getEmojiPreview(node.value);
-					context.report({
-						node,
-						message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`
-					});
-				}
-			}
-		};
-	}
-});
-const noEmojiRule = rule$6;
-
-//#endregion
-//#region src/oxlint-plugins/no-finally.js
-/** @typedef {import("oxlint").ESTree.Node} ESTNode */
-const rule$5 = defineRule({
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow 'finally' blocks in try/catch/finally statements",
-			recommended: true
-		},
-		schema: []
-	},
-	createOnce(context) {
-		return { TryStatement(node) {
-			if (node.type !== "TryStatement") return;
-			if (node.finalizer) context.report({
-				node: node.finalizer,
-				message: "Use of 'finally' blocks is disallowed. Handle cleanup explicitly in try/catch blocks instead."
-			});
-		} };
-	}
-});
-const noFinallyRule = rule$5;
+const noComponentDateInstantiationRule = rule$9;
 
 //#endregion
 //#region src/oxlint-plugins/no-inline-components.js
@@ -487,21 +358,38 @@ const noFinallyRule = rule$5;
 * @property {NestedFunctionRecord[]} nestedJsxChildren
 */
 const JSX_NODE_TYPES$1 = new Set(["JSXElement", "JSXFragment"]);
-const FUNCTION_NODE_TYPES$1 = new Set([
+const FUNCTION_NODE_TYPES$2 = new Set([
 	"FunctionDeclaration",
 	"FunctionExpression",
 	"ArrowFunctionExpression"
 ]);
 /**
+* @param {unknown} name
+* @returns {name is string}
+*/
+const isComponentName = (name) => typeof name === "string" && /^[A-Z]/.test(name);
+/**
 * @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);
+/**
+* @param {ESTNode | null | undefined} node
+* @returns {FunctionLikeNode | null}
+*/
+const getEnclosingFunction$1 = (node) => {
+	const findFunction = (current) => {
+		if (!current) return null;
+		if (isFunctionLike$2(current)) return current;
+		return findFunction(isNode$2(current) ? current.parent ?? null : null);
+	};
+	return findFunction(isNode$2(node) ? node.parent ?? null : null);
+};
 /**
 * @param {FunctionLikeNode} node
 */
@@ -509,16 +397,16 @@ const isFunctionUsedAsJsxProp = (node) => {
 	const checkJsxProp = (current) => {
 		if (!current) return false;
 		if (current.type === "JSXAttribute") return true;
-		if (isFunctionLike$1(current)) return false;
-		return checkJsxProp(isNode$1(current) ? current.parent ?? null : null);
+		if (isFunctionLike$2(current)) return false;
+		return checkJsxProp(isNode$2(current) ? current.parent ?? null : null);
 	};
-	return checkJsxProp(isNode$1(node) ? node.parent ?? null : null);
+	return checkJsxProp(isNode$2(node) ? node.parent ?? null : null);
 };
 /**
 * @param {FunctionLikeNode} node
 */
 const isFunctionImmediatelyInvoked = (node) => {
-	const parent = isNode$1(node) ? node.parent ?? null : null;
+	const parent = isNode$2(node) ? node.parent ?? null : null;
 	if (!parent) return false;
 	if (parent.type === "CallExpression" && parent.callee === node) return true;
 	return false;
@@ -527,20 +415,20 @@ const isFunctionImmediatelyInvoked = (node) => {
 * @param {ESTExpression | null | undefined} root
 */
 const expressionContainsJsx$1 = (root) => {
-	if (!root || !isNode$1(root)) return false;
+	if (!root || !isNode$2(root)) return false;
 	const stack = [root];
 	while (stack.length > 0) {
 		const current = stack.pop();
-		if (!current || !isNode$1(current)) continue;
+		if (!current || !isNode$2(current)) continue;
 		if (JSX_NODE_TYPES$1.has(current.type)) return true;
-		if (FUNCTION_NODE_TYPES$1.has(current.type) && current !== root) continue;
+		if (FUNCTION_NODE_TYPES$2.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$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;
@@ -552,7 +440,7 @@ const expressionContainsJsx$1 = (root) => {
 const expressionProducesJsx = (root, bindingNames) => {
 	if (!root) return false;
 	if (expressionContainsJsx$1(root)) return true;
-	if (!isNode$1(root)) return false;
+	if (!isNode$2(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);
@@ -578,7 +466,7 @@ const expressionProducesJsx = (root, bindingNames) => {
 * @param {string[]} names
 */
 const collectBindingNames = (pattern, names) => {
-	if (!pattern || !isNode$1(pattern)) return;
+	if (!pattern || !isNode$2(pattern)) return;
 	const type = pattern.type;
 	if (type === "Identifier") {
 		names.push(pattern.name);
@@ -615,13 +503,13 @@ const getFunctionName = (node) => {
 		if (node.id.type === "Identifier") return node.id.name;
 	}
 	const parent = node.parent;
-	if (!parent || !isNode$1(parent)) return "";
+	if (!parent || !isNode$2(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$1(callParent)) {
+		if (callParent && isNode$2(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 : "";
 		}
@@ -652,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$4 = defineRule({
+const rule$8 = defineRule({
 	meta: {
 		type: "problem",
 		docs: {
@@ -713,7 +601,7 @@ const rule$4 = defineRule({
 			const fnCtx = currentFunction();
 			if (!fnCtx) return;
 			const argument = node.argument;
-			if (!argument || isFunctionLike$1(argument)) return;
+			if (!argument || isFunctionLike$2(argument)) return;
 			if (expressionProducesJsx(argument, fnCtx.jsxBindingNames)) fnCtx.returnsJsx = true;
 		};
 		/** @param {VariableDeclaratorNode} node */
@@ -721,7 +609,7 @@ const rule$4 = defineRule({
 			const fnCtx = currentFunction();
 			if (!fnCtx) return;
 			const init = node.init;
-			if (!init || isFunctionLike$1(init)) return;
+			if (!init || isFunctionLike$2(init)) return;
 			if (!expressionContainsJsx$1(init)) return;
 			const names = [];
 			collectBindingNames(node.id, names);
@@ -737,7 +625,7 @@ const rule$4 = defineRule({
 			const fnCtx = currentFunction();
 			if (!fnCtx) return;
 			const right = node.right;
-			if (!right || isFunctionLike$1(right)) return;
+			if (!right || isFunctionLike$2(right)) return;
 			if (!expressionContainsJsx$1(right)) return;
 			const names = [];
 			if (node.left && node.left.type === "Identifier") {
@@ -774,15 +662,15 @@ const rule$4 = defineRule({
 		};
 		return {
 			FunctionDeclaration(node) {
-				if (isFunctionLike$1(node)) enterFunction(node);
+				if (isFunctionLike$2(node)) enterFunction(node);
 			},
 			"FunctionDeclaration:exit": exitFunction,
 			FunctionExpression(node) {
-				if (isFunctionLike$1(node)) enterFunction(node);
+				if (isFunctionLike$2(node)) enterFunction(node);
 			},
 			"FunctionExpression:exit": exitFunction,
 			ArrowFunctionExpression(node) {
-				if (isFunctionLike$1(node)) enterFunction(node);
+				if (isFunctionLike$2(node)) enterFunction(node);
 			},
 			"ArrowFunctionExpression:exit": exitFunction,
 			ReturnStatement(node) {
@@ -800,7 +688,412 @@ const rule$4 = defineRule({
 		};
 	}
 });
-const noInlineComponentsRule = rule$4;
+const noInlineComponentsRule = rule$8;
+
+//#endregion
+//#region src/oxlint-plugins/no-component-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 is likely a React component
+* @param {FunctionLikeNode} node
+* @returns {boolean}
+*/
+const isReactComponent = (node) => {
+	if (!isComponentName(getFunctionName(node))) return false;
+	return containsJSX(node) || containsHooks(node);
+};
+/**
+* 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 component 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$7 = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Recommend extracting pure functions from React components to module scope for better performance and readability.",
+			recommended: false
+		},
+		schema: []
+	},
+	createOnce(context) {
+		/**
+		* @param {VariableDeclaratorNode} node
+		*/
+		const handleVariableDeclarator = (node) => {
+			const init = node.init;
+			if (!init || !isFunctionLike$1(init)) return;
+			const enclosingFunction = getEnclosingFunction$1(node);
+			if (!enclosingFunction) return;
+			if (!isReactComponent(enclosingFunction)) return;
+			if (!isPureFunction(init)) return;
+			const functionName = node.id && node.id.type === "Identifier" ? node.id.name : "this function";
+			const componentName = getFunctionName(enclosingFunction);
+			context.report({
+				node: init,
+				message: `Pure function '${functionName}' can be extracted outside of component '${componentName}' to improve performance and readability.`
+			});
+		};
+		return { VariableDeclarator(node) {
+			if (node.type === "VariableDeclarator") handleVariableDeclarator(node);
+		} };
+	}
+});
+const noComponentPureFunctionsRule = rule$7;
+
+//#endregion
+//#region src/oxlint-plugins/no-delete.js
+/** @typedef {import("oxlint").ESTree.Node} ESTNode */
+const rule$6 = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow the 'delete' operator",
+			recommended: true
+		},
+		schema: []
+	},
+	createOnce(context) {
+		return { UnaryExpression(node) {
+			if (node.type !== "UnaryExpression") return;
+			if (node.operator === "delete") context.report({
+				node,
+				message: "Use of 'delete' operator is disallowed. Use object destructuring or set properties to undefined instead."
+			});
+		} };
+	}
+});
+const noDeleteRule = rule$6;
+
+//#endregion
+//#region src/oxlint-plugins/no-emoji.js
+/** @typedef {import("oxlint").ESTree.Node} ESTNode */
+/**
+* Regex pattern to match emojis
+* Covers most common emoji ranges in Unicode
+*/
+const EMOJI_REGEX = /[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1F000}-\u{1F02F}\u{1F0A0}-\u{1F0FF}\u{1F100}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{1F900}-\u{1F9FF}\u{1FA00}-\u{1FA6F}\u{1FA70}-\u{1FAFF}\u{FE00}-\u{FE0F}\u{203C}\u{2049}\u{20E3}\u{2139}\u{2194}-\u{2199}\u{21A9}-\u{21AA}\u{231A}-\u{231B}\u{2328}\u{23CF}\u{23E9}-\u{23F3}\u{23F8}-\u{23FA}\u{24C2}\u{25AA}-\u{25AB}\u{25B6}\u{25C0}\u{25FB}-\u{25FE}\u{2600}-\u{2604}\u{260E}\u{2611}\u{2614}-\u{2615}\u{2618}\u{261D}\u{2620}\u{2622}-\u{2623}\u{2626}\u{262A}\u{262E}-\u{262F}\u{2638}-\u{263A}\u{2640}\u{2642}\u{2648}-\u{2653}\u{265F}-\u{2660}\u{2663}\u{2665}-\u{2666}\u{2668}\u{267B}\u{267E}-\u{267F}\u{2692}-\u{2697}\u{2699}\u{269B}-\u{269C}\u{26A0}-\u{26A1}\u{26A7}\u{26AA}-\u{26AB}\u{26B0}-\u{26B1}\u{26BD}-\u{26BE}\u{26C4}-\u{26C5}\u{26C8}\u{26CE}\u{26CF}\u{26D1}\u{26D3}-\u{26D4}\u{26E9}-\u{26EA}\u{26F0}-\u{26F5}\u{26F7}-\u{26FA}\u{26FD}\u{2702}\u{2705}\u{2708}-\u{270D}\u{270F}\u{2712}\u{2714}\u{2716}\u{271D}\u{2721}\u{2728}\u{2733}-\u{2734}\u{2744}\u{2747}\u{274C}\u{274E}\u{2753}-\u{2755}\u{2757}\u{2763}-\u{2764}\u{2795}-\u{2797}\u{27A1}\u{27B0}\u{27BF}\u{2934}-\u{2935}\u{2B05}-\u{2B07}\u{2B1B}-\u{2B1C}\u{2B50}\u{2B55}\u{3030}\u{303D}\u{3297}\u{3299}]/gu;
+/**
+* Find emojis in a string
+* @param {string} text
+* @returns {RegExpMatchArray | null}
+*/
+const findEmojis = (text) => {
+	return text.match(EMOJI_REGEX);
+};
+/**
+* Get a preview of the emoji found
+* @param {string} text
+* @returns {string}
+*/
+const getEmojiPreview = (text) => {
+	const emojis = findEmojis(text);
+	if (!emojis || emojis.length === 0) return "";
+	const uniqueEmojis = [...new Set(emojis)];
+	const preview = uniqueEmojis.slice(0, 3).join(" ");
+	return uniqueEmojis.length > 3 ? `${preview} ...` : preview;
+};
+const rule$5 = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow the use of emojis in code. Use icons from a component library instead.",
+			recommended: true
+		},
+		schema: []
+	},
+	createOnce(context) {
+		return {
+			StringLiteral(node) {
+				if (node.type !== "StringLiteral") return;
+				const emojis = findEmojis(node.value);
+				if (emojis && emojis.length > 0) {
+					const preview = getEmojiPreview(node.value);
+					context.report({
+						node,
+						message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`
+					});
+				}
+			},
+			TemplateLiteral(node) {
+				if (node.type !== "TemplateLiteral") return;
+				for (const quasi of node.quasis) {
+					if (quasi.type !== "TemplateElement") continue;
+					const text = quasi.value.raw;
+					const emojis = findEmojis(text);
+					if (emojis && emojis.length > 0) {
+						const preview = getEmojiPreview(text);
+						context.report({
+							node: quasi,
+							message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`
+						});
+					}
+				}
+			},
+			JSXText(node) {
+				if (node.type !== "JSXText") return;
+				const emojis = findEmojis(node.value);
+				if (emojis && emojis.length > 0) {
+					const preview = getEmojiPreview(node.value);
+					context.report({
+						node,
+						message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`
+					});
+				}
+			}
+		};
+	}
+});
+const noEmojiRule = rule$5;
+
+//#endregion
+//#region src/oxlint-plugins/no-finally.js
+/** @typedef {import("oxlint").ESTree.Node} ESTNode */
+const rule$4 = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow 'finally' blocks in try/catch/finally statements",
+			recommended: true
+		},
+		schema: []
+	},
+	createOnce(context) {
+		return { TryStatement(node) {
+			if (node.type !== "TryStatement") return;
+			if (node.finalizer) context.report({
+				node: node.finalizer,
+				message: "Use of 'finally' blocks is disallowed. Handle cleanup explicitly in try/catch blocks instead."
+			});
+		} };
+	}
+});
+const noFinallyRule = rule$4;
 
 //#endregion
 //#region src/oxlint-plugins/no-react-namespace.js
@@ -1164,6 +1457,7 @@ const plugin = definePlugin({
 		"jsx-component-pascal-case": jsxComponentPascalCaseRule,
 		"no-array-type": noArrayTypeRule,
 		"no-component-date-instantiation": noComponentDateInstantiationRule,
+		"no-component-pure-functions": noComponentPureFunctionsRule,
 		"no-delete": noDeleteRule,
 		"no-emoji": noEmojiRule,
 		"no-finally": noFinallyRule,