@@ -25,8 +25,9 @@ while (node) {
 This rule finds references which are inside of loop conditions, then checks the
 variables of those references are modified in the loop.
 
-If a reference is inside of a binary expression or a ternary expression, this rule checks the result of
-the expression instead.
+By default, if a reference is inside of a binary expression or a ternary expression, this rule checks
+the result of the expression instead. The `checkConditionalExpressions` option stops the rule from
+grouping references solely because they belong to the same ternary expression.
 If a reference is inside of a dynamic expression (e.g. `CallExpression`,
 `YieldExpression`, ...), this rule ignores it.
 
@@ -99,7 +100,27 @@ while (check(obj)) {
 
 ## Options
 
-This rule has no options.
+This rule has an object option:
+
+* `"checkConditionalExpressions": false` (default) checks the result of an entire ternary expression
+* `"checkConditionalExpressions": true` each branch in a ternary expression is checked independently
+
+Examples of **incorrect** code for this rule with the `{ "checkConditionalExpressions": true }` option:
+
+::: incorrect
+
+```js
+/* eslint no-unmodified-loop-condition: ["error", { "checkConditionalExpressions": true }] */
+
+let chunk = getInitialChunk();
+let done = false;
+
+while (chunk ? !done : false) {
+    chunk = nextOrNull();
+}
+```
+
+:::
 
 ## When Not To Use It
 
 
@@ -26,7 +26,6 @@ const Traverser = require("../shared/traverser"),
 const SENTINEL_PATTERN =
 	/(?:(?:Call|Class|Function|Member|New|Yield)Expression|Statement|Declaration)$/u;
 const LOOP_PATTERN = /^(?:DoWhile|For|While)Statement$/u; // for-in/of statements don't have `test` property.
-const GROUP_PATTERN = /^(?:BinaryExpression|ConditionalExpression)$/u;
 const SKIP_PATTERN = /^(?:ArrowFunction|Class|Function)Expression$/u;
 const DYNAMIC_PATTERN = /^(?:Call|Member|New|TaggedTemplate|Yield)Expression$/u;
 
@@ -190,7 +189,19 @@ module.exports = {
 			url: "https://eslint.org/docs/latest/rules/no-unmodified-loop-condition",
 		},
 
-		schema: [],
+		schema: [
+			{
+				type: "object",
+				properties: {
+					checkConditionalExpressions: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		defaultOptions: [{ checkConditionalExpressions: false }],
 
 		messages: {
 			loopConditionNotModified:
@@ -199,6 +210,7 @@ module.exports = {
 	},
 
 	create(context) {
+		const [{ checkConditionalExpressions }] = context.options;
 		const sourceCode = context.sourceCode;
 		let groupMap = null;
 
@@ -305,10 +317,14 @@ module.exports = {
 				}
 
 				/*
-				 * If it's inside of a group, OK if either operand is modified.
-				 * So stores the group this reference belongs to.
+				 * If it's inside of a group, OK if any reference in that group is
+				 * modified. So stores the group this reference belongs to.
 				 */
-				if (GROUP_PATTERN.test(node.type)) {
+				if (
+					node.type === "BinaryExpression" ||
+					(!checkConditionalExpressions &&
+						node.type === "ConditionalExpression")
+				) {
 					// If this expression is dynamic, no need to check.
 					if (hasDynamicExpressions(node)) {
 						break;
 
@@ -4040,7 +4040,16 @@ export interface ESLintRules extends Linter.RulesRecord {
 	 * @since 2.0.0-alpha-2
 	 * @see https://eslint.org/docs/latest/rules/no-unmodified-loop-condition
 	 */
-	"no-unmodified-loop-condition": Linter.RuleEntry<[]>;
+	"no-unmodified-loop-condition": Linter.RuleEntry<
+		[
+			Partial<{
+				/**
+				 * @default false
+				 */
+				checkConditionalExpressions: boolean;
+			}>,
+		]
+	>;
 
 	/**
 	 * Rule to disallow ternary operators when simpler alternatives exist.
 
@@ -58,6 +58,10 @@ ruleTester.run("no-unmodified-loop-condition", rule, {
 		"var foo = 0, bar = 0; for (bar; foo;) { ++foo }",
 		"var foo; if (foo) { }",
 		"var a = [1, 2, 3]; var len = a.length; for (var i = 0; i < len - 1; i++) {}",
+		{
+			code: "let foo = 0, bar = 1, baz = 2; while (foo ? bar : baz) { foo += 1; bar += 1; baz += 1; }",
+			options: [{ checkConditionalExpressions: true }],
+		},
 	],
 	invalid: [
 		{
@@ -161,5 +165,29 @@ ruleTester.run("no-unmodified-loop-condition", rule, {
 				},
 			],
 		},
+		{
+			code: "let foo = 0, bar = 1, baz = 2; while (foo ? bar : baz) { foo += 1; }",
+			options: [{ checkConditionalExpressions: true }],
+			errors: [
+				{
+					messageId: "loopConditionNotModified",
+					data: { name: "bar" },
+				},
+				{
+					messageId: "loopConditionNotModified",
+					data: { name: "baz" },
+				},
+			],
+		},
+		{
+			code: "let chunk = true, done = false; while (chunk ? !done : false) { chunk = nextOrNull(); }",
+			options: [{ checkConditionalExpressions: true }],
+			errors: [
+				{
+					messageId: "loopConditionNotModified",
+					data: { name: "done" },
+				},
+			],
+		},
 	],
 });