oxlint-plugin-react-doctor 0.9.2-dev.3f3197f → 0.9.2-dev.444e177

package/dist/index.d.ts

@@ -98,7 +98,7 @@ interface RuleContext extends Omit<BaseRuleContext, "getFilename"> {
 }
 //#endregion
 //#region src/plugin/utils/capability.d.ts
-declare const FRAMEWORK_TOKENS: readonly ["nextjs", "vite", "cra", "remix", "gatsby", "expo", "react-native", "tanstack-start", "preact", "unknown"];
+declare const FRAMEWORK_TOKENS: readonly ["nextjs", "astro", "vite", "cra", "remix", "gatsby", "expo", "react-native", "tanstack-start", "preact", "unknown"];
 type FrameworkToken = (typeof FRAMEWORK_TOKENS)[number];
 type Capability = FrameworkToken | "react" | "remotion" | "pure-preact" | "react-native" | "server-actions" | "ssr" | "client-only" | "expo:54" | "nextjs:static-export" | "nextjs:15" | "nextjs:16" | "tailwind" | "tailwind:3.4" | "tailwind:4" | "zod" | "zod:4" | "mobx" | "mobx-react" | "mobx-react-lite" | "mobx-react-binding" | "mobx-react-binding-observer-memo-guard" | "mobx-react-observer-memo-guard" | "mobx-react-lite-observer-memo-guard" | "mobx-state-tree" | "mobx-react-observer" | "zustand" | "typescript" | "react-compiler" | "reanimated" | "reanimated:4" | "tanstack-query" | "valtio" | "i18n" | "styled-components" | "styled-components:6" | "three" | "r3f" | "react-router" | "react-router-framework" | "react-router:6.4" | "react-router:6.7" | "react-router:6.9" | "react-router:6.19" | "react-router:7" | "react-router:7.8" | "react-router:7.9" | "react-router:7.10" | "react-router:7.15" | "react-router:8" | "pre-es2023" | "target-blank-needs-explicit-protection" | "target-blank-needs-noreferrer" | `react:${number}` | `preact:${number}` | `remotion:${number}` | `valtio:${number}` | `mobx:${number}` | `zustand:${number}` | `three:${number}` | `r3f:${number}`;
 type CapabilityQuery = (capability: Capability) => boolean;

package/dist/index.js

@@ -8675,7 +8675,7 @@ const resolveStableOptionsObject = (expression, observedPropertyNames, scopes, r
 //#endregion
 //#region src/plugin/rules/state-and-effects/class-component-missing-component-will-unmount-teardown.ts
 const MESSAGE$89 = "This class registers a listener or timer during mount without a matching teardown on every unmount path, so it can keep firing after the component unmounts; release it in `componentWillUnmount`.";
-const GLOBAL_OBJECT_NAMES$3 = new Set([
+const GLOBAL_OBJECT_NAMES$4 = new Set([
 	"window",
 	"globalThis",
 	"global",
@@ -8834,14 +8834,14 @@ const getTimerIdentifierAliasName = (identifier, scopes, visitedSymbolIds = /* @
 		const property = symbol.bindingIdentifier.parent;
 		const objectPattern = property?.parent;
 		const source = declaration.init ? stripParenExpression(declaration.init) : null;
-		if (isNodeOfType(property, "Property") && isNodeOfType(objectPattern, "ObjectPattern") && isNodeOfType(source, "Identifier") && GLOBAL_OBJECT_NAMES$3.has(source.name) && scopes.isGlobalReference(source)) return getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (isNodeOfType(property, "Property") && isNodeOfType(objectPattern, "ObjectPattern") && isNodeOfType(source, "Identifier") && GLOBAL_OBJECT_NAMES$4.has(source.name) && scopes.isGlobalReference(source)) return getStaticPropertyKeyName(property, { allowComputedString: true });
 		return null;
 	}
 	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
 	if (isNodeOfType(initializer, "Identifier")) return getTimerIdentifierAliasName(initializer, scopes, visitedSymbolIds);
 	if (!isNodeOfType(initializer, "MemberExpression")) return null;
 	const receiver = stripParenExpression(initializer.object);
-	return isNodeOfType(receiver, "Identifier") && GLOBAL_OBJECT_NAMES$3.has(receiver.name) && scopes.isGlobalReference(receiver) ? getStaticPropertyName(initializer) : null;
+	return isNodeOfType(receiver, "Identifier") && GLOBAL_OBJECT_NAMES$4.has(receiver.name) && scopes.isGlobalReference(receiver) ? getStaticPropertyName(initializer) : null;
 };
 const getTimerCalleeName = (node, scopes) => {
 	if (!isNodeOfType(node, "CallExpression")) return null;
@@ -8849,7 +8849,7 @@ const getTimerCalleeName = (node, scopes) => {
 	if (getBareCalleeName(node) && isNodeOfType(callee, "Identifier")) return getTimerIdentifierAliasName(callee, scopes);
 	if (!isNodeOfType(callee, "MemberExpression")) return null;
 	const receiver = stripParenExpression(callee.object);
-	if (!isNodeOfType(receiver, "Identifier") || !GLOBAL_OBJECT_NAMES$3.has(receiver.name) || findVariableInitializer(receiver, receiver.name)) return null;
+	if (!isNodeOfType(receiver, "Identifier") || !GLOBAL_OBJECT_NAMES$4.has(receiver.name) || findVariableInitializer(receiver, receiver.name)) return null;
 	return getStaticPropertyName(callee);
 };
 const getClassMemberName$1 = (member) => {
@@ -10045,6 +10045,12 @@ const FOCUS_FORWARDING_METHOD_NAMES = new Set([
 	"preventDefault",
 	"stopImmediatePropagation"
 ]);
+const DOM_QUERY_METHOD_NAMES = new Set(["getElementById", "querySelector"]);
+const GLOBAL_OBJECT_NAMES$3 = new Set([
+	"global",
+	"globalThis",
+	"window"
+]);
 const isFocusForwardingCall = (node) => {
 	if (!node) return false;
 	const inner = isNodeOfType(node, "ChainExpression") ? node.expression : node;
@@ -10054,6 +10060,12 @@ const isFocusForwardingCall = (node) => {
 	if (!isNodeOfType(callee.property, "Identifier")) return false;
 	return FOCUS_FORWARDING_METHOD_NAMES.has(callee.property.name);
 };
+const isGlobalDocumentExpression = (expression, scopes) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier")) return candidate.name === "document" && scopes.isGlobalReference(candidate);
+	if (!isNodeOfType(candidate, "MemberExpression") || !isNodeOfType(candidate.object, "Identifier") || !isNodeOfType(candidate.property, "Identifier") || candidate.property.name !== "document") return false;
+	return GLOBAL_OBJECT_NAMES$3.has(candidate.object.name) && scopes.isGlobalReference(candidate.object);
+};
 const isFocusForwardingFunctionBody = (body) => {
 	if (!body) return false;
 	if (isFocusForwardingCall(body)) return true;
@@ -10073,19 +10085,70 @@ const resolveHandlerFunction$2 = (attribute) => {
 	return resolveHandlerFunctionExpression(attribute.value.expression);
 };
 const resolveHandlerFunctionExpression = (handlerExpression) => {
-	let expression = handlerExpression;
+	let expression = stripParenExpression(handlerExpression);
 	if (isNodeOfType(expression, "Identifier")) {
 		const binding = findVariableInitializer(expression, expression.name);
 		if (!binding?.initializer) return null;
-		expression = binding.initializer;
+		expression = stripParenExpression(binding.initializer);
 	}
 	if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "FunctionDeclaration")) return expression;
 	return null;
 };
-const isFocusForwardingHandler = (attribute) => {
+const isEmptyReturn = (statement) => isNodeOfType(statement, "ReturnStatement") && statement.argument === null;
+const isClosestEarlyReturn = (statement) => {
+	if (!isNodeOfType(statement, "IfStatement") || statement.alternate) return false;
+	const consequent = statement.consequent;
+	if (!(isNodeOfType(consequent, "BlockStatement") ? consequent.body.length === 1 && isEmptyReturn(consequent.body[0]) : isEmptyReturn(consequent))) return false;
+	const test = stripParenExpression(statement.test);
+	const call = isNodeOfType(test, "ChainExpression") ? test.expression : test;
+	if (!isNodeOfType(call, "CallExpression") || call.arguments.length !== 1) return false;
+	const callee = stripParenExpression(call.callee);
+	const receiver = isNodeOfType(callee, "MemberExpression") ? stripParenExpression(callee.object) : null;
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "closest" && isNodeOfType(receiver, "MemberExpression") && isNodeOfType(receiver.object, "Identifier") && isNodeOfType(receiver.property, "Identifier") && receiver.property.name === "target" && isNodeOfType(call.arguments[0], "Literal") && typeof call.arguments[0].value === "string";
+};
+const isStaticSelectorExpression = (expression) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier") || isNodeOfType(candidate, "Literal")) return true;
+	return isNodeOfType(candidate, "TemplateLiteral") && candidate.expressions.every((innerExpression) => isStaticSelectorExpression(innerExpression));
+};
+const getDomQueryVariableName = (statement, scopes) => {
+	if (!isNodeOfType(statement, "VariableDeclaration") || statement.kind !== "const" || statement.declarations.length !== 1) return null;
+	const declaration = statement.declarations[0];
+	if (!declaration || !isNodeOfType(declaration.id, "Identifier") || !declaration.init) return null;
+	const initializer = stripParenExpression(declaration.init);
+	if (!isNodeOfType(initializer, "CallExpression") || initializer.arguments.length !== 1 || isNodeOfType(initializer.arguments[0], "SpreadElement") || !isStaticSelectorExpression(initializer.arguments[0])) return null;
+	const callee = stripParenExpression(initializer.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.property, "Identifier") || !DOM_QUERY_METHOD_NAMES.has(callee.property.name) || !isGlobalDocumentExpression(callee.object, scopes)) return null;
+	return declaration.id.name;
+};
+const isFocusCallOnVariable = (statement, variableName) => {
+	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+	const expression = stripParenExpression(statement.expression);
+	if (!isNodeOfType(expression, "CallExpression")) return false;
+	const callee = stripParenExpression(expression.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && receiver.name === variableName && isNodeOfType(callee.property, "Identifier") && callee.property.name === "focus" && expression.arguments.length === 0;
+};
+const isConditionalFocusForwardingHandler = (attribute, scopes) => {
+	if (!attribute.value || !isNodeOfType(attribute.value, "JSXExpressionContainer")) return false;
+	const expression = stripParenExpression(attribute.value.expression);
+	if (!isNodeOfType(expression, "ConditionalExpression")) return false;
+	const consequent = stripParenExpression(expression.consequent);
+	const alternate = stripParenExpression(expression.alternate);
+	const nullishBranch = isNullishExpression$2(consequent) ? consequent : alternate;
+	if (!isNullishExpression$2(nullishBranch) || isNodeOfType(nullishBranch, "Identifier") && !scopes.isGlobalReference(nullishBranch)) return false;
+	const handlerFunction = resolveHandlerFunctionExpression(nullishBranch === consequent ? alternate : consequent);
+	if (!handlerFunction || !isNodeOfType(handlerFunction.body, "BlockStatement")) return false;
+	const [guard, query, focus, ...rest] = handlerFunction.body.body;
+	if (!guard || !query || !focus || rest.length > 0 || !isClosestEarlyReturn(guard)) return false;
+	const queryVariableName = getDomQueryVariableName(query, scopes);
+	return Boolean(queryVariableName && isFocusCallOnVariable(focus, queryVariableName));
+};
+const isFocusForwardingHandler = (attribute, scopes) => {
+	if (isConditionalFocusForwardingHandler(attribute, scopes)) return true;
 	const handlerFunction = resolveHandlerFunction$2(attribute);
-	if (!handlerFunction) return false;
-	return isFocusForwardingFunctionBody(handlerFunction.body ?? null);
+	return Boolean(handlerFunction && isFocusForwardingFunctionBody(handlerFunction.body ?? null));
 };
 const COMPOSITE_ITEM_ROLES$1 = new Set([
 	"option",
@@ -10155,7 +10218,7 @@ const clickEventsHaveKeyEvents = defineRule({
 			const spreadOnClickExpression = CLICK_HANDLERS.map((name) => spreadEventValues.get(name.toLowerCase())).find((expression) => expression !== void 0);
 			if (!onClick && !spreadOnClickExpression) return;
 			if (onClick && isPureEventBlockerHandler(onClick)) return;
-			if (onClick && isFocusForwardingHandler(onClick)) return;
+			if (onClick && isFocusForwardingHandler(onClick, context.scopes)) return;
 			const spreadHandlerFunction = spreadOnClickExpression ? resolveHandlerFunctionExpression(spreadOnClickExpression) : null;
 			if (spreadHandlerFunction && (isFocusForwardingFunctionBody(spreadHandlerFunction.body ?? null) || containsBackdropDismissComparison(spreadHandlerFunction.body ?? null))) return;
 			if (hasCompositeItemRole(node)) return;
@@ -88308,6 +88371,11 @@ const noUndersizedIconButton = defineRule({
 //#region src/plugin/rules/correctness/no-unescaped-dynamic-string-in-regexp.ts
 const TEST_CONTEXT_FILE_PATTERN = /(\.test\.|\.spec\.|__tests__|(^|\/)(test|tests|e2e|cypress|playwright)\/)/;
 const SEARCH_TERM_NAME_PATTERN = /search|query|highlight|filter|term(?!in)|keyword/i;
+const REGEX_SOURCE_WORDS = [
+	"pattern",
+	"regex",
+	"regexp"
+];
 const ESCAPE_HELPER_NAME_PATTERN = /escape.*reg|safe.*reg/i;
 const SANITIZED_NAME_PATTERN = /escap|sanitiz/i;
 const INITIALIZER_RESOLUTION_HOPS = 2;
@@ -88461,14 +88529,70 @@ const isTypePositionIdentifier = (identifier) => {
 	}
 	return false;
 };
-const collectRawSearchTermIdentifiers = (argument) => {
-	const rawSearchTermIdentifiers = [];
+const identifierNameHasPathSegmentSemantics = (identifierName) => {
+	const identifierWords = identifierName.replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_]+/).map((word) => word.toLowerCase());
+	if (identifierWords.some((word) => REGEX_SOURCE_WORDS.includes(word))) return false;
+	return identifierWords.some((word) => [
+		"path",
+		"folder",
+		"directory",
+		"root"
+	].includes(word)) || identifierWords.includes("top") && identifierWords.includes("level");
+};
+const flattenPatternParts = (expression) => {
+	const inner = stripParenExpression(expression);
+	const staticValue = literalStringValue(inner);
+	if (staticValue !== null) return [staticValue];
+	if (isNodeOfType(inner, "Identifier")) return [inner];
+	if (isNodeOfType(inner, "TemplateLiteral")) {
+		const parts = [];
+		for (let index = 0; index < inner.quasis.length; index += 1) {
+			const quasi = inner.quasis[index];
+			if (quasi) parts.push(quasi.value.cooked ?? quasi.value.raw);
+			const templateExpression = inner.expressions[index];
+			if (templateExpression) parts.push(stripParenExpression(templateExpression));
+		}
+		return parts;
+	}
+	if (isNodeOfType(inner, "BinaryExpression") && inner.operator === "+") {
+		const leftParts = flattenPatternParts(inner.left);
+		const rightParts = flattenPatternParts(inner.right);
+		return leftParts && rightParts ? [...leftParts, ...rightParts] : null;
+	}
+	if (isNodeOfType(inner, "CallExpression") && isNodeOfType(inner.callee, "MemberExpression") && getStaticPropertyName(inner.callee) === "concat") {
+		const receiverParts = flattenPatternParts(inner.callee.object);
+		if (!receiverParts) return null;
+		const parts = [...receiverParts];
+		for (const argument of inner.arguments) {
+			if (isNodeOfType(argument, "SpreadElement")) return null;
+			const argumentParts = flattenPatternParts(argument);
+			if (!argumentParts) return null;
+			parts.push(...argumentParts);
+		}
+		return parts;
+	}
+	return null;
+};
+const isIdentifierAnAnchoredPathSegment = (argument, identifier) => {
+	if (!identifierNameHasPathSegmentSemantics(identifier.name)) return false;
+	const parts = flattenPatternParts(argument);
+	if (!parts) return false;
+	const identifierPartIndex = parts.findIndex((part) => part === identifier);
+	if (identifierPartIndex < 0) return false;
+	const precedingParts = parts.slice(0, identifierPartIndex);
+	if (precedingParts.some((part) => typeof part !== "string")) return false;
+	const staticPrefix = precedingParts.join("");
+	const followingPart = parts[identifierPartIndex + 1];
+	return staticPrefix === "^" && typeof followingPart === "string" && followingPart.startsWith("/");
+};
+const collectRawDynamicLiteralIdentifiers = (argument) => {
+	const rawDynamicLiteralIdentifiers = [];
 	walkAst(argument, (child) => {
 		if (isEscapingCall(child) || isRegexSourceAccess(child)) return false;
 		if (isLiteralReturningGetterCall(child)) return false;
-		if (isNodeOfType(child, "Identifier") && SEARCH_TERM_NAME_PATTERN.test(child.name) && !isPropertyNamePosition(child) && !isTypePositionIdentifier(child)) rawSearchTermIdentifiers.push(child);
+		if (isNodeOfType(child, "Identifier") && (SEARCH_TERM_NAME_PATTERN.test(child.name) || isIdentifierAnAnchoredPathSegment(argument, child)) && !isPropertyNamePosition(child) && !isTypePositionIdentifier(child)) rawDynamicLiteralIdentifiers.push(child);
 	});
-	return rawSearchTermIdentifiers;
+	return rawDynamicLiteralIdentifiers;
 };
 const collectLeafIdentifiers = (node) => {
 	const leafIdentifiers = [];
@@ -88479,8 +88603,11 @@ const collectLeafIdentifiers = (node) => {
 	return leafIdentifiers;
 };
 const compositeInitializerResolvesEscaped = (strippedInitializer, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames) => {
+	if (isNodeOfType(strippedInitializer, "ConditionalExpression")) return [strippedInitializer.consequent, strippedInitializer.alternate].every((branch) => initializerLooksEscaped(branch, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames));
+	if (isNodeOfType(strippedInitializer, "BinaryExpression") || isNodeOfType(strippedInitializer, "LogicalExpression")) return [strippedInitializer.left, strippedInitializer.right].every((operand) => initializerLooksEscaped(operand, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames));
+	if (isNodeOfType(strippedInitializer, "TemplateLiteral")) return strippedInitializer.expressions.every((expression) => initializerLooksEscaped(expression, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames));
 	let didResolveAnyLeafEscaped = false;
-	for (const leafIdentifier of collectLeafIdentifiers(strippedInitializer)) if (identifierResolvesToEscapedValue(leafIdentifier, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames)) didResolveAnyLeafEscaped = true;
+	for (const leafIdentifier of collectLeafIdentifiers(strippedInitializer)) if (identifierResolvesToEscapedValue(leafIdentifier, remainingHops - 1, scopes, regexpObjectSymbolIds, globalRegExpObjectNames)) didResolveAnyLeafEscaped = true;
 	else if (SEARCH_TERM_NAME_PATTERN.test(leafIdentifier.name)) return false;
 	return didResolveAnyLeafEscaped;
 };
@@ -88492,7 +88619,7 @@ const initializerLooksEscaped = (initializer, remainingHops, scopes, regexpObjec
 	if (isNodeOfType(strippedInitializer, "CallExpression") && (isEscapingCall(strippedInitializer) || calleeBindingBodyEscapes(strippedInitializer))) return true;
 	if (remainingHops > 0) {
 		if (isNodeOfType(strippedInitializer, "Identifier")) return identifierResolvesToEscapedValue(strippedInitializer, remainingHops - 1, scopes, regexpObjectSymbolIds, globalRegExpObjectNames);
-		return compositeInitializerResolvesEscaped(strippedInitializer, remainingHops - 1, scopes, regexpObjectSymbolIds, globalRegExpObjectNames);
+		return compositeInitializerResolvesEscaped(strippedInitializer, remainingHops, scopes, regexpObjectSymbolIds, globalRegExpObjectNames);
 	}
 	return false;
 };
@@ -88684,7 +88811,7 @@ const noUnescapedDynamicStringInRegexp = defineRule({
 	severity: "warn",
 	category: "Correctness",
 	tags: ["test-noise"],
-	recommendation: "A search/filter/highlight term dropped straight into `new RegExp(...)` lets its regex metacharacters act as operators, so a user typing `.` or `(` over-matches or throws. Escape the value with an `escapeRegExp` helper before constructing the pattern.",
+	recommendation: "A dynamic literal string such as a search term or path segment dropped straight into `new RegExp(...)` lets its regex metacharacters act as operators, so values containing `.` or `(` over-match or throw. Escape the value with an `escapeRegExp` helper before constructing the pattern.",
 	create: (context) => {
 		if (TEST_CONTEXT_FILE_PATTERN.test(context.filename ?? "")) return {};
 		let regexpObjectIndex = null;
@@ -88701,10 +88828,10 @@ const noUnescapedDynamicStringInRegexp = defineRule({
 				regexpObjectIndex = buildRegExpObjectIndex(programRoot, context.scopes);
 			}
 			const currentRegExpObjectIndex = regexpObjectIndex;
-			if (!collectRawSearchTermIdentifiers(firstArgument).some((identifier) => !identifierResolvesToEscapedValue(identifier, INITIALIZER_RESOLUTION_HOPS, context.scopes, currentRegExpObjectIndex.regexpObjectSymbolIds, currentRegExpObjectIndex.globalRegExpObjectNames) && !isShapeTestedByDominatingGuard(node, identifier, context.scopes) && !isParameterFedOnlyMetacharacterFreeLiterals(identifier, context.scopes))) return;
+			if (!collectRawDynamicLiteralIdentifiers(firstArgument).some((identifier) => !identifierResolvesToEscapedValue(identifier, INITIALIZER_RESOLUTION_HOPS, context.scopes, currentRegExpObjectIndex.regexpObjectSymbolIds, currentRegExpObjectIndex.globalRegExpObjectNames) && !isShapeTestedByDominatingGuard(node, identifier, context.scopes) && !isParameterFedOnlyMetacharacterFreeLiterals(identifier, context.scopes))) return;
 			context.report({
 				node,
-				message: "This builds a `RegExp` from a dynamic search/filter term without escaping it, so regex metacharacters in the value act as operators and over-match or throw. Escape the value with an `escapeRegExp` helper first."
+				message: "This builds a `RegExp` from a dynamic literal string without escaping it, so regex metacharacters in the value act as operators and over-match or throw. Escape the value with an `escapeRegExp` helper first."
 			});
 		};
 		return {
@@ -140049,6 +140176,7 @@ const shouldReadSecurityScanContent = (relativePath, isGeneratedBundle) => isGen
 //#region src/plugin/utils/capability.ts
 const FRAMEWORK_TOKENS = [
 	"nextjs",
+	"astro",
 	"vite",
 	"cra",
 	"remix",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.9.2-dev.3f3197f",
+  "version": "0.9.2-dev.444e177",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",
@@ -46,7 +46,7 @@
     "@typescript-eslint/types": "^8.59.3",
     "eslint-scope": "^9.1.2",
     "eslint-visitor-keys": "^5.0.1",
-    "oxc-parser": "^0.141.0"
+    "oxc-parser": "^0.142.0"
   },
   "devDependencies": {
     "@types/node": "^25.6.0"