fix: stuff

Author: alexander-akait

package-lock.json

@@ -56,6 +56,7 @@
   },
   "dependencies": {
     "jest-worker": "^27.0.6",
+    "merge-source-map": "^1.1.0",
     "p-limit": "^3.1.0",
     "schema-utils": "^3.1.1",
     "serialize-javascript": "^6.0.0",
@@ -91,7 +92,7 @@
     "standard-version": "^9.3.1",
     "typescript": "^4.3.5",
     "uglify-js": "^3.14.1",
-    "webpack": "^5.48.0",
+    "webpack": "^5.51.1",
     "worker-loader": "^3.0.8"
   },
   "keywords": [

package.json

@@ -441,7 +441,11 @@ class TerserPlugin {
               inputSourceMap,
               // TODO rename to `minimizer` in the next major release
               minimizer: this.options.minify,
-              minimizerOptions: { ...this.options.terserOptions },
+              minimizerOptions: Array.isArray(this.options.terserOptions)
+                ? this.options.terserOptions.map((item) => {
+                    return { ...item };
+                  })
+                : { ...this.options.terserOptions },
               extractComments: this.options.extractComments,
             };
 

src/index.js

@@ -1,5 +1,6 @@
 /** @typedef {import("./index.js").InternalMinifyOptions} InternalMinifyOptions */
 /** @typedef {import("./index.js").MinifyResult} MinifyResult */
+/** @typedef {import("source-map").RawSourceMap} RawSourceMap */
 
 /**
  * @param {InternalMinifyOptions} options
@@ -14,25 +15,108 @@ async function minify(options) {
   /**
    * @type {MinifyResult}
    */
-  const result = { code: options.input, map: options.inputSourceMap };
+  const result = { code: options.input };
+
+  /**
+   * @param {RawSourceMap | undefined} oldMap
+   * @param {RawSourceMap | undefined} newMap
+   * @returns {RawSourceMap | undefined}
+   */
+  const mergeSourceMap = (oldMap, newMap) => {
+    if (!oldMap) {
+      return newMap;
+    }
+
+    if (!newMap) {
+      return oldMap;
+    }
+
+    // eslint-disable-next-line global-require
+    const sourceMap = require("source-map");
+    const oldMapConsumer = new sourceMap.SourceMapConsumer(oldMap);
+    const newMapConsumer = new sourceMap.SourceMapConsumer(newMap);
+    const mergedMapGenerator = new sourceMap.SourceMapGenerator();
+
+    newMapConsumer.eachMapping((m) => {
+      // pass when `originalLine` is null.
+      // It occurs in case that the node does not have origin in original code.
+      if (m.originalLine == null) {
+        return;
+      }
+
+      const origPosInOldMap = oldMapConsumer.originalPositionFor({
+        line: m.originalLine,
+        column: m.originalColumn,
+      });
+
+      if (origPosInOldMap.source == null) {
+        return;
+      }
+
+      mergedMapGenerator.addMapping({
+        original: {
+          line: origPosInOldMap.line,
+          column: origPosInOldMap.column,
+        },
+        generated: {
+          line: m.generatedLine,
+          column: m.generatedColumn,
+        },
+        source: origPosInOldMap.source,
+        name: origPosInOldMap.name,
+      });
+    });
+
+    const consumers = [oldMapConsumer, newMapConsumer];
+
+    consumers.forEach((consumer) => {
+      // @ts-ignore
+      consumer.sources.forEach(
+        /**
+         * @param {string} sourceFile
+         */
+        (sourceFile) => {
+          // @ts-ignore
+          // eslint-disable-next-line no-underscore-dangle
+          mergedMapGenerator._sources.add(sourceFile);
+
+          const sourceContent = consumer.sourceContentFor(sourceFile);
+
+          if (sourceContent != null) {
+            mergedMapGenerator.setSourceContent(sourceFile, sourceContent);
+          }
+        }
+      );
+    });
+
+    const merged = JSON.parse(mergedMapGenerator.toString());
+
+    merged.sourceRoot = oldMap.sourceRoot;
+    merged.file = oldMap.file;
+
+    return merged;
+  };
+
+  const { inputSourceMap } = options;
 
   for (let i = 0; i <= minifyFns.length - 1; i++) {
     const minifyFn = minifyFns[i];
     const minifyOptions = Array.isArray(options.minimizerOptions)
       ? options.minimizerOptions[i]
       : options.minimizerOptions;
+
     // eslint-disable-next-line no-await-in-loop
     const minifyResult = await minifyFn(
       { [options.name]: result.code },
-      result.map,
+      result.map || inputSourceMap,
       minifyOptions,
       options.extractComments
     );
 
     result.code = minifyResult.code;
 
     if (minifyResult.map) {
-      result.map = minifyResult.map;
+      result.map = mergeSourceMap(inputSourceMap, minifyResult.map);
     }
 
     if (minifyResult.warnings && minifyResult.warnings.length > 0) {