@@ -22885,133 +22885,6 @@ const installImprove = (modules) => {
 		}
 	);
 
-	/** @type {WeakMap<Node, boolean>} */
-	const argumentsReadOnly = new WeakMap();
-
-	/**
-	 * Whether a function only reads its `arguments` object's `length` and
-	 * indices, so an index at or past `length` reads `undefined`.
-	 * @param {Node} lambda a function
-	 * @returns {boolean} true when nothing writes or passes the object on
-	 */
-	const readsArgumentsOnly = (lambda) => {
-		const known = argumentsReadOnly.get(lambda);
-		if (known !== undefined) return known;
-		let readOnly = true;
-		const walker = A.createWalker((/** @type {Node} */ node) => {
-			if (!readOnly) return true;
-			if (!A.isSymbolRefNode(node) || node.name !== "arguments") return;
-			const access = walker.parent();
-			const outer = walker.parent(1);
-			if (
-				!(
-					(A.isDotNode(access) && access.property.name === "length") ||
-					(A.isSubNode(access) && A.isNumberNode(access.property))
-				) ||
-				access.object !== node ||
-				(A.isAssignNode(outer) && outer.left === access) ||
-				(A.isUnaryNode(outer) &&
-					(outer.operator === "++" ||
-						outer.operator === "--" ||
-						outer.operator === "delete"))
-			) {
-				readOnly = false;
-			}
-		});
-		walkNode(lambda, walker);
-		argumentsReadOnly.set(lambda, readOnly);
-		return readOnly;
-	};
-
-	/**
-	 * The index `arguments.length > n` tests for, where the function's own
-	 * `arguments` object is only ever read.
-	 * @param {Node} node a test
-	 * @returns {number | undefined} the index n, or undefined
-	 */
-	const testedArgumentIndex = (node) => {
-		if (!A.isBinaryNode(node) || A.isAssignNode(node)) return;
-		let length;
-		let count;
-		if (node.operator === ">") [length, count] = [node.left, node.right];
-		else if (node.operator === "<") [count, length] = [node.left, node.right];
-		else return;
-		if (
-			!A.isDotNode(length) ||
-			length.property.name !== "length" ||
-			!A.isArgumentsObject(length.object) ||
-			!A.isNumberNode(count) ||
-			!readsArgumentsOnly(length.object.definition.scope.node)
-		) {
-			return;
-		}
-		return count.value;
-	};
-
-	/**
-	 * @param {Node} node an expression
-	 * @returns {boolean} whether it is `undefined` or `void` of a constant
-	 */
-	const isUndefinedValue = (node) =>
-		A.isUndefinedNode(node) ||
-		(A.isUnaryPrefixNode(node) &&
-			node.operator === "void" &&
-			A.isConstantNode(node.argument));
-
-	/**
-	 * Whether a node reads `arguments[n]` off the same object a test read.
-	 * @param {Node} node an expression
-	 * @param {number} index the index n
-	 * @returns {boolean} true for that read
-	 */
-	const readsArgument = (node, index) =>
-		A.isSubNode(node) &&
-		A.isArgumentsObject(node.object) &&
-		A.isNumberNode(node.property) &&
-		node.property.value === index;
-
-	// Babel's default parameters test `arguments.length > n` before reading
-	// `arguments[n]`, which reads `undefined` past the length anyway.
-	A.wrapOptimizer("Binary", (optimizeBinary) => (self, compressor) => {
-		const optimized = optimizeBinary(self, compressor);
-		if (
-			!improvements.enabled ||
-			!A.isBinaryNode(optimized) ||
-			optimized.operator !== "&&"
-		) {
-			return optimized;
-		}
-		const index = testedArgumentIndex(optimized.left);
-		const { right } = optimized;
-		if (
-			index === undefined ||
-			!A.isBinaryNode(right) ||
-			right.operator !== "!==" ||
-			!(
-				(isUndefinedValue(right.left) && readsArgument(right.right, index)) ||
-				(isUndefinedValue(right.right) && readsArgument(right.left, index))
-			)
-		) {
-			return optimized;
-		}
-		return right;
-	});
-	A.wrapOptimizer(
-		"Conditional",
-		(optimizeConditional) => (self, compressor) => {
-			const optimized = optimizeConditional(self, compressor);
-			if (!improvements.enabled || !A.isConditionalNode(optimized)) {
-				return optimized;
-			}
-			const index = testedArgumentIndex(optimized.test);
-			return index !== undefined &&
-				readsArgument(optimized.consequent, index) &&
-				isUndefinedValue(optimized.alternate)
-				? optimized.consequent
-				: optimized;
-		}
-	);
-
 	/**
 	 * Whether the value of the node visited goes on as it is, where no test or
 	 * operator around it could fold a constant written in its place.
 
@@ -329,12 +329,6 @@ const IMPROVED_CASES = [
 		{ compress: { ecma: 2020 }, ecma: 2020, mangle: false },
 		"function f(y,z){return[+y,y>>>z]}console.log(f(\"3\",1));"
 	],
-	[
-		"Babel's default parameters, testing `arguments.length` before reading the index",
-		"function f() { var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; var b = arguments.length > 1 ? arguments[1] : void 0; return [a, b]; } console.log(f(), f(5), f(5, 6));",
-		{ compress: {}, mangle: false },
-		"function f(){return[void 0!==arguments[0]?arguments[0]:1,arguments[1]]}console.log(f(),f(5),f(5,6));"
-	],
 	[
 		"unread calls of an async function with no body and of a generator",
 		"var log = []; function f() { (async () => {})(); (function* () { log.push(1); })(); log.push(2); } f(); console.log(log.join());",
@@ -8503,9 +8497,10 @@ describe("syntax-printer", () => {
 			}
 		});
 
-		it("should keep `arguments.length` tested where something else uses the object", async () => {
+		it("should keep `arguments.length` tested, as an index past it may read a getter `Object.prototype` holds", async () => {
 			const { minify } = await load();
 			for (const input of [
+				"export function f(){var a=arguments.length>0&&arguments[0]!==undefined?arguments[0]:1;var b=arguments.length>1?arguments[1]:void 0;return[a,b]}",
 				"export function f(){arguments[1]=5;return arguments.length>1?arguments[1]:void 0}",
 				"export function f(){g(arguments);return arguments.length>1&&void 0!==arguments[1]?arguments[1]:2}",
 				"export function f(){return arguments.length>2&&void 0!==arguments[1]?arguments[1]:2}"