@@ -3987,6 +3987,31 @@ const lambdaModifiers = (func) =>
  */
 const staticSize = (isStatic) => (isStatic ? 7 : 0);
 
+/**
+ * Whether a destructuring pattern writes an expression: its element,
+ * property value, rest or defaulted target.
+ * @param {Node} self the expression
+ * @param {Compressor} compressor the compressor, `self`'s parent first
+ * @param {TerserAst} ast the node kinds
+ * @returns {boolean} true when a pattern writes it
+ */
+const isPatternTarget = (self, compressor, ast) => {
+	/** @type {Node | NodeShape} */
+	let node = self;
+	let level = 0;
+	let parent = compressor.parent(level);
+	while (
+		parent &&
+		((ast.isObjectPropertyNode(parent) && parent.value === node) ||
+			ast.isExpansionNode(parent) ||
+			(ast.isDefaultAssignNode(parent) && parent.left === node))
+	) {
+		node = parent;
+		parent = compressor.parent(++level);
+	}
+	return Boolean(parent) && ast.isDestructuringNode(parent);
+};
+
 /**
  * terser's `first_in_statement`: whether the node a walk is at is the first
  * thing its statement prints, so an object or function there needs parentheses.
@@ -24090,7 +24115,8 @@ const installImprove = (modules) => {
 			node.optional ||
 			node.property.name !== "source" ||
 			!A.isRegExpNode(node.object) ||
-			isLhs(node, compressor.parent()) ||
+			isLhs(compressor.self(), compressor.parent()) ||
+			isPatternTarget(compressor.self(), compressor, A) ||
 			!compressor.option("evaluate")
 		) {
 			return undefined;
@@ -31349,16 +31375,12 @@ const installImprove = (modules) => {
 			!Number.isInteger(index) ||
 			index < 0 ||
 			index >= object.elements.length ||
-			isLhs(self, parent) ||
+			isLhs(compressor.self(), parent) ||
+			isPatternTarget(compressor.self(), compressor, A) ||
 			(A.isUnaryPrefixNode(parent) && parent.operator === "delete") ||
 			// Called, it reads the array as its `this`.
 			(A.isCallNode(parent) && parent.callee === self) ||
-			A.isPrefixedTemplateStringNode(parent) ||
-			(A.isForInNode(parent) && parent.left === self) ||
-			A.isDestructuringNode(parent) ||
-			A.isDefaultAssignNode(parent) ||
-			(A.isObjectKeyValNode(parent) &&
-				A.isDestructuringNode(compressor.parent(1)))
+			A.isPrefixedTemplateStringNode(parent)
 		) {
 			return undefined;
 		}
@@ -43547,30 +43569,6 @@ const installValueOptimizers = (modules, helpers) => {
 		);
 	};
 
-	/**
-	 * Whether a destructuring pattern writes a name: its element, property
-	 * value, rest or defaulted target, which `void 0` cannot stand for.
-	 * @param {Node} self the name
-	 * @param {Compressor} compressor the compressor, `self`'s parent first
-	 * @returns {boolean} true when a pattern writes it
-	 */
-	const isPatternTarget = (self, compressor) => {
-		/** @type {Node | NodeShape} */
-		let node = self;
-		let level = 0;
-		let parent = compressor.parent(level);
-		while (
-			parent &&
-			((A.isObjectPropertyNode(parent) && parent.value === node) ||
-				A.isExpansionNode(parent) ||
-				(A.isDefaultAssignNode(parent) && parent.left === node))
-		) {
-			node = parent;
-			parent = compressor.parent(++level);
-		}
-		return Boolean(parent) && A.isDestructuringNode(parent);
-	};
-
 	defineOptimizer("SymbolRef", (self, compressor) => {
 		if (
 			!compressor.option("ie8") &&
@@ -43579,7 +43577,7 @@ const installValueOptimizers = (modules, helpers) => {
 			!(
 				modules.corrections !== undefined &&
 				modules.corrections.enabled &&
-				isPatternTarget(self, compressor)
+				isPatternTarget(self, compressor, A)
 			)
 		) {
 			switch (self.name) {
 
@@ -0,0 +1,62 @@
+"use strict";
+
+it("should preserve an array rest assignment target", () => {
+	let value = 1;
+	[...[value][0]] = [2, 3];
+	expect(value).toBe(1);
+});
+
+it("should preserve an object rest assignment target", () => {
+	let value = 1;
+	({ ...[value][0] } = { answer: 2 });
+	expect(value).toBe(1);
+});
+
+it("should preserve nested rest assignment targets", () => {
+	let value = 1;
+	({ answer: [...[value][0]] } = { answer: [2, 3] });
+	expect(value).toBe(1);
+	for ([...[value][0]] of [[2, 3]]) {
+		expect(value).toBe(1);
+	}
+});
+
+it("should preserve ordinary and defaulted assignment targets", () => {
+	let value = 1;
+	[[value][0]] = [2];
+	({ answer: [value][0] } = { answer: 2 });
+	[[value][0] = 2] = [];
+	({ answer: [value][0] = 2 } = {});
+	expect(value).toBe(1);
+});
+
+it("should preserve direct writes and loop targets", () => {
+	let value = 1;
+	[value][0] = 2;
+	[value][0]++;
+	delete [value][0];
+	for ([value][0] of [2]) {
+		expect(value).toBe(1);
+	}
+});
+
+it("should still read values in computed keys and defaults", () => {
+	let value;
+	({ [["answer"][0]]: value = [2][0] } = {});
+	expect(value).toBe(2);
+	({ [["answer"][0]]: value } = { answer: 3 });
+	expect(value).toBe(3);
+});
+
+it("should still read an array element inside a property assignment target", () => {
+	const value = {};
+	[value][0].answer = 2;
+	expect(value.answer).toBe(2);
+	value[["answer"][0]] = 3;
+	expect(value.answer).toBe(3);
+});
+
+it("should still read array elements in spread expressions", () => {
+	expect([...[[2, 3]][0]]).toEqual([2, 3]);
+	expect({ ...[{ answer: 2 }][0] }).toEqual({ answer: 2 });
+});
@@ -0,0 +1,69 @@
+"use strict";
+
+it("should preserve direct and computed regular expression property writes", () => {
+	expect(() => {
+		/a/.source = "b";
+	}).toThrow(TypeError);
+	expect(() => {
+		/a/["source"] = "b";
+	}).toThrow(TypeError);
+	expect(() => {
+		for (/a/.source of ["b"]) {
+			throw new Error("unreachable");
+		}
+	}).toThrow(TypeError);
+});
+
+it("should preserve regular expression properties in assignment patterns", () => {
+	expect(() => {
+		({ answer: /a/.source } = { answer: "b" });
+	}).toThrow(TypeError);
+	expect(() => {
+		[/a/.source] = ["b"];
+	}).toThrow(TypeError);
+});
+
+it("should preserve computed regular expression properties in patterns", () => {
+	expect(() => {
+		({ answer: /a/["source"] } = { answer: "b" });
+	}).toThrow(TypeError);
+});
+
+it("should preserve regular expression properties in rest targets", () => {
+	expect(() => {
+		[.../a/.source] = ["b"];
+	}).toThrow(TypeError);
+	expect(() => {
+		({ .../a/.source } = { answer: "b" });
+	}).toThrow(TypeError);
+});
+
+it("should preserve regular expression properties in defaulted targets", () => {
+	expect(() => {
+		[/a/.source = "b"] = [];
+	}).toThrow(TypeError);
+	expect(() => {
+		({ answer: /a/.source = "b" } = {});
+	}).toThrow(TypeError);
+});
+
+it("should preserve regular expression properties in nested loop targets", () => {
+	expect(() => {
+		for ({ answer: [.../a/.source] } of [{ answer: ["b"] }]) {
+			throw new Error("unreachable");
+		}
+	}).toThrow(TypeError);
+});
+
+it("should still read regular expression properties in keys and defaults", () => {
+	let value;
+	({ [/a/.source]: value = /b/.source } = {});
+	expect(value).toBe("b");
+	({ [/a/.source]: value } = { a: "c" });
+	expect(value).toBe("c");
+});
+
+it("should still read regular expression properties in spread expressions", () => {
+	expect([.../ab/.source]).toEqual(["a", "b"]);
+	expect({ .../ab/.source }).toEqual({ 0: "a", 1: "b" });
+});
@@ -0,0 +1,18 @@
+"use strict";
+
+/** @type {import("../../../../").Configuration[]} */
+module.exports = ["array", "regexp"].map((name) => ({
+	mode: "production",
+	target: ["web", "es2018"],
+	entry: `./${name}.js`,
+	experiments: { futureDefaults: true },
+	output: { module: false },
+	optimization: {
+		minimizer: ["..."],
+		minimize: {
+			javascript: {
+				compress: { pure_getters: false, pure_conversions: false }
+			}
+		}
+	}
+}));