refactor: stop cloning minimizer options on every asset

The per-asset shallow clone in `optimize()` only existed because
`minify.js` mutated `module`/`ecma` on the caller's options object, which
would have leaked across assets when a single options object was shared.
Move that overlay inside the `minify.js` loop and build it as a fresh
object via spread, so the same source options reference is safe to reuse.

`optimize()` no longer pre-expands a `minimizerOptionsList`: when the
configured options are an array, slice the matching subset (references,
not clones); otherwise pass the single object straight through. With a
shared options object and N minimizers across M assets that drops the
cloning from N×M to a single overlay per minimizer call.

Author: claude

src/index.js

@@ -379,21 +379,13 @@ class TerserPlugin {
     const cache = compilation.getCache("TerserWebpackPlugin");
     let numberOfAssets = 0;
 
-    // Normalize the configured minimizer(s) and their options into parallel
-    // arrays. The user can pass either a single `(impl, options)` pair or an
-    // array of pairs; for dispatch and per-asset slicing we treat both the
-    // same. The original `this.options.minimizer.implementation` shape is
-    // preserved for chunk hashing further down.
+    // Normalize the implementation list to an array so dispatch and the
+    // worker-pool capability checks below can iterate uniformly. The
+    // original shape on `this.options.minimizer.implementation` is preserved
+    // for chunk hashing.
     const implementations = Array.isArray(this.options.minimizer.implementation)
       ? this.options.minimizer.implementation
       : [this.options.minimizer.implementation];
-    const minimizerOptionsList =
-      /** @type {MinimizerOptions<T>[]} */
-      (
-        Array.isArray(this.options.minimizer.options)
-          ? this.options.minimizer.options
-          : implementations.map(() => this.options.minimizer.options)
-      );
 
     /**
      * Collect the indices of minimizers whose `filter` accepts `name`.
@@ -578,16 +570,19 @@ class TerserPlugin {
           // Dispatch to only the minimizers whose `filter` accepted this
           // asset (computed once when collecting `assetsForMinify`).
           // `minify.js` already normalizes a single implementation into a
-          // one-element array, so we always hand it the matching subset here.
+          // one-element array, so we always hand it the matching subset.
+          // Options are sliced as references — `minify.js` overlays
+          // `module`/`ecma` without mutating the caller's object.
           const assetImplementation =
             /** @type {MinimizerImplementation<T>} */
             (matched.map((i) => implementations[i]));
-          const clonedMinimizerOptions =
+          const sourceOptions = this.options.minimizer.options;
+          const assetMinimizerOptions =
             /** @type {MinimizerOptions<T>} */
             (
-              matched.map((i) => ({
-                .../** @type {T} */ (minimizerOptionsList[i]),
-              }))
+              Array.isArray(sourceOptions)
+                ? matched.map((i) => sourceOptions[i] || {})
+                : sourceOptions
             );
 
           /**
@@ -599,7 +594,7 @@ class TerserPlugin {
             inputSourceMap,
             minimizer: {
               implementation: assetImplementation,
-              options: clonedMinimizerOptions,
+              options: assetMinimizerOptions,
             },
             extractComments: this.options.extractComments,
           };

src/minify.js

@@ -323,8 +323,8 @@ async function minify(options) {
     const currentImplementation =
       /** @type {import("./index.js").BasicMinimizerImplementation<T> & import("./index.js").MinimizeFunctionHelpers} */
       (implementations[i]);
-    const currentOptions =
-      /** @type {import("./index.js").MinimizerOptions<T>} */
+    const baseOptions =
+      /** @type {import("./index.js").MinimizerOptions<T> & { module?: boolean, ecma?: number | string }} */
       (
         Array.isArray(minimizerOptions)
           ? minimizerOptions[i] || {}
@@ -333,14 +333,15 @@ async function minify(options) {
     const currentInput = typeof lastCode === "string" ? lastCode : input;
     const currentMap = typeof lastCode === "string" ? lastMap : inputSourceMap;
 
-    /** @type {MinimizerOptions<T & { module?: boolean }>} */
-    (currentOptions).module =
-      /** @type {MinimizerOptions<T & { module?: boolean }>} */
-      (currentOptions).module || module;
-    /** @type {MinimizerOptions<T & { ecma?: number | string }>} */
-    (currentOptions).ecma =
-      /** @type {MinimizerOptions<T & { ecma?: number | string }>} */
-      (currentOptions).ecma || ecma;
+    // Overlay `module` and `ecma` without mutating the caller's options so
+    // a single options object can be reused safely across assets.
+    const currentOptions =
+      /** @type {import("./index.js").MinimizerOptions<T>} */
+      ({
+        ...baseOptions,
+        module: baseOptions.module || module,
+        ecma: baseOptions.ecma || ecma,
+      });
 
     const result = await currentImplementation(
       { [name]: currentInput },