@umijs/bundler-webpack 4.0.0-beta.9 → 4.0.0-canary-20240513.3

package/dist/cli.js

@@ -1,93 +1,96 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const esbuild_1 = __importDefault(require("@umijs/bundler-utils/compiled/esbuild"));
-const utils_1 = require("@umijs/utils");
-const assert_1 = __importDefault(require("assert"));
-const fs_1 = require("fs");
-const path_1 = require("path");
-const build_1 = require("./build");
-const dev_1 = require("./dev");
-const args = (0, utils_1.yParser)(process.argv.slice(2), {});
-const command = args._[0];
-const cwd = process.cwd();
-const entry = tryPaths([
-    (0, path_1.join)(cwd, 'src/index.tsx'),
-    (0, path_1.join)(cwd, 'src/index.ts'),
-    (0, path_1.join)(cwd, 'index.tsx'),
-    (0, path_1.join)(cwd, 'index.ts'),
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_esbuild = __toESM(require("@umijs/bundler-utils/compiled/esbuild"));
+var import_utils = require("@umijs/utils");
+var import_assert = __toESM(require("assert"));
+var import_fs = require("fs");
+var import_path = require("path");
+var import_build = require("./build");
+var import_dev = require("./dev");
+var args = (0, import_utils.yParser)(process.argv.slice(2), {});
+var command = args._[0];
+var cwd = process.cwd();
+var entry = (0, import_utils.tryPaths)([
+  (0, import_path.join)(cwd, "src/index.tsx"),
+  (0, import_path.join)(cwd, "src/index.ts"),
+  (0, import_path.join)(cwd, "index.tsx"),
+  (0, import_path.join)(cwd, "index.ts")
 ]);
-let config = {};
-const configFile = (0, path_1.join)(cwd, args.config || 'config.ts');
-utils_1.register.register({
-    implementor: esbuild_1.default,
+var config = {};
+var configFile = (0, import_path.resolve)(cwd, args.config || "config.ts");
+import_utils.register.register({
+  implementor: import_esbuild.default
 });
-utils_1.register.clearFiles();
-if ((0, fs_1.existsSync)(configFile)) {
-    require('./requireHook');
-    config = require(configFile).default;
+import_utils.register.clearFiles();
+if ((0, import_fs.existsSync)(configFile)) {
+  require("./requireHook");
+  config = require(configFile).default;
 }
 Object.assign(config, args);
-if (command === 'build') {
-    (() => __awaiter(void 0, void 0, void 0, function* () {
-        process.env.NODE_ENV = 'production';
-        (0, assert_1.default)(entry, `Build failed: entry not found.`);
-        try {
-            yield (0, build_1.build)({
-                config,
-                cwd,
-                entry: {
-                    [getEntryKey(entry)]: entry,
-                },
-            });
-        }
-        catch (e) {
-            console.error(e);
+if (command === "build") {
+  (async () => {
+    process.env.NODE_ENV = "production";
+    (0, import_assert.default)(entry, `Build failed: entry not found.`);
+    try {
+      await (0, import_build.build)({
+        config,
+        cwd,
+        entry: {
+          [getEntryKey(entry)]: entry
         }
-    }))();
-}
-else if (command === 'dev') {
-    (() => __awaiter(void 0, void 0, void 0, function* () {
-        process.env.NODE_ENV = 'development';
-        try {
-            (0, assert_1.default)(entry, `Build failed: entry not found.`);
-            yield (0, dev_1.dev)({
-                config,
-                cwd,
-                port: process.env.PORT,
-                entry: {
-                    [getEntryKey(entry)]: entry,
-                },
-            });
-        }
-        catch (e) {
-            console.error(e);
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  })();
+} else if (command === "dev") {
+  (async () => {
+    process.env.NODE_ENV = "development";
+    try {
+      (0, import_assert.default)(entry, `Build failed: entry not found.`);
+      await (0, import_dev.dev)({
+        config,
+        cwd,
+        port: process.env.PORT,
+        entry: {
+          [getEntryKey(entry)]: entry
+        },
+        cache: {
+          buildDependencies: [].filter(Boolean)
         }
-    }))();
-}
-else {
-    error(`Unsupported command ${command}.`);
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  })();
+} else {
+  error(`Unsupported command ${command}.`);
 }
 function error(msg) {
-    console.error(utils_1.chalk.red(msg));
-}
-function tryPaths(paths) {
-    for (const path of paths) {
-        if ((0, fs_1.existsSync)(path))
-            return path;
-    }
+  console.error(import_utils.chalk.red(msg));
 }
 function getEntryKey(path) {
-    return (0, path_1.basename)(path, (0, path_1.extname)(path));
+  return (0, import_path.basename)(path, (0, import_path.extname)(path));
 }

package/dist/config/_sampleFeature.js

@@ -1,22 +1,35 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addSampleFeature = void 0;
-function addSampleFeature(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { config, userConfig, cwd, env } = opts;
-        config;
-        userConfig;
-        cwd;
-        env;
-    });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/_sampleFeature.ts
+var sampleFeature_exports = {};
+__export(sampleFeature_exports, {
+  addSampleFeature: () => addSampleFeature
+});
+module.exports = __toCommonJS(sampleFeature_exports);
+async function addSampleFeature(opts) {
+  const { config, userConfig, cwd, env } = opts;
+  config;
+  userConfig;
+  cwd;
+  env;
 }
-exports.addSampleFeature = addSampleFeature;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addSampleFeature
+});

package/dist/config/assetRules.js

@@ -1,69 +1,48 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addAssetRules = void 0;
-function addAssetRules(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { config, userConfig } = opts;
-        const inlineLimit = parseInt(userConfig.inlineLimit || '10000', 10);
-        const rule = config.module.rule('asset');
-        rule
-            .oneOf('avif')
-            .test(/\.avif$/)
-            .type('asset')
-            .mimetype('image/avif')
-            .parser({
-            dataUrlCondition: {
-                maxSize: inlineLimit,
-            },
-        })
-            .generator({
-            filename: `${opts.staticPathPrefix}[name].[hash:8].[ext]`,
-        });
-        rule
-            .oneOf('image')
-            .test(/\.(bmp|gif|jpg|jpeg|png)$/)
-            .type('asset')
-            .parser({
-            dataUrlCondition: {
-                maxSize: inlineLimit,
-            },
-        })
-            .generator({
-            filename: `${opts.staticPathPrefix}[name].[hash:8].[ext]`,
-        });
-        rule
-            .oneOf('svg')
-            .type('asset')
-            .resourceQuery(/url/)
-            .parser({
-            dataUrlCondition: {
-                maxSize: 1000,
-            },
-        })
-            .generator({
-            filename: `${opts.staticPathPrefix}[name].[hash:8].[ext]`,
-        });
-        rule
-            .oneOf('fallback')
-            .exclude.add(/^$/) /* handle data: resources */
-            .add(/\.(js|mjs|jsx|ts|tsx)$/)
-            .add(/\.(css|less|sass|scss|stylus)$/)
-            .add(/\.html$/)
-            .add(/\.json$/)
-            .end()
-            .type('asset/resource')
-            .generator({
-            filename: `${opts.staticPathPrefix}[name].[hash:8].[ext]`,
-        });
-    });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/assetRules.ts
+var assetRules_exports = {};
+__export(assetRules_exports, {
+  addAssetRules: () => addAssetRules
+});
+module.exports = __toCommonJS(assetRules_exports);
+async function addAssetRules(opts) {
+  const { config, userConfig } = opts;
+  const inlineLimit = userConfig.inlineLimit;
+  const rule = config.module.rule("asset");
+  rule.oneOf("avif").test(/\.avif$/).type("asset").mimetype("image/avif").parser({
+    dataUrlCondition: {
+      maxSize: inlineLimit
+    }
+  });
+  rule.oneOf("image").test(/\.(bmp|gif|jpg|jpeg|png)$/).type("asset").parser({
+    dataUrlCondition: {
+      maxSize: inlineLimit
+    }
+  });
+  const fallback = rule.oneOf("fallback").exclude.add(/^$/).add(/\.(js|mjs|cjs|jsx|ts|tsx)$/).add(/\.(css|less|sass|scss|styl|stylus)$/).add(/\.html$/).add(/\.json$/);
+  if (userConfig.mdx) {
+    fallback.add(/\.mdx?$/);
+  }
+  fallback.end().type("asset/resource");
 }
-exports.addAssetRules = addAssetRules;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addAssetRules
+});

package/dist/config/bundleAnalyzerPlugin.js

@@ -1,30 +1,43 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addBundleAnalyzerPlugin = void 0;
-// @ts-ignore
-const webpack_bundle_analyzer_1 = require("@umijs/bundler-webpack/compiled/webpack-bundle-analyzer");
-function addBundleAnalyzerPlugin(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { config } = opts;
-        config.plugin('webpack-bundle-analyzer').use(webpack_bundle_analyzer_1.BundleAnalyzerPlugin, [
-            // https://github.com/webpack-contrib/webpack-bundle-analyzer
-            {
-                analyzerMode: 'server',
-                analyzerPort: process.env.ANALYZE_PORT || 8888,
-                openAnalyzer: false,
-                logLevel: 'info',
-                defaultSizes: 'parsed',
-            },
-        ]);
-    });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/bundleAnalyzerPlugin.ts
+var bundleAnalyzerPlugin_exports = {};
+__export(bundleAnalyzerPlugin_exports, {
+  addBundleAnalyzerPlugin: () => addBundleAnalyzerPlugin
+});
+module.exports = __toCommonJS(bundleAnalyzerPlugin_exports);
+var import_webpack_bundle_analyzer = require("@umijs/bundler-webpack/compiled/webpack-bundle-analyzer");
+async function addBundleAnalyzerPlugin(opts) {
+  const { config } = opts;
+  config.plugin("webpack-bundle-analyzer").use(import_webpack_bundle_analyzer.BundleAnalyzerPlugin, [
+    // https://github.com/webpack-contrib/webpack-bundle-analyzer
+    {
+      analyzerMode: "server",
+      analyzerPort: process.env.ANALYZE_PORT || 8888,
+      openAnalyzer: false,
+      logLevel: "info",
+      defaultSizes: "parsed",
+      ...opts.userConfig.analyze
+    }
+  ]);
 }
-exports.addBundleAnalyzerPlugin = addBundleAnalyzerPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addBundleAnalyzerPlugin
+});

package/dist/config/compressPlugin.js

@@ -1,77 +1,128 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addCompressPlugin = void 0;
-// @ts-ignore
-const css_minimizer_webpack_plugin_1 = __importDefault(require("@umijs/bundler-webpack/compiled/css-minimizer-webpack-plugin"));
-const terser_webpack_plugin_1 = __importDefault(require("../../compiled/terser-webpack-plugin"));
-const ESBuildCSSMinifyPlugin_1 = __importDefault(require("../plugins/ESBuildCSSMinifyPlugin"));
-const types_1 = require("../types");
-function addCompressPlugin(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { config, userConfig, env } = opts;
-        const jsMinifier = userConfig.jsMinifier || types_1.JSMinifier.esbuild;
-        const cssMinifier = userConfig.cssMinifier || types_1.CSSMinifier.esbuild;
-        if (env === types_1.Env.development ||
-            process.env.COMPRESS === 'none' ||
-            (jsMinifier === types_1.JSMinifier.none && cssMinifier === types_1.CSSMinifier.none)) {
-            config.optimization.minimize(false);
-            return;
-        }
-        config.optimization.minimize(true);
-        let minify;
-        if (jsMinifier === types_1.JSMinifier.esbuild) {
-            minify = terser_webpack_plugin_1.default.esbuildMinify;
-        }
-        else if (jsMinifier === types_1.JSMinifier.terser) {
-            minify = terser_webpack_plugin_1.default.terserMinify;
-        }
-        else if (jsMinifier === types_1.JSMinifier.swc) {
-            minify = terser_webpack_plugin_1.default.swcMinify;
-        }
-        else if (jsMinifier === types_1.JSMinifier.uglifyJs) {
-            minify = terser_webpack_plugin_1.default.uglifyJsMinify;
-        }
-        else if (jsMinifier !== types_1.JSMinifier.none) {
-            throw new Error(`Unsupported jsMinifier ${userConfig.jsMinifier}.`);
-        }
-        if (jsMinifier !== types_1.JSMinifier.none) {
-            config.optimization.minimizer(`js-${jsMinifier}`).use(terser_webpack_plugin_1.default, [
-                {
-                    minify,
-                    terserOptions: userConfig.jsMinifierOptions,
-                },
-            ]);
-        }
-        if (cssMinifier === types_1.CSSMinifier.esbuild) {
-            config.optimization
-                .minimizer(`css-${cssMinifier}`)
-                .use(ESBuildCSSMinifyPlugin_1.default, [userConfig.cssMinifierOptions]);
-        }
-        else if (cssMinifier === types_1.CSSMinifier.cssnano) {
-            config.optimization
-                .minimizer(`css-${cssMinifier}`)
-                .use(css_minimizer_webpack_plugin_1.default, [
-                {
-                    minimizerOptions: userConfig.cssMinifierOptions,
-                    parallel: true,
-                },
-            ]);
-        }
-        else if (cssMinifier !== types_1.CSSMinifier.none) {
-            throw new Error(`Unsupported cssMinifier ${userConfig.cssMinifier}.`);
-        }
-    });
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/compressPlugin.ts
+var compressPlugin_exports = {};
+__export(compressPlugin_exports, {
+  addCompressPlugin: () => addCompressPlugin
+});
+module.exports = __toCommonJS(compressPlugin_exports);
+var import_css_minimizer_webpack_plugin = __toESM(require("@umijs/bundler-webpack/compiled/css-minimizer-webpack-plugin"));
+var import_terser_webpack_plugin = __toESM(require("../../compiled/terser-webpack-plugin"));
+var import_EsbuildMinifyFix = require("../plugins/EsbuildMinifyFix");
+var import_types = require("../types");
+var import_getEsBuildTarget = require("../utils/getEsBuildTarget");
+async function addCompressPlugin(opts) {
+  const { config, userConfig, env } = opts;
+  const jsMinifier = userConfig.jsMinifier || import_types.JSMinifier.esbuild;
+  const cssMinifier = userConfig.cssMinifier || import_types.CSSMinifier.esbuild;
+  if (env === import_types.Env.development || process.env.COMPRESS === "none" || jsMinifier === import_types.JSMinifier.none && cssMinifier === import_types.CSSMinifier.none) {
+    config.optimization.minimize(false);
+    return;
+  }
+  config.optimization.minimize(true);
+  const esbuildTarget = (0, import_getEsBuildTarget.getEsBuildTarget)({
+    targets: userConfig.targets || {},
+    jsMinifier
+  });
+  if (!esbuildTarget.includes("es2015")) {
+    esbuildTarget.push("es2015");
+  }
+  let minify;
+  let terserOptions;
+  if (jsMinifier === import_types.JSMinifier.esbuild) {
+    minify = import_terser_webpack_plugin.default.esbuildMinify;
+    terserOptions = {
+      target: esbuildTarget,
+      // remove all comments
+      legalComments: "none"
+    };
+    if (userConfig.esbuildMinifyIIFE) {
+      config.plugin("EsbuildMinifyFix").use(import_EsbuildMinifyFix.EsbuildMinifyFix);
+    }
+  } else if (jsMinifier === import_types.JSMinifier.terser) {
+    minify = import_terser_webpack_plugin.default.terserMinify;
+    terserOptions = {
+      format: {
+        comments: false
+      }
+    };
+  } else if (jsMinifier === import_types.JSMinifier.swc) {
+    minify = import_terser_webpack_plugin.default.swcMinify;
+  } else if (jsMinifier === import_types.JSMinifier.uglifyJs) {
+    minify = import_terser_webpack_plugin.default.uglifyJsMinify;
+    terserOptions = {
+      output: {
+        comments: false
+      }
+    };
+  } else if (jsMinifier !== import_types.JSMinifier.none) {
+    throw new Error(`Unsupported jsMinifier ${userConfig.jsMinifier}.`);
+  }
+  terserOptions = {
+    ...terserOptions,
+    ...userConfig.jsMinifierOptions
+  };
+  if (jsMinifier !== import_types.JSMinifier.none) {
+    config.optimization.minimizer(`js-${jsMinifier}`).use(import_terser_webpack_plugin.default, [
+      {
+        extractComments: false,
+        minify,
+        terserOptions
+      }
+    ]);
+  }
+  let cssMinify;
+  let minimizerOptions;
+  if (cssMinifier === import_types.CSSMinifier.esbuild) {
+    cssMinify = import_css_minimizer_webpack_plugin.default.esbuildMinify;
+    minimizerOptions = {
+      target: esbuildTarget
+    };
+  } else if (cssMinifier === import_types.CSSMinifier.cssnano) {
+    cssMinify = import_css_minimizer_webpack_plugin.default.cssnanoMinify;
+  } else if (cssMinifier === import_types.CSSMinifier.parcelCSS) {
+    cssMinify = import_css_minimizer_webpack_plugin.default.lightningCssMinify;
+  } else if (cssMinifier !== import_types.CSSMinifier.none) {
+    throw new Error(`Unsupported cssMinifier ${userConfig.cssMinifier}.`);
+  }
+  minimizerOptions = {
+    ...minimizerOptions,
+    ...userConfig.cssMinifierOptions
+  };
+  config.optimization.minimizer(`css-${cssMinifier}`).use(import_css_minimizer_webpack_plugin.default, [
+    {
+      minify: cssMinify,
+      minimizerOptions
+    }
+  ]);
 }
-exports.addCompressPlugin = addCompressPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addCompressPlugin
+});