@pobammer-ts/small-rules 2.1.0 → 2.2.1

package/dist/index.js

@@ -7,15 +7,17 @@ import { ResolverFactory } from "oxc-resolver";
 import { type } from "arktype";
 //#region src/rules/array-type-generic.ts
 function toGenericArrayType(typeNode, sourceCode) {
+	if (typeNode.type === "TSParenthesizedType") return toGenericArrayType(typeNode.typeAnnotation, sourceCode);
 	if (typeNode.type === "TSArrayType") return `Array<${toGenericArrayType(typeNode.elementType, sourceCode)}>`;
 	if (typeNode.type === "TSTypeOperator" && typeNode.operator === "readonly" && typeNode.typeAnnotation.type === "TSArrayType") return `ReadonlyArray<${toGenericArrayType(typeNode.typeAnnotation.elementType, sourceCode)}>`;
 	return sourceCode.getText(typeNode);
 }
 function isTopLevelArrayType({ parent }) {
-	return !(parent.type === "TSRestType" && parent.parent.type === "TSTupleType" || parent.type === "TSTupleType" || parent.type === "TSArrayType" || parent.type === "TSTypeOperator" && parent.operator === "readonly");
+	const meaningfulParent = parent.type === "TSParenthesizedType" ? parent.parent : parent;
+	return !(meaningfulParent.type === "TSRestType" && meaningfulParent.parent.type === "TSTupleType" || meaningfulParent.type === "TSTupleType" || meaningfulParent.type === "TSArrayType" || meaningfulParent.type === "TSTypeOperator" && meaningfulParent.operator === "readonly");
 }
 const arrayTypeGeneric = defineRule({
-	create(context) {
+	createOnce(context) {
 		function reportArrayType(node) {
 			context.report({
 				fix(fixer) {
@@ -343,7 +345,7 @@ function isKeyOfNode(key) {
 function isComponentName(name) {
 	return COMPONENT_NAME_PATTERN.test(name);
 }
-function isVariableDeclarator$1(node) {
+function isVariableDeclarator(node) {
 	return node.type === "VariableDeclarator";
 }
 function getTypeAnnotationFromBinding(binding) {
@@ -369,7 +371,7 @@ function getImportedName({ imported }) {
 function hasName(node) {
 	return node.type === "Identifier" && isStringRaw(node.name);
 }
-function isIdentifierName$1(node) {
+function isIdentifierName(node) {
 	return node.type === "Identifier";
 }
 function isJsxIdentifier$1(node) {
@@ -381,7 +383,7 @@ function isJsxOpeningExpression(node) {
 function isImportDeclaration(node) {
 	return node.type === "ImportDeclaration";
 }
-function isStringLiteral$1(node) {
+function isStringLiteral(node) {
 	return node.type === "Literal" && isStringRaw(node.value);
 }
 function isCallExpression$1(node) {
@@ -429,7 +431,7 @@ function isImportDefaultSpecifier(node) {
 function isImportNamespaceSpecifier(node) {
 	return node.type === "ImportNamespaceSpecifier";
 }
-function isVariableDeclaration$1(node) {
+function isVariableDeclaration(node) {
 	return node.type === "VariableDeclaration";
 }
 function isExportNamedDeclaration(node) {
@@ -462,7 +464,7 @@ function isFunction(node) {
 function isTsQualifiedName(node) {
 	return node.type === "TSQualifiedName";
 }
-function isNumericLiteral$1(node) {
+function isNumericLiteral(node) {
 	return node.type === "Literal" && isNumberRaw(node.value);
 }
 function isNewExpression(node) {
@@ -498,9 +500,15 @@ function isThisExpression(node) {
 function isStaticRequire(node) {
 	if (!isCallExpression$1(node) || node.optional) return false;
 	const { callee } = node;
-	if (!isIdentifierName$1(callee) || callee.name !== "require" || node.arguments.length !== 1) return false;
+	if (!isIdentifierName(callee) || callee.name !== "require" || node.arguments.length !== 1) return false;
 	const [argument] = node.arguments;
-	return argument !== void 0 && isStringLiteral$1(argument);
+	return argument !== void 0 && isStringLiteral(argument);
+}
+function isBindingIdentifier(node) {
+	return node.type === "Identifier";
+}
+function isExpressionNode(node) {
+	return node.type !== "PrivateIdentifier";
 }
 //#endregion
 //#region src/rules/ban-react-fc.ts
@@ -519,7 +527,7 @@ function getTypeAnnotationFromId(node) {
 	return isTsTypeAnnotation(typeAnnotation) ? typeAnnotation : void 0;
 }
 const banReactFc = defineRule({
-	create(context) {
+	createOnce(context) {
 		return { VariableDeclarator(node) {
 			const typeAnnotation = getTypeAnnotationFromId(node);
 			if (typeAnnotation === void 0) return;
@@ -548,7 +556,6 @@ function normalizeBannedTypes(rawOptions) {
 	const bannedTypes = new Map(DEFAULT_BANNED_TYPES);
 	if (!(isRecord(rawOptions) && "bannedTypes" in rawOptions)) return bannedTypes;
 	const { bannedTypes: configuredBannedTypes } = rawOptions;
-	if (configuredBannedTypes === void 0) return bannedTypes;
 	if (isStringArray$1(configuredBannedTypes)) {
 		for (const typeName of configuredBannedTypes) bannedTypes.set(typeName.toLowerCase(), {
 			originalName: typeName,
@@ -1427,7 +1434,7 @@ const enforceIanitorCheckType = defineRule({
 				const { init, id } = node;
 				if (init?.type !== "CallExpression" || !isIanitorValidator(init)) return;
 				hasIanitorReference = true;
-				if (id.type === "Identifier" && id.typeAnnotation !== void 0) return;
+				if (id.type === "Identifier" && id.typeAnnotation !== void 0 && id.typeAnnotation !== null) return;
 				const complexity = calculateIanitorComplexity(init);
 				if (complexity < config.baseThreshold) return;
 				variableDeclaratorsToCheck.set(node, { complexity });
@@ -1881,7 +1888,7 @@ function getBindingTypeAnnotation(bindingName) {
 }
 function hasContextualArrayAnnotation(node, sourceCode) {
 	const { parent } = node;
-	if (isVariableDeclarator$1(parent) && parent.init === node) {
+	if (isVariableDeclarator(parent) && parent.init === node) {
 		const typeAnnotation = getBindingTypeAnnotation(parent.id);
 		if (typeAnnotation === void 0) return false;
 		return extractElementTypeFromArrayAnnotation(typeAnnotation.typeAnnotation, sourceCode) !== void 0;
@@ -2050,7 +2057,7 @@ function reportLengthArrayConstructor(context, node, options, lengthExpressionTe
 }
 function getPushCollapseCandidate(sourceCode, statements, index) {
 	const statement = statements[index];
-	if (statement === void 0 || !isVariableDeclaration$1(statement)) return void 0;
+	if (statement === void 0 || !isVariableDeclaration(statement)) return void 0;
 	if (statement.kind !== "const" && statement.kind !== "let") return void 0;
 	if (statement.declarations.length !== 1) return void 0;
 	const [declarator] = statement.declarations;
@@ -2199,9 +2206,6 @@ const VISITOR_KEYS_TO_SKIP = new Set([
 function isIdentifierReference$1(node) {
 	return node.type === "Identifier";
 }
-function isBindingIdentifier$1(node) {
-	return node.type === "Identifier";
-}
 function isNode(value) {
 	return "type" in value && typeof value.type === "string";
 }
@@ -2237,10 +2241,10 @@ function getArrayIndexAssignment(statement, arrayIdentifierName, expectedIndex)
 	const { expression } = statement;
 	if (!isAssignmentExpression(expression) || expression.operator !== "=") return void 0;
 	const { left } = expression;
-	if (!isMemberExpression(left) || left.optional || !left.computed) return void 0;
+	if (!(isMemberExpression(left) && left.computed)) return void 0;
 	const { object, property } = left;
 	if (!isIdentifierReference$1(object) || object.name !== arrayIdentifierName) return void 0;
-	if (!isNumericLiteral$1(property) || property.value !== expectedIndex) return void 0;
+	if (!isNumericLiteral(property) || property.value !== expectedIndex) return void 0;
 	return {
 		expression,
 		statement
@@ -2248,13 +2252,13 @@ function getArrayIndexAssignment(statement, arrayIdentifierName, expectedIndex)
 }
 function getCandidate(sourceCode, statements, index) {
 	const declaration = statements[index];
-	if (declaration === void 0 || !isVariableDeclaration$1(declaration) || declaration.declarations.length !== 1) return;
+	if (declaration === void 0 || !isVariableDeclaration(declaration) || declaration.declarations.length !== 1) return;
 	const [declarator] = declaration.declarations;
 	/* v8 ignore next -- guarded by declarations.length === 1; undefined is a parser invariant. @preserve */
-	if (declarator === void 0 || !isVariableDeclarator$1(declarator) || declarator.init === null) return;
+	if (declarator === void 0 || !isVariableDeclarator(declarator) || declarator.init === null) return;
 	const { init } = declarator;
 	if (!isNewExpression(init) || init.arguments.length > 0 || !isGlobalArrayConstructor(sourceCode, init)) return;
-	if (!isBindingIdentifier$1(declarator.id)) return void 0;
+	if (!isBindingIdentifier(declarator.id)) return void 0;
 	const arrayIdentifierName = declarator.id.name;
 	const foundAssignments = new Array();
 	let scanIndex = index + 1;
@@ -2373,9 +2377,6 @@ function isAllowAutofixOption(value) {
 }
 //#endregion
 //#region src/rules/no-array-size-assignment.ts
-function isExpressionNode$1(node) {
-	return node.type !== "PrivateIdentifier";
-}
 function areEquivalentTargets(left, right, sourceCode) {
 	if (left.type !== right.type) return false;
 	switch (left.type) {
@@ -2394,7 +2395,7 @@ function areEquivalentMembers(left, right, sourceCode) {
 	return left.computed ? areEquivalentComputedProperties(left.property, right.property, sourceCode) : areEquivalentStaticProperties(left.property, right.property);
 }
 function areEquivalentComputedProperties(left, right, sourceCode) {
-	return isExpressionNode$1(left) && isExpressionNode$1(right) && areEquivalentTargets(left, right, sourceCode);
+	return isExpressionNode(left) && isExpressionNode(right) && areEquivalentTargets(left, right, sourceCode);
 }
 function areEquivalentStaticProperties(left, right) {
 	if (left.type === "PrivateIdentifier" || right.type === "PrivateIdentifier") return left.type === "PrivateIdentifier" && right.type === "PrivateIdentifier" && left.name === right.name;
@@ -2409,7 +2410,7 @@ function isSafeMemberAccess(node, allowLiteralRoot) {
 			if (node.optional || !isSafeMemberAccess(node.object, false)) return false;
 			if (node.computed)
  /* v8 ignore next -- @preserve computed member properties are expressions in parser output. */
-			return isExpressionNode$1(node.property) ? isSafeMemberAccess(node.property, true) : false;
+			return isExpressionNode(node.property) ? isSafeMemberAccess(node.property, true) : false;
 			return node.property.type === "Identifier" || node.property.type === "PrivateIdentifier";
 		default: return false;
 	}
@@ -2440,7 +2441,7 @@ function getAppendTarget(node, sourceCode, environment) {
 const noArraySizeAssignment = defineRule({
 	create(context) {
 		const [options] = context.options;
-		const allowAutofix = isAllowAutofixOption(options) && options?.allowAutofix === true;
+		const allowAutofix = isAllowAutofixOption(options) && options.allowAutofix;
 		const environment = options?.environment === "standard" ? "standard" : "roblox-ts";
 		const { sourceCode } = context;
 		return { AssignmentExpression(node) {
@@ -2595,7 +2596,8 @@ function isPromiseChainCall(node) {
 	return PROMISE_CHAIN_METHODS.has(node.callee.property.name);
 }
 function isAsyncIife({ callee }) {
-	return (callee.type === "ArrowFunctionExpression" || callee.type === "FunctionExpression") && callee.async;
+	const unwrapped = unwrapExpression(callee);
+	return (unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "FunctionExpression") && unwrapped.async;
 }
 function getThisAsyncMethodName({ callee }, asyncMethods) {
 	if (callee.type !== "MemberExpression" || callee.object.type !== "ThisExpression" || callee.property.type !== "Identifier") return;
@@ -2613,6 +2615,7 @@ function getLocalVariableAssignment(node) {
 }
 function isNonIifeFunction(node) {
 	if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") return false;
+	if (node.parent.type === "ParenthesizedExpression" && node.parent.parent.type === "CallExpression" && node.parent.parent.callee === node.parent) return false;
 	return node.parent.type !== "CallExpression" || node.parent.callee !== node;
 }
 function isInsideSkippedFunction(node, constructorBody) {
@@ -2740,9 +2743,6 @@ const noCascadingSetState = defineRule({
 });
 //#endregion
 //#region src/rules/no-color3-constructor.ts
-function isNumericLiteral(node) {
-	return node.type === "Literal" && isNumberRaw(node.value);
-}
 function mapComponentToRgbRange(value) {
 	return Math.round(value > 1 ? value : value * 255);
 }
@@ -3645,6 +3645,7 @@ function unwrapNode(node) {
 	/* v8 ignore next -- @preserve wrapper variants are parser-shape defensive cases. */
 	switch (node.type) {
 		case "ChainExpression":
+		case "ParenthesizedExpression":
 		case "TSAsExpression":
 		case "TSInstantiationExpression":
 		case "TSNonNullExpression":
@@ -4569,7 +4570,7 @@ function isStandaloneUpdateExpression(node) {
 const noIncrementDecrement = defineRule({
 	create(context) {
 		const [options] = context.options;
-		const allowAutofix = isAllowAutofixOption(options) && options.allowAutofix === true;
+		const allowAutofix = isAllowAutofixOption(options) && options.allowAutofix;
 		const { sourceCode } = context;
 		return { UpdateExpression(node) {
 			if (!isStandaloneUpdateExpression(node)) return;
@@ -4705,7 +4706,6 @@ function traverseForThis(currentNode, visited) {
 	return false;
 }
 function childUsesThis(childValue, visited) {
-	if (childValue === void 0) return false;
 	if (Array.isArray(childValue)) {
 		for (const item of childValue) if (isNode$1(item) && traverseForThis(item, visited)) return true;
 		return false;
@@ -4833,7 +4833,7 @@ const VALID_EXPRESSIONS = new Set([
 function isExpression$1(node) {
 	return VALID_EXPRESSIONS.has(node.type);
 }
-function isModuleLevelScope$1(scope) {
+function isModuleLevelScope(scope) {
 	return scope.type === "module" || scope.type === "global";
 }
 function isImportBinding(scopeVariable) {
@@ -4854,7 +4854,7 @@ function getConstInitializer(definition) {
 }
 function getModuleConstInitializer(sourceCode, identifier) {
 	const variable = getVariableByName(sourceCode.getScope(identifier), identifier.name);
-	if (variable === void 0 || !isModuleLevelScope$1(variable.scope)) return void 0;
+	if (variable === void 0 || !isModuleLevelScope(variable.scope)) return void 0;
 	for (const definition of variable.defs) {
 		const initializer = getConstInitializer(definition);
 		if (initializer !== void 0) return initializer;
@@ -4924,7 +4924,7 @@ function isStaticExpression(sourceCode, expression, seen, options) {
 function isStaticIdentifier(sourceCode, identifier, seen, options) {
 	const variable = getVariableByName(sourceCode.getScope(identifier), identifier.name);
 	if (variable === void 0) return options.staticGlobalFactories.has(identifier.name);
-	if (!isModuleLevelScope$1(variable.scope)) return false;
+	if (!isModuleLevelScope(variable.scope)) return false;
 	if (isImportBinding(variable)) return true;
 	for (const definition of variable.defs) {
 		const initializer = getConstInitializer(definition);
@@ -4964,9 +4964,6 @@ function getVariableInitializer(definition) {
 	if (definition.type !== "Variable" || definition.node.type !== "VariableDeclarator") return void 0;
 	return definition.node.init ?? void 0;
 }
-function isModuleLevelScope(scope) {
-	return scope.type === "module" || scope.type === "global";
-}
 function getRootIdentifier$1(expression) {
 	let currentExpression = unwrapExpression(expression);
 	while (currentExpression.type === "MemberExpression") {
@@ -5028,6 +5025,7 @@ const noNativePropertiesSpread = defineRule({
 				const { value } = node;
 				if (value?.type !== "JSXExpressionContainer") return;
 				const { expression } = value;
+				/* v8 ignore next -- @preserve Oxc only produces JSXEmptyExpression here for rejected parse-error cases. */
 				if (expression.type === "JSXEmptyExpression") return;
 				const objectExpression = resolveObjectExpression(sourceCode, expression, /* @__PURE__ */ new Set());
 				if (objectExpression === void 0) return;
@@ -5541,6 +5539,10 @@ function getFunctionComponentName(node) {
 		if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name;
 	}
 }
+function getArrowExpressionBody(node) {
+	if (node.body.type === "BlockStatement") return void 0;
+	return unwrapExpression(node.body);
+}
 function getImportSourceFromVariable(variable) {
 	for (const definition of variable.defs) {
 		/* v8 ignore start -- @preserve imported component variables only carry import binding definitions here. */
@@ -5597,8 +5599,9 @@ const noRedundantAspectRatioConstraint = defineRule({
 		return {
 			ArrowFunctionExpression(node) {
 				const name = getFunctionComponentName(node);
-				if (name === void 0 || node.body.type !== "JSXElement" && node.body.type !== "JSXFragment") return;
-				if (!hasAspectRatioConstraintInSubtree(node.body)) return;
+				const body = getArrowExpressionBody(node);
+				if (name === void 0 || body === void 0 || body.type !== "JSXElement" && body.type !== "JSXFragment") return;
+				if (!hasAspectRatioConstraintInSubtree(body)) return;
 				protectedComponents.add(name);
 			},
 			FunctionDeclaration(node) {
@@ -5702,7 +5705,15 @@ function isPropertyValueReference(node) {
 	/* v8 ignore next -- @preserve scope reference identifiers always have parents in parser-produced ASTs. */
 	const parent = ascendPastWrappers$1(node.parent ?? void 0);
 	/* v8 ignore next -- @preserve scope references always have parents in parser-produced ASTs. */
-	return parent?.type === "Property" && parent.value === node;
+	return parent?.type === "Property" && unwrapPropertyValue(parent.value) === node;
+}
+function unwrapPropertyValue(node) {
+	let current = node;
+	while (isWrapperParent(current)) current = current.expression;
+	return current;
+}
+function isWrapperParent(node) {
+	return WRAPPER_PARENT_TYPES$1.has(node.type);
 }
 function getDeclaredFunctionVariable(sourceCode, node) {
 	if (node.type === "FunctionDeclaration") {
@@ -5792,10 +5803,118 @@ const noRenderHelperFunctions = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/no-restricted-property-assignment.ts
+function isRestriction(value) {
+	if (!isRecord(value)) return false;
+	if (!isStringRaw(value.object)) return false;
+	if (!Array.isArray(value.properties)) return false;
+	if (!value.properties.every((property) => isStringRaw(property))) return false;
+	return value.message === void 0 || isStringRaw(value.message);
+}
+function isRuleOptions(value) {
+	if (!isRecord(value)) return false;
+	if (!Array.isArray(value.restrictions)) return false;
+	if (!value.restrictions.every(isRestriction)) return false;
+	return value.checkComputed === void 0 || typeof value.checkComputed === "boolean";
+}
+function isMemberExpressionTarget(node) {
+	return node.type === "MemberExpression";
+}
+const noRestrictedPropertyAssignment = defineRule({
+	createOnce(context) {
+		let restrictions = [];
+		let checkComputed = true;
+		function reportIfRestricted(node, reportNode) {
+			if (!isMemberExpressionTarget(node)) return;
+			if (node.computed && !checkComputed) return;
+			if (node.object.type !== "Identifier") return;
+			const property = getMemberPropertyName(node);
+			if (property === void 0) return;
+			for (const restriction of restrictions) {
+				if (restriction.object !== node.object.name) continue;
+				if (restriction.properties.includes("*") || restriction.properties.includes(property)) {
+					if (restriction.message === void 0) context.report({
+						data: {
+							object: node.object.name,
+							property
+						},
+						messageId: "restricted",
+						node: reportNode
+					});
+					else context.report({
+						data: { message: restriction.message },
+						messageId: "restrictedCustom",
+						node: reportNode
+					});
+					return;
+				}
+			}
+		}
+		return {
+			AssignmentExpression(node) {
+				reportIfRestricted(node.left, node);
+			},
+			before() {
+				const [options] = context.options;
+				if (!isRuleOptions(options)) {
+					restrictions = [];
+					checkComputed = true;
+					return;
+				}
+				const { checkComputed: nextCheckComputed, restrictions: nextRestrictions } = options;
+				restrictions = nextRestrictions;
+				checkComputed = nextCheckComputed ?? true;
+			},
+			UpdateExpression(node) {
+				reportIfRestricted(node.argument, node);
+			}
+		};
+	},
+	meta: {
+		docs: {
+			description: "Disallow assignment to restricted object properties.",
+			recommended: true
+		},
+		messages: {
+			restricted: "Assignment to '{{object}}.{{property}}' is not permitted.",
+			restrictedCustom: "{{message}}"
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: {
+				checkComputed: {
+					default: true,
+					type: "boolean"
+				},
+				restrictions: {
+					items: {
+						additionalProperties: false,
+						properties: {
+							message: { type: "string" },
+							object: { type: "string" },
+							properties: {
+								items: { type: "string" },
+								minItems: 1,
+								type: "array"
+							}
+						},
+						required: ["object", "properties"],
+						type: "object"
+					},
+					type: "array"
+				}
+			},
+			required: ["restrictions"],
+			type: "object"
+		}],
+		type: "problem"
+	}
+});
+//#endregion
 //#region src/rules/no-spec-file-extension.ts
 const SPEC_EXTENSION_PATTERN = /\.spec\.(?:ts|tsx)$/u;
 const noSpecFileExtension = defineRule({
-	create(context) {
+	createOnce(context) {
 		return { Program(node) {
 			const { filename } = context;
 			if (!(filename && SPEC_EXTENSION_PATTERN.test(filename))) return;
@@ -5861,7 +5980,7 @@ function isStringElementName(node) {
 }
 function isStaticComponentVariable(variable, name) {
 	if (isImportBinding(variable)) return isComponentName(name) || name === REACT_FRAGMENT;
-	if (!isModuleLevelScope$1(variable.scope)) return false;
+	if (!isModuleLevelScope(variable.scope)) return false;
 	if (!isComponentName(name) && name !== REACT_FRAGMENT) return false;
 	for (const definition of variable.defs) {
 		if (definition.type === "FunctionName" || definition.type === "ClassName") return true;
@@ -6000,7 +6119,7 @@ function isPromiseDelayAwaitCall(node) {
 	return getMemberPropertyName(delayCallee) === "delay";
 }
 const noTaskWait = defineRule({
-	create(context) {
+	createOnce(context) {
 		return { CallExpression(node) {
 			if (isPromiseDelayAwaitCall(node)) {
 				context.report({
@@ -6032,7 +6151,7 @@ const noTaskWait = defineRule({
 //#endregion
 //#region src/rules/no-underscore-react-properties.ts
 const noUnderscoreReactProperties = defineRule({
-	create(context) {
+	createOnce(context) {
 		return { JSXAttribute(node) {
 			if (node.name.type !== "JSXIdentifier" || !node.name.name.startsWith("_")) return;
 			context.report({
@@ -6256,20 +6375,11 @@ function collectAllScopes(root) {
 		const current = stack.pop();
 		/* v8 ignore next -- @preserve non-empty traversal stack always yields a scope from pop. */
 		if (current === void 0) break;
-		scopes[size++] = current;
+		if (current.type !== "global") scopes[size++] = current;
 		for (const childScope of current.childScopes) stack.push(childScope);
 	}
 	return scopes;
 }
-function isBindingIdentifier(node) {
-	return node.type === "Identifier";
-}
-function isVariableDeclarator(node) {
-	return node.type === "VariableDeclarator";
-}
-function isVariableDeclaration(node) {
-	return node.type === "VariableDeclaration";
-}
 function isFunctionLikeInitializer(node) {
 	return isCallbackFunction(node) || node.type === "ClassExpression";
 }
@@ -6278,7 +6388,8 @@ function isObjectLikeInitializer(initializer, patterns, sourceCode) {
 	if (initializer.type === "JSXElement" || initializer.type === "JSXFragment") return true;
 	if (initializer.type !== "CallExpression" && initializer.type !== "NewExpression") return false;
 	const candidateText = sourceCode.getText(initializer.callee);
-	return patterns.some((pattern) => pattern.test(candidateText));
+	for (const pattern of patterns) if (pattern.test(candidateText)) return true;
+	return false;
 }
 function isStatementContainer(node) {
 	return node.type === "Program" || node.type === "BlockStatement";
@@ -6365,6 +6476,11 @@ function isAutoInlineSafeInitializer(sourceCode, node) {
 	if (node.type === "Literal") return true;
 	return isStaticExpression(sourceCode, node, /* @__PURE__ */ new Set(), STATIC_OPTIONS$1) && hasOnlyRelocatableCalls(node, STATIC_OPTIONS$1.staticGlobalFactories);
 }
+function getInlineInitializerText(sourceCode, initializer) {
+	let current = initializer;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return sourceCode.getText(current);
+}
 function areAdjacentStatements(first, second) {
 	const { parent } = first;
 	/* v8 ignore next -- @preserve VariableDeclaration parents visited by this rule are Program or BlockStatement containers. */
@@ -6471,7 +6587,6 @@ const noUselessConstants = defineRule({
 			};
 		}
 		function inspectScope(scope) {
-			if (scope.type === "global") return;
 			const fixableConstants = new Array();
 			for (const scopeVariable of scope.variables) {
 				const candidate = getUselessConstantCandidate(scope, scopeVariable);
@@ -6489,7 +6604,7 @@ const noUselessConstants = defineRule({
 				}
 				fixableConstants.push({
 					declarationNode: candidate.declarationNode,
-					initializerText: sourceCode.getText(candidate.initializer),
+					initializerText: getInlineInitializerText(sourceCode, candidate.initializer),
 					name: candidate.name,
 					referenceIdentifier: candidate.referenceIdentifier,
 					reportNode: candidate.reportNode
@@ -18311,9 +18426,6 @@ function isIdentifierNamed(node, name) {
 function isBooleanLiteral(node) {
 	return node.type === "Literal" && typeof node.value === "boolean";
 }
-function isStringLiteral(node) {
-	return node.type === "Literal" && isStringRaw(node.value);
-}
 function getIntrinsicClassName(node) {
 	if (node.type !== "JSXIdentifier") return void 0;
 	const className = intrinsicClassNamesByTagName.get(node.name.toLowerCase());
@@ -18328,6 +18440,7 @@ function getJsxAttributeExpression(node) {
 	const { value } = node;
 	if (value === null) return void 0;
 	if (value.type === "Literal") return value;
+	/* v8 ignore next -- @preserve Oxc only produces JSXEmptyExpression here for rejected parse-error cases. */
 	if (value.type !== "JSXExpressionContainer" || value.expression.type === "JSXEmptyExpression") return void 0;
 	return value.expression;
 }
@@ -18426,7 +18539,7 @@ function matchesTuple(expected, actual) {
 	return true;
 }
 function extractNumberValue(node) {
-	if (isNumericLiteral$1(node)) return node.value;
+	if (isNumericLiteral(node)) return node.value;
 	if (isMathHuge(node)) return Number.POSITIVE_INFINITY;
 	if (node.type !== "UnaryExpression") return void 0;
 	if (node.operator !== "+" && node.operator !== "-") return void 0;
@@ -18469,13 +18582,16 @@ function extractVector2Value(node) {
 	}
 	if (node.type !== "NewExpression" || !isIdentifierNamed(node.callee, "Vector2")) return void 0;
 	if (node.arguments.length === 0) return [0, 0];
-	const components = extractPair(node.arguments);
+	return extractNumberPair(node.arguments);
+}
+function extractNumberPair(argumentsList) {
+	const components = extractPair(argumentsList);
 	if (components === void 0) return void 0;
-	const [xNode, yNode] = components;
-	const x = extractNumberValue(xNode);
-	const y = extractNumberValue(yNode);
-	if (x === void 0 || y === void 0) return void 0;
-	return [x, y];
+	const [firstNode, secondNode] = components;
+	const first = extractNumberValue(firstNode);
+	const second = extractNumberValue(secondNode);
+	if (first === void 0 || second === void 0) return void 0;
+	return [first, second];
 }
 function extractNumberTriple(argumentsList) {
 	const components = extractTriple(argumentsList);
@@ -18512,23 +18628,30 @@ function extractVector3Value(node) {
 function extractUDimValue(node) {
 	if (node.type !== "NewExpression" || !isIdentifierNamed(node.callee, "UDim")) return void 0;
 	if (node.arguments.length === 0) return [0, 0];
-	const components = extractPair(node.arguments);
+	return extractNumberPair(node.arguments);
+}
+function extractNumberQuadruple(argumentsList) {
+	const components = extractQuadruple(argumentsList);
 	if (components === void 0) return void 0;
-	const [scaleNode, offsetNode] = components;
-	const scale = extractNumberValue(scaleNode);
-	const offset = extractNumberValue(offsetNode);
-	if (scale === void 0 || offset === void 0) return void 0;
-	return [scale, offset];
+	const [firstNode, secondNode, thirdNode, fourthNode] = components;
+	const first = extractNumberValue(firstNode);
+	const second = extractNumberValue(secondNode);
+	const third = extractNumberValue(thirdNode);
+	const fourth = extractNumberValue(fourthNode);
+	if (first === void 0 || second === void 0 || third === void 0 || fourth === void 0) return;
+	return [
+		first,
+		second,
+		third,
+		fourth
+	];
 }
 function extractUDim2Value(node) {
 	if (node.type === "CallExpression") {
 		const path = getMemberPath(node.callee);
-		const components = extractPair(node.arguments);
+		const components = extractNumberPair(node.arguments);
 		if (path === void 0 || components === void 0) return void 0;
-		const [firstNode, secondNode] = components;
-		const first = extractNumberValue(firstNode);
-		const second = extractNumberValue(secondNode);
-		if (first === void 0 || second === void 0) return void 0;
+		const [first, second] = components;
 		if (path.length === 2 && path[0] === "UDim2" && path[1] === "fromOffset") return [
 			0,
 			first,
@@ -18550,20 +18673,7 @@ function extractUDim2Value(node) {
 		0,
 		0
 	];
-	const components = extractQuadruple(node.arguments);
-	if (components === void 0) return void 0;
-	const [scaleXNode, offsetXNode, scaleYNode, offsetYNode] = components;
-	const scaleX = extractNumberValue(scaleXNode);
-	const offsetX = extractNumberValue(offsetXNode);
-	const scaleY = extractNumberValue(scaleYNode);
-	const offsetY = extractNumberValue(offsetYNode);
-	if (scaleX === void 0 || offsetX === void 0 || scaleY === void 0 || offsetY === void 0) return;
-	return [
-		scaleX,
-		offsetX,
-		scaleY,
-		offsetY
-	];
+	return extractNumberQuadruple(node.arguments);
 }
 function extractRectValue(node) {
 	if (node.type !== "NewExpression" || !isIdentifierNamed(node.callee, "Rect")) return void 0;
@@ -18573,20 +18683,7 @@ function extractRectValue(node) {
 		0,
 		0
 	];
-	const components = extractQuadruple(node.arguments);
-	if (components === void 0) return void 0;
-	const [minimumXNode, minimumYNode, maximumXNode, maximumYNode] = components;
-	const minimumX = extractNumberValue(minimumXNode);
-	const minimumY = extractNumberValue(minimumYNode);
-	const maximumX = extractNumberValue(maximumXNode);
-	const maximumY = extractNumberValue(maximumYNode);
-	if (minimumX === void 0 || minimumY === void 0 || maximumX === void 0 || maximumY === void 0) return;
-	return [
-		minimumX,
-		minimumY,
-		maximumX,
-		maximumY
-	];
+	return extractNumberQuadruple(node.arguments);
 }
 function extractRGBFromComponents(components) {
 	const [redNode, greenNode, blueNode] = components;
@@ -18944,10 +19041,22 @@ function normalizeOptions$1(raw) {
 		stateHooks: new Set(isStringArray$1(raw.stateHooks) ? raw.stateHooks : DEFAULT_STATE_HOOKS)
 	};
 }
+function getNamespacedCallNames(callee) {
+	if (callee.type !== "MemberExpression" || callee.computed || callee.object.type !== "Identifier" || callee.property.type !== "Identifier") return;
+	return {
+		objectName: callee.object.name,
+		propertyName: callee.property.name
+	};
+}
+function getNonComputedCalleePropertyName(callee) {
+	if (callee.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier") return;
+	return callee.property.name;
+}
 function isHookCall$1(node, hookIdentifiers, reactNamespaces, hookNames) {
 	const { callee } = node;
 	if (callee.type === "Identifier") return hookIdentifiers.has(callee.name);
-	if (callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.property.type === "Identifier") return reactNamespaces.has(callee.object.name) && hookNames.has(callee.property.name);
+	const memberNames = getNamespacedCallNames(callee);
+	if (memberNames !== void 0) return reactNamespaces.has(memberNames.objectName) && hookNames.has(memberNames.propertyName);
 	return false;
 }
 function getFunctionName$1(node) {
@@ -19269,7 +19378,8 @@ function buildFunctionContext(node, propertyCallbackPrefixes, functionId, isCust
 function isPropertyCallbackCall(callExpression, functionContext, propertyCallbackPrefixes) {
 	const { callee } = callExpression;
 	if (callee.type === "Identifier") return functionContext.propertyCallbackIdentifiers.has(callee.name);
-	if (callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.property.type === "Identifier") return functionContext.propertyObjectName !== void 0 && callee.object.name === functionContext.propertyObjectName && hasPrefix(callee.property.name, propertyCallbackPrefixes);
+	const memberNames = getNamespacedCallNames(callee);
+	if (memberNames !== void 0) return functionContext.propertyObjectName !== void 0 && memberNames.objectName === functionContext.propertyObjectName && hasPrefix(memberNames.propertyName, propertyCallbackPrefixes);
 	return false;
 }
 function hasDependencyIdentifier(callExpression, name) {
@@ -19319,7 +19429,8 @@ function collectSetterCalls(statements, stateSetterIdentifiers) {
 function isAllowedPropertyCallbackCall(callExpression, propertyCallbackIdentifiers) {
 	const { callee } = callExpression;
 	if (callee.type === "Identifier") return propertyCallbackIdentifiers.has(callee.name);
-	return callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.property.type === "Identifier" && propertyCallbackIdentifiers.has(callee.object.name);
+	const memberNames = getNamespacedCallNames(callee);
+	return memberNames !== void 0 && propertyCallbackIdentifiers.has(memberNames.objectName);
 }
 function hasNonSetterSideEffect(statements, stateSetterIdentifiers, propertyCallbackIdentifiers) {
 	for (const statement of statements) {
@@ -19357,8 +19468,7 @@ function hasOnlyLogCalls(statements) {
 	return hasOnlyNestedStatementsMatching(statements, (statement) => {
 		const callExpression = getCallExpressionFromStatement(statement);
 		if (callExpression === void 0) return false;
-		if (callExpression.callee.type === "MemberExpression" && !callExpression.callee.computed && callExpression.callee.object.type === "Identifier" && callExpression.callee.object.name === "console" && callExpression.callee.property.type === "Identifier") return true;
-		return false;
+		return getNamespacedCallNames(callExpression.callee)?.objectName === "console";
 	});
 }
 const SUBSCRIBE_METHODS = new Set([
@@ -19371,8 +19481,8 @@ function hasExternalStorePattern(statements) {
 	return statements.some((statement) => {
 		const callExpression = getCallExpressionFromStatement(statement);
 		if (callExpression === void 0) return false;
-		if (callExpression.callee.type === "MemberExpression" && !callExpression.callee.computed && callExpression.callee.property.type === "Identifier") return SUBSCRIBE_METHODS.has(callExpression.callee.property.name);
-		return false;
+		const propertyName = getNonComputedCalleePropertyName(callExpression.callee);
+		return propertyName !== void 0 && SUBSCRIBE_METHODS.has(propertyName);
 	});
 }
 function isRefCurrentArgument(argument, referenceIdentifiers) {
@@ -20080,7 +20190,7 @@ function objectExpressionMatches(sourceCode, expression, predicate) {
 	if (unwrapped.type === "ObjectExpression") return predicate(unwrapped);
 	if (unwrapped.type !== "Identifier") return false;
 	const variable = getVariableByName(sourceCode.getScope(unwrapped), unwrapped.name);
-	if (variable === void 0 || !isModuleLevelScope$1(variable.scope) || isImportBinding(variable)) return false;
+	if (variable === void 0 || !isModuleLevelScope(variable.scope) || isImportBinding(variable)) return false;
 	for (const definition of variable.defs) {
 		const initializer = getConstInitializer(definition);
 		if (initializer === void 0) continue;
@@ -20283,7 +20393,7 @@ const preferClassProperties = defineRule({
 //#endregion
 //#region src/rules/prefer-constant-dispatch.ts
 function isModuleScopeConst(variable) {
-	if (!isModuleLevelScope$1(variable.scope)) return false;
+	if (!isModuleLevelScope(variable.scope)) return false;
 	for (const definition of variable.defs) {
 		if (definition.type !== "Variable") continue;
 		const declarator = definition.node;
@@ -20302,7 +20412,7 @@ function resolvesToConstantIdentifier(sourceCode, identifier) {
 function resolvesToModuleScopeBinding(sourceCode, identifier) {
 	const variable = getVariableByName(sourceCode.getScope(identifier), identifier.name);
 	if (variable === void 0) return false;
-	return isImportBinding(variable) || isModuleLevelScope$1(variable.scope);
+	return isImportBinding(variable) || isModuleLevelScope(variable.scope);
 }
 function isConstantMemberExpression(sourceCode, memberExpression) {
 	let current = memberExpression;
@@ -20721,7 +20831,7 @@ function getContextStackReplacement(componentName, chain, sourceCode) {
 const preferContextStack = defineRule({
 	create(context) {
 		const { filename, sourceCode } = context;
-		/* v8 ignore start -- @preserve RuleTester/runtime filenames are present; empty filename is a defensive host guard. */
+		/* v8 ignore start -- @preserve rule harness/runtime filenames are present; empty filename is a defensive host guard. */
 		const discoveredContextStack = filename === "" ? { found: false } : discoverLocalComponent(filename, CONTEXT_STACK_COMPONENT);
 		/* v8 ignore stop -- @preserve */
 		const contextStackIdentifiers = /* @__PURE__ */ new Set();
@@ -21018,7 +21128,7 @@ function validateAssertionCall(context, assertionCall, deterministic, hasIndeter
 		return;
 	}
 	const [firstArgument] = assertionCall.arguments;
-	if (firstArgument === void 0 || firstArgument.type === "SpreadElement" || !isNumericLiteral$1(firstArgument)) {
+	if (firstArgument === void 0 || firstArgument.type === "SpreadElement" || !isNumericLiteral(firstArgument)) {
 		context.report({
 			messageId: "assertionsRequiresNumberArgument",
 			node: assertionCall
@@ -21124,11 +21234,16 @@ function normalizeAdditionalStaticFactories(rawOptions) {
 	return new Set(additionalStaticFactories);
 }
 function isJavaScriptXmlElementAssignedToModuleConst(context, node) {
-	const { parent } = node;
-	if (parent.type !== "VariableDeclarator" || parent.id.type !== "Identifier" || parent.init !== node) return false;
-	const variable = getVariableByName(context.sourceCode.getScope(node), parent.id.name);
+	let current = node;
+	let { parent } = current;
+	while (parent.type === "ParenthesizedExpression") {
+		current = parent;
+		({parent} = current);
+	}
+	if (parent.type !== "VariableDeclarator" || parent.id.type !== "Identifier" || parent.init !== current) return false;
+	const variable = getVariableByName(context.sourceCode.getScope(current), parent.id.name);
 	/* v8 ignore start -- @preserve module const declarators have a matching scope variable. */
-	return variable === void 0 ? false : isModuleLevelScope$1(variable.scope);
+	return variable === void 0 ? false : isModuleLevelScope(variable.scope);
 	/* v8 ignore stop -- @preserve */
 }
 function isStaticAttributeValue(context, attribute, seen, staticOptions) {
@@ -21176,9 +21291,9 @@ function isInsideHoistedJsxElement(context, node) {
 		if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier" && parent.init === current) {
 			const variable = getVariableByName(context.sourceCode.getScope(current), parent.id.name);
 			/* v8 ignore next -- @preserve module-level JSX declarators have scope variables in parser scopes. */
-			if (variable !== void 0 && isModuleLevelScope$1(variable.scope)) return true;
+			if (variable !== void 0 && isModuleLevelScope(variable.scope)) return true;
 		}
-		if (parent.type === "JSXElement" || parent.type === "JSXFragment") current = parent;
+		if (parent.type === "JSXElement" || parent.type === "JSXFragment" || parent.type === "ParenthesizedExpression") current = parent;
 		({parent} = parent);
 	}
 	return false;
@@ -21233,6 +21348,7 @@ const STATIC_OPTIONS = { staticGlobalFactories: new Set(DEFAULT_STATIC_GLOBAL_FA
 function getAttributeExpression(node) {
 	const { value } = node;
 	if (value?.type !== "JSXExpressionContainer") return void 0;
+	/* v8 ignore next -- @preserve Oxc only produces JSXEmptyExpression here for rejected parse-error cases. */
 	if (value.expression.type === "JSXEmptyExpression") return void 0;
 	return value.expression;
 }
@@ -21240,6 +21356,8 @@ function isJsxElementAssignedToModuleConst(context, node) {
 	let current = node;
 	while (true) {
 		const { parent } = current;
+		/* v8 ignore next -- @preserve decorated parser ASTs keep JSX ancestors attached until traversal stops. */
+		if (parent === null) return false;
 		if (parent.type === "VariableDeclarator") return isModuleConstDeclaration(context, node, parent, current);
 		const nextParent = getWalkableJsxParent(parent);
 		if (nextParent === void 0) return false;
@@ -21247,7 +21365,7 @@ function isJsxElementAssignedToModuleConst(context, node) {
 	}
 }
 function getWalkableJsxParent(parent) {
-	if (parent.type === "JSXElement" || parent.type === "JSXFragment" || parent.type === "JSXExpressionContainer" || parent.type === "ArrayExpression") return parent;
+	if (parent.type === "JSXElement" || parent.type === "JSXFragment" || parent.type === "JSXExpressionContainer" || parent.type === "ParenthesizedExpression" || parent.type === "ArrayExpression") return parent;
 }
 function isModuleConstDeclaration(context, node, parent, current) {
 	/* v8 ignore next -- @preserve non-identifier module bindings cannot be referenced as JSX constants. */
@@ -21255,7 +21373,7 @@ function isModuleConstDeclaration(context, node, parent, current) {
 	/* v8 ignore next -- @preserve walkable JSX parents are followed only through initializer positions. */
 	if (parent.init !== current) return false;
 	const variable = getVariableByName(context.sourceCode.getScope(node), parent.id.name);
-	return variable !== void 0 && isModuleLevelScope$1(variable.scope);
+	return variable !== void 0 && isModuleLevelScope(variable.scope);
 }
 function reportHoistableObject(context, objectExpression) {
 	const objectText = context.sourceCode.getText(objectExpression);
@@ -21308,8 +21426,13 @@ const preferHoistedJsxObjectProperties = defineRule({
 function isSimpleReceiver({ type }) {
 	return type === "Identifier" || type === "MemberExpression" || type === "CallExpression" || type === "NewExpression" || type === "ThisExpression";
 }
+function stripParenthesizedExpression$1(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
 const preferIdiv = defineRule({
-	create(context) {
+	createOnce(context) {
 		return { CallExpression(node) {
 			if (node.optional) return;
 			const callee = unwrapExpression(node.callee);
@@ -21321,9 +21444,9 @@ const preferIdiv = defineRule({
 			const expression = unwrapExpression(argument);
 			if (expression.type !== "BinaryExpression" || expression.operator !== "/") return;
 			const left = unwrapExpression(expression.left);
-			const leftText = context.sourceCode.getText(expression.left);
+			const leftText = context.sourceCode.getText(stripParenthesizedExpression$1(expression.left));
 			const receiverText = isSimpleReceiver(left) ? leftText : `(${leftText})`;
-			const rightText = context.sourceCode.getText(expression.right);
+			const rightText = context.sourceCode.getText(stripParenthesizedExpression$1(expression.right));
 			context.report({
 				fix: (fixer) => fixer.replaceText(node, `${receiverText}.idiv(${rightText})`),
 				messageId: "useIdiv",
@@ -21406,7 +21529,7 @@ function getPortalReplacement(componentName, node, sourceCode) {
 const preferLocalPortalComponent = defineRule({
 	create(context) {
 		const { filename, sourceCode } = context;
-		/* v8 ignore start -- @preserve RuleTester/runtime filenames are present; empty filename is a defensive host guard. */
+		/* v8 ignore start -- @preserve rule harness/runtime filenames are present; empty filename is a defensive host guard. */
 		const discoveredPortal = filename === "" ? { found: false } : discoverLocalComponent(filename, PORTAL_COMPONENT);
 		/* v8 ignore stop -- @preserve */
 		const availablePortalIdentifiers = /* @__PURE__ */ new Set();
@@ -21480,6 +21603,7 @@ function isKnownNonNumberIdentifier(sourceCode, identifier) {
 	return false;
 }
 function isKnownNonNumberExpression(sourceCode, expression) {
+	if (expression.type === "ParenthesizedExpression") return isKnownNonNumberExpression(sourceCode, expression.expression);
 	if (expression.type === "TSAsExpression" || expression.type === "TSTypeAssertion") return !isNumberTypeAnnotation(expression.typeAnnotation);
 	/* v8 ignore next -- @preserve literal non-number cases are covered by direct literal tests. */
 	if (isKnownNonNumberLiteral(expression)) return true;
@@ -21489,9 +21613,15 @@ function isKnownNonNumberExpression(sourceCode, expression) {
 function getComparableText(sourceCode, expression) {
 	return sourceCode.getText(unwrapExpression(expression));
 }
+function stripParenthesizedExpression(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
 function getMathArgumentText(sourceCode, expression) {
-	if (expression.type === "SequenceExpression") return `(${sourceCode.getText(expression)})`;
-	return sourceCode.getText(expression);
+	const unwrapped = stripParenthesizedExpression(expression);
+	if (unwrapped.type === "SequenceExpression") return `(${sourceCode.getText(unwrapped)})`;
+	return sourceCode.getText(unwrapped);
 }
 function getPreferredMathMethod(sourceCode, node) {
 	if (node.test.type !== "BinaryExpression") return void 0;
@@ -21870,7 +22000,7 @@ function getEnumMemberName(node) {
 	return IS_INTEGER.test(node.id.value) ? void 0 : node.id.value;
 }
 const preferPascalCaseEnums = defineRule({
-	create(context) {
+	createOnce(context) {
 		return {
 			TSEnumDeclaration(node) {
 				const identifier = node.id.name;
@@ -21905,7 +22035,7 @@ const preferPascalCaseEnums = defineRule({
 //#endregion
 //#region src/rules/prefer-sequence-overloads.ts
 function isNumericLiteralValue(node, value) {
-	return isNumericLiteral$1(node) && node.value === value;
+	return isNumericLiteral(node) && node.value === value;
 }
 function getSequenceKeypointName(sequenceName) {
 	if (sequenceName === "ColorSequence") return "ColorSequenceKeypoint";
@@ -21957,7 +22087,7 @@ function getKeypointArrayReplacement(context, node, sequenceName, keypointName)
 	};
 }
 const preferSequenceOverloads = defineRule({
-	create(context) {
+	createOnce(context) {
 		return { NewExpression(node) {
 			if (node.callee.type !== "Identifier") return;
 			const sequenceName = node.callee.name;
@@ -22284,7 +22414,7 @@ function isPlural(identifier) {
 	return lastToken !== void 0 && isPluralWord(lastToken.lowercased, lastToken.original);
 }
 const preferSingularEnums = defineRule({
-	create(context) {
+	createOnce(context) {
 		return { TSEnumDeclaration({ id }) {
 			const { name } = id;
 			if (!isPlural(name)) return;
@@ -22310,9 +22440,6 @@ const preferSingularEnums = defineRule({
 function canRender(node) {
 	return node.type === "JSXElement" || node.type === "JSXFragment";
 }
-function isExpressionNode(node) {
-	return node.type !== "PrivateIdentifier";
-}
 function areEquivalentExpressionOrSuper(left, right, sourceCode) {
 	if (left.type === "Super" || right.type === "Super") return left.type === "Super" && right.type === "Super";
 	return areEquivalentExpression(left, right, sourceCode);
@@ -22962,7 +23089,7 @@ function countCaptureGroups(replacement) {
 	if (dollarReferences === null) return 0;
 	let maxGroup = 0;
 	for (const dollarReference of dollarReferences) {
-		const groupNumber = Number.parseInt(dollarReference.slice(1), 10);
+		const groupNumber = Math.trunc(Number(dollarReference.slice(1)));
 		if (groupNumber > maxGroup) maxGroup = groupNumber;
 	}
 	return maxGroup;
@@ -23372,18 +23499,18 @@ function isDefaultOrNamespaceImportName(identifier) {
 	if (isImportDefaultSpecifier(parent) && parent.local === identifier || isImportNamespaceSpecifier(parent) && parent.local === identifier) return true;
 	if (isImportSpecifier$1(parent) && parent.local === identifier) {
 		const { imported } = parent;
-		if (isIdentifierName$1(imported) && imported.name === "default") return true;
+		if (isIdentifierName(imported) && imported.name === "default") return true;
 	}
-	return isVariableDeclarator$1(parent) && parent.id === identifier && parent.init !== null && isStaticRequire(parent.init);
+	return isVariableDeclarator(parent) && parent.id === identifier && parent.init !== null && isStaticRequire(parent.init);
 }
 function isExportedIdentifier(identifier) {
 	/* v8 ignore next -- parser-produced identifiers in this rule always expose a name. @preserve */
 	if (!hasName(identifier)) return false;
 	const { parent } = identifier;
-	if (isVariableDeclarator$1(parent) && parent.id === identifier) {
+	if (isVariableDeclarator(parent) && parent.id === identifier) {
 		const declaration = parent.parent;
 		/* v8 ignore next -- variable declarator definitions are always parented by a variable declaration. @preserve */
-		return isVariableDeclaration$1(declaration) ? isExportNamedDeclaration(declaration.parent) : false;
+		return isVariableDeclaration(declaration) ? isExportNamedDeclaration(declaration.parent) : false;
 	}
 	if (isFunctionDeclaration(parent) && parent.id === identifier) return isExportNamedDeclaration(parent.parent);
 	if (isClass(parent) && parent.id === identifier) return isExportNamedDeclaration(parent.parent);
@@ -23434,16 +23561,16 @@ function getImportSource(definition) {
 	if (definition.type === "ImportBinding") {
 		const { parent } = definition;
 		/* v8 ignore else -- parser import bindings retain their ImportDeclaration parent. @preserve */
-		if (parent !== null && isImportDeclaration(parent) && isStringLiteral$1(parent.source)) return parent.source.value;
+		if (parent !== null && isImportDeclaration(parent) && isStringLiteral(parent.source)) return parent.source.value;
 	}
 	/* v8 ignore next -- variable import checks only reach require-backed variable definitions. @preserve */
 	if (definition.type === "Variable") {
 		const { node } = definition;
 		/* v8 ignore else -- callers only ask for sources from static require declarators. @preserve */
-		if (isVariableDeclarator$1(node) && node.init !== null && isStaticRequire(node.init)) {
+		if (isVariableDeclarator(node) && node.init !== null && isStaticRequire(node.init)) {
 			const [argument] = node.init.arguments;
 			/* v8 ignore next -- static require recognition requires a string literal source. @preserve */
-			if (argument !== void 0 && isStringLiteral$1(argument)) return argument.value;
+			if (argument !== void 0 && isStringLiteral(argument)) return argument.value;
 		}
 	}
 }
@@ -23501,9 +23628,9 @@ function shouldSkipVariable(definition, definitionName, options) {
 function getSpecialCaseReplacement(variable) {
 	if (variable.name !== "plr") return void 0;
 	const [definition] = variable.defs;
-	if (definition?.type !== "Variable" || !isVariableDeclarator$1(definition.node) || definition.node.init === null) return;
+	if (definition?.type !== "Variable" || !isVariableDeclarator(definition.node) || definition.node.init === null) return;
 	const { init } = definition.node;
-	if (isMemberExpression(init) && !init.computed && isIdentifierName$1(init.object) && init.object.name === "Players" && isIdentifierName$1(init.property) && init.property.name === "LocalPlayer") return "localPlayer";
+	if (isMemberExpression(init) && !init.computed && isIdentifierName(init.object) && init.object.name === "Players" && isIdentifierName(init.property) && init.property.name === "LocalPlayer") return "localPlayer";
 }
 function computeSafeSamples(samples, scopes, isSafeNameForVariable, options) {
 	const safeSamples = new Array();
@@ -23525,7 +23652,7 @@ function computeSafeSamples(samples, scopes, isSafeNameForVariable, options) {
 	};
 }
 function createIsSafeNameForVariable(definition, variable, isSafeGeneratedName) {
-	const avoidArgumentsReplacement = definition.type === "Variable" && isVariableDeclarator$1(definition.node) && definition.node.init === null;
+	const avoidArgumentsReplacement = definition.type === "Variable" && isVariableDeclarator(definition.node) && definition.node.init === null;
 	const avoidArgumentsInArrowParameter = definition.type === "Parameter" && variable.scope.type === "function" && variable.scope.block.type === "ArrowFunctionExpression";
 	const shouldAvoidArguments = avoidArgumentsReplacement || avoidArgumentsInArrowParameter;
 	return (name, scopes) => {
@@ -23552,7 +23679,7 @@ function checkVariable(variable, options, scopeToNamesGeneratedByFixer, isSafeGe
 	if (definition === void 0) return;
 	const definitionName = definition.name;
 	/* v8 ignore next -- parser variable definitions in this rule expose identifier names. @preserve */
-	if (!isIdentifierName$1(definitionName)) return;
+	if (!isIdentifierName(definitionName)) return;
 	if (shouldSkipVariable(definition, definitionName, options)) return;
 	const isSafeNameForVariable = createIsSafeNameForVariable(definition, variable, isSafeGeneratedName);
 	const specialCaseReplacement = getSpecialCaseReplacement(variable);
@@ -23598,7 +23725,7 @@ function checkPossiblyWeirdClassVariable(variable, variableChecker) {
 		}
 		const definitionName = definition.name;
 		/* v8 ignore next -- parser class-name definitions expose identifier names. @preserve */
-		if (!isIdentifierName$1(definitionName)) {
+		if (!isIdentifierName(definitionName)) {
 			variableChecker(variable);
 			return;
 		}
@@ -23649,7 +23776,7 @@ function getFixablePropertyReplacement(node, samples) {
 	if (samples?.length !== 1 || !isObjectPropertyKey(node)) return void 0;
 	const [replacement] = samples;
 	const { parent } = node;
-	if (replacement !== void 0 && isProperty(parent) && isStringLiteral$1(parent.value) && isValidIdentifier(replacement)) return replacement;
+	if (replacement !== void 0 && isProperty(parent) && isStringLiteral(parent.value) && isValidIdentifier(replacement)) return replacement;
 }
 const preventAbbreviations = defineRule({
 	create(context) {
@@ -25275,36 +25402,27 @@ function isAssignedJSXValue(node) {
 	if (parent.type === "AssignmentExpression") return parent.right === current;
 	return false;
 }
-function isTernaryJSXChild(node) {
+function isJSXChildWrappedBy(node, wrapperType) {
 	let current = getParent(node);
 	/* v8 ignore next -- @preserve visited JSX nodes have parent links in parser-produced ASTs. */
 	if (current === void 0) return false;
-	let foundTernary = false;
-	while (current !== void 0 && (current.type === "ConditionalExpression" || WRAPPER_PARENT_TYPES.has(current.type))) {
-		if (current.type === "ConditionalExpression") foundTernary = true;
+	let foundWrapper = false;
+	while (current !== void 0 && (current.type === wrapperType || WRAPPER_PARENT_TYPES.has(current.type))) {
+		/* v8 ignore else -- @preserve current parser output keeps wrapped JSX operands attached directly to the wrapper here. */
+		if (current.type === wrapperType) foundWrapper = true;
 		current = getParent(current);
 	}
-	if (!foundTernary || current?.type !== "JSXExpressionContainer") return false;
+	if (!foundWrapper || current?.type !== "JSXExpressionContainer") return false;
 	const containerParent = getParent(current);
 	/* v8 ignore next -- @preserve parser-produced JSX expression containers are attached to a parent. */
 	if (containerParent === void 0) return false;
 	return containerParent.type === "JSXElement" || containerParent.type === "JSXFragment";
 }
+function isTernaryJSXChild(node) {
+	return isJSXChildWrappedBy(node, "ConditionalExpression");
+}
 function isLogicalJSXChild(node) {
-	let current = getParent(node);
-	/* v8 ignore next -- @preserve visited JSX nodes have parent links in parser-produced ASTs. */
-	if (current === void 0) return false;
-	let foundLogical = false;
-	while (current !== void 0 && (current.type === "LogicalExpression" || WRAPPER_PARENT_TYPES.has(current.type))) {
-		/* v8 ignore else -- @preserve current parser output keeps logical JSX operands attached directly to LogicalExpression here. */
-		if (current.type === "LogicalExpression") foundLogical = true;
-		current = getParent(current);
-	}
-	if (!foundLogical || current?.type !== "JSXExpressionContainer") return false;
-	const containerParent = getParent(current);
-	/* v8 ignore next -- @preserve parser-produced JSX expression containers are attached to a parent. */
-	if (containerParent === void 0) return false;
-	return containerParent.type === "JSXElement" || containerParent.type === "JSXFragment";
+	return isJSXChildWrappedBy(node, "LogicalExpression");
 }
 const requireReactComponentKeys = defineRule({
 	create(context) {
@@ -25613,7 +25731,7 @@ function getEnclosingFunctionName(node) {
 }
 function getAssignedName({ parent }) {
 	if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name;
-	if (parent?.type === "PropertyDefinition" || parent?.type === "Property" || parent?.type === "MethodDefinition") {
+	if (parent?.type === "PropertyDefinition" || parent?.type === "MethodDefinition") {
 		if (parent.key.type === "PrivateIdentifier") return `#${parent.key.name}`;
 		/* v8 ignore next -- @preserve class and object member keys are identifiers after private keys are handled. */
 		if (parent.key.type === "Identifier") return parent.key.name;
@@ -25707,7 +25825,7 @@ const requireThrowErrorCapture = defineRule({
 	create(context) {
 		const { sourceCode } = context;
 		const allowList = context.options[0]?.allow ?? [];
-		/* v8 ignore next -- @preserve RuleTester and Oxlint provide a physical filename for rule execution. */
+		/* v8 ignore next -- @preserve the rule harness and Oxlint provide a physical filename for rule execution. */
 		const physicalFilename = context.physicalFilename ?? "<input>";
 		return { ThrowStatement(node) {
 			const { argument } = node;
@@ -25801,7 +25919,7 @@ function isNotSpread(node) {
 	return node.type !== "SpreadElement";
 }
 const requireUnicodeRegex = defineRule({
-	create(context) {
+	createOnce(context) {
 		return { CallExpression(node) {
 			if (!isIdentifierWithName(node.callee, "regex")) return;
 			if (node.arguments.length < 2) {
@@ -25843,9 +25961,9 @@ function reportEmptyDefaultValue(context, defaultValue) {
 function checkParameterDefaults(context, parameters) {
 	for (const parameter of parameters) {
 		if (parameter.type === "AssignmentPattern" && parameter.left.type === "ObjectPattern") {
+			checkObjectPatternDefaults(context, parameter.left);
 			/* v8 ignore next -- @preserve assignment pattern defaults are parser expression nodes. */
 			if (isNode$1(parameter.right)) reportEmptyDefaultValue(context, parameter.right);
-			checkObjectPatternDefaults(context, parameter.left);
 			continue;
 		}
 		if (parameter.type !== "ObjectPattern") continue;
@@ -26126,8 +26244,12 @@ function getHookName(node) {
 function getMemberExpressionDepth(node) {
 	let depth = 0;
 	let current = node;
-	if (current.type === "ChainExpression") current = current.expression;
-	while (current.type === "MemberExpression") {
+	while (true) {
+		if (current.type === "ChainExpression" || current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion") {
+			current = current.expression;
+			continue;
+		}
+		if (current.type !== "MemberExpression") break;
 		depth += 1;
 		current = current.object;
 	}
@@ -26135,15 +26257,21 @@ function getMemberExpressionDepth(node) {
 }
 function getRootIdentifier(node) {
 	let current = node;
-	if (current.type === "ChainExpression") current = current.expression;
-	while (current.type === "MemberExpression" || current.type === "TSNonNullExpression") current = current.type === "MemberExpression" ? current.object : current.expression;
+	while (true) {
+		if (current.type === "ChainExpression" || current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion") {
+			current = current.expression;
+			continue;
+		}
+		if (current.type !== "MemberExpression") break;
+		current = current.object;
+	}
 	return current.type === "Identifier" ? current : void 0;
 }
 function collectIdentifierNames(node) {
 	if (node.type === "Identifier") return [node.name];
 	if (node.type === "MemberExpression") return collectIdentifierNames(node.object);
 	if (node.type === "ChainExpression") return collectIdentifierNames(node.expression);
-	if (node.type === "TSNonNullExpression" || node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion") return collectIdentifierNames(node.expression);
+	if (node.type === "ParenthesizedExpression" || node.type === "TSNonNullExpression" || node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion") return collectIdentifierNames(node.expression);
 	if (node.type === "BinaryExpression" || node.type === "LogicalExpression") return [...collectIdentifierNames(node.left), ...collectIdentifierNames(node.right)];
 	if (node.type === "UnaryExpression") return collectIdentifierNames(node.argument);
 	if (node.type === "ConditionalExpression") return [
@@ -26158,7 +26286,7 @@ function isExpression(node) {
 }
 function nodeToSafeDependencyPath(node, sourceCode) {
 	if (node.type === "Identifier") return node.name;
-	if (node.type === "ChainExpression" || isExpression(node)) return nodeToSafeDependencyPath(node.expression, sourceCode);
+	if (node.type === "ChainExpression" || node.type === "ParenthesizedExpression" || isExpression(node)) return nodeToSafeDependencyPath(node.expression, sourceCode);
 	/* v8 ignore next -- @preserve dependency path conversion only receives identifiers, chains, transparent TS wrappers, or member expressions. */
 	if (node.type === "MemberExpression") {
 		const objectPath = nodeToSafeDependencyPath(node.object, sourceCode);
@@ -26372,7 +26500,7 @@ function getCaptureInfo(current, name, variable, sourceCode) {
 	};
 }
 function isTransparentExpressionNode(node) {
-	return node.type === "TSSatisfiesExpression" || node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression";
+	return node.type === "ParenthesizedExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression";
 }
 function visitChildNodes(current, sourceCode, visit) {
 	/* v8 ignore next -- @preserve parser node types visited here have registered visitor keys. */
@@ -26433,7 +26561,7 @@ function parseDependencies(node, sourceCode) {
 	for (const element of node.elements) {
 		if (!element) continue;
 		const actualNode = element.type === "SpreadElement" ? element.argument : element;
-		const name = sourceCode.getText(actualNode);
+		const name = nodeToSafeDependencyPath(actualNode, sourceCode);
 		const depth = getMemberExpressionDepth(actualNode);
 		dependencies.push({
 			depth,
@@ -26785,9 +26913,6 @@ function isReactHookName(name) {
 function getOptions(value) {
 	return isRecord(value) ? value : {};
 }
-function isIdentifierName(node) {
-	return node.type === "Identifier";
-}
 function isComponentOrHook(node) {
 	if ((node.type === "FunctionDeclaration" || node.type === "FunctionExpression") && node.id !== null) return isComponentName(node.id.name) || isReactHookName(node.id.name);
 	const { parent } = node;
@@ -26906,6 +27031,7 @@ const smallRules = definePlugin({
 		"no-recursive": noRecursive,
 		"no-redundant-aspect-ratio-constraint": noRedundantAspectRatioConstraint,
 		"no-render-helper-functions": noRenderHelperFunctions,
+		"no-restricted-property-assignment": noRestrictedPropertyAssignment,
 		"no-spec-file-extension": noSpecFileExtension,
 		"no-static-react-create-element": noStaticReactCreateElement,
 		"no-table-create-map": noTableCreateMap,