@depup/webpack 5.109.2-depup.0 → 5.110.3-depup.0

package/lib/errors/ConflictingResourceHintsWarning.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} ConflictingResourceHintDetails
+ * @property {string} parent the chunk group the directives were written in
+ * @property {string} child the chunk group they point at
+ */
+
+class ConflictingResourceHintsWarning extends WebpackError {
+	/**
+	 * Creates an instance of ConflictingResourceHintsWarning.
+	 * @param {ConflictingResourceHintDetails[]} links the conflicting links, parent name first
+	 */
+	constructor(links) {
+		const list = links
+			.map((link) => `\n  ${link.parent} -> ${link.child}`)
+			.join("");
+
+		super(
+			`conflicting resource hints: these chunks are asked for as both prefetch and preload from the same place:${list}\nThe two say opposite things: a preload fetches the chunk at high priority right away, while a prefetch asks for it at idle priority in case it is needed later. Keep 'webpackPreload' for what the page needs now and 'webpackPrefetch' for what it may need later, not both.\nFor more info visit https://webpack.js.org/guides/code-splitting/#prefetchingpreloading-modules`
+		);
+
+		/** @type {string} */
+		this.name = "ConflictingResourceHintsWarning";
+	}
+}
+
+module.exports = ConflictingResourceHintsWarning;

package/lib/errors/DotenvFileError.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * Error for a dotenv file that exists but could not be read. An absent file is
+ * normal and reported through `missingDependencies` instead.
+ */
+class DotenvFileError extends WebpackError {
+	/**
+	 * @param {string} file path of the dotenv file
+	 * @param {Error} error underlying file system error
+	 */
+	constructor(file, error) {
+		super(`Unable to read the dotenv file ${file}\n${error.message}`);
+
+		this.name = "DotenvFileError";
+		/** @type {string} */
+		this.file = file;
+		this.error = error;
+	}
+}
+
+module.exports = DotenvFileError;

package/lib/errors/DuplicateModulesWarning.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const formatSize = require("../util/formatSize");
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} DuplicateModuleDetails
+ * @property {string} name
+ * @property {number} chunks how many chunks carry a copy
+ * @property {number} wasted bytes the extra copies cost
+ */
+
+class DuplicateModulesWarning extends WebpackError {
+	/**
+	 * Creates an instance of DuplicateModulesWarning.
+	 * @param {DuplicateModuleDetails[]} modules the worst offenders, largest waste first
+	 * @param {number} wasted bytes all duplicated copies cost together
+	 */
+	constructor(modules, wasted) {
+		const list = modules
+			.map(
+				(module) =>
+					`\n  ${module.name} (in ${module.chunks} chunks, ${formatSize(
+						module.wasted
+					)} extra)`
+			)
+			.join("");
+
+		super(
+			`duplicate modules: copies of the same module across chunks add ${formatSize(
+				wasted
+			)}:${list}\nA module reached from several chunks is emitted into each of them unless a shared chunk holds it. 'optimization.splitChunks' can pull it into one.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
+		);
+
+		/** @type {string} */
+		this.name = "DuplicateModulesWarning";
+	}
+}
+
+module.exports = DuplicateModulesWarning;

package/lib/errors/DynamicExportsWarning.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("../WebpackError");
+
+/** @typedef {{ name: string, size: number }} DynamicExportsDetails */
+
+class DynamicExportsWarning extends WebpackError {
+	/**
+	 * Creates an instance of DynamicExportsWarning.
+	 * @param {DynamicExportsDetails[]} modules the modules to name, largest first
+	 * @param {number} total how many were found
+	 */
+	constructor(modules, total) {
+		super(
+			`dynamic exports: webpack cannot tell what ${total} ${total === 1 ? "module exports" : "modules export"}, so nothing importing ${total === 1 ? "it" : "them"} can be tree-shaken:
+${modules.map(({ name, size }) => `  ${name} (${size} bytes)`).join("\n")}
+
+Exports assigned under a condition or through a computed key cannot be read statically. For more info visit https://webpack.js.org/guides/tree-shaking/`
+		);
+
+		this.name = "DynamicExportsWarning";
+	}
+}
+
+module.exports = DynamicExportsWarning;

package/lib/errors/EmbeddedSourceMapsWarning.js

@@ -0,0 +1,25 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class EmbeddedSourceMapsWarning extends WebpackError {
+	/**
+	 * Creates an instance of EmbeddedSourceMapsWarning.
+	 * @param {string} devtool the devtool that embeds them
+	 */
+	constructor(devtool) {
+		super(
+			`embedded source maps: 'devtool: "${devtool}"' writes the source map into the JavaScript itself, and this is a production build.\nThe map is then downloaded by everyone who loads the page, several times the size of the code it describes. A separate '.map' file is fetched only by whoever opens the devtools, and 'hidden-source-map' keeps it off the client entirely while still uploading to an error reporter.\nFor more info visit https://webpack.js.org/configuration/devtool/#production`
+		);
+
+		/** @type {string} */
+		this.name = "EmbeddedSourceMapsWarning";
+	}
+}
+
+module.exports = EmbeddedSourceMapsWarning;

package/lib/errors/EntrypointOverlapWarning.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const formatSize = require("../util/formatSize");
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} EntrypointOverlapDetails
+ * @property {string} name
+ * @property {string[]} entrypoints the entrypoints that each ship a copy
+ * @property {number} wasted bytes the copies past the first cost
+ */
+
+class EntrypointOverlapWarning extends WebpackError {
+	/**
+	 * Creates an instance of EntrypointOverlapWarning.
+	 * @param {EntrypointOverlapDetails[]} modules the worst offenders, largest waste first
+	 * @param {number} wasted bytes all overlapping copies cost together
+	 */
+	constructor(modules, wasted) {
+		const list = modules
+			.map(
+				(module) =>
+					`\n  ${module.name} (in ${module.entrypoints.join(", ")}, ${formatSize(
+						module.wasted
+					)} extra)`
+			)
+			.join("");
+
+		super(
+			`entrypoint overlap: modules shipped by more than one entrypoint add ${formatSize(
+				wasted
+			)}:${list}\nEach entrypoint downloads its own copy. 'optimization.splitChunks' with 'chunks: "all"' can move them into a chunk every entrypoint shares.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
+		);
+
+		/** @type {string} */
+		this.name = "EntrypointOverlapWarning";
+	}
+}
+
+module.exports = EntrypointOverlapWarning;

package/lib/errors/EnvironmentNotSupportAsyncWarning.js

@@ -8,8 +8,8 @@
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @import Module from "../Module" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
 /** @typedef {"asyncWebAssembly" | "topLevelAwait" | "external promise" | "external script" | "external import" | "external module" | "external amd-async"} Feature */
 
 class EnvironmentNotSupportAsyncWarning extends WebpackError {

package/lib/errors/EvalUsageWarning.js

@@ -0,0 +1,28 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class EvalUsageWarning extends WebpackError {
+	/**
+	 * Creates an instance of EvalUsageWarning.
+	 * @param {string[]} modules the modules calling it, named for the report
+	 * @param {number} total how many call it in all
+	 */
+	constructor(modules, total) {
+		const list = modules.map((module) => `\n  ${module}`).join("");
+
+		super(
+			`eval usage: ${total} ${total === 1 ? "module calls" : "modules call"} 'eval' directly:${list}\nA direct eval reads and writes any name in scope, so nothing the module declares can be renamed or dropped: minification, scope hoisting and tree shaking all stop at it. 'new Function' takes no local scope and does not.\nFor more info visit https://webpack.js.org/configuration/optimization/#optimizationconcatenatemodules`
+		);
+
+		/** @type {string} */
+		this.name = "EvalUsageWarning";
+	}
+}
+
+module.exports = EvalUsageWarning;

package/lib/errors/HookWebpackError.js

@@ -65,8 +65,6 @@ class HookWebpackError extends WebpackError {
 
 makeSerializable(HookWebpackError, "webpack/lib/errors/HookWebpackError");
 
-module.exports = HookWebpackError;
-
 /**
  * Creates webpack error.
  * @param {Error} error an error
@@ -78,7 +76,7 @@ const makeWebpackError = (error, hook) => {
 	return new HookWebpackError(error, hook);
 };
 
-module.exports.makeWebpackError = makeWebpackError;
+HookWebpackError.makeWebpackError = makeWebpackError;
 
 /**
  * Creates webpack error callback.
@@ -99,7 +97,7 @@ const makeWebpackErrorCallback = (callback, hook) => (err, result) => {
 	callback(null, result);
 };
 
-module.exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
+HookWebpackError.makeWebpackErrorCallback = makeWebpackErrorCallback;
 
 /**
  * Try run or webpack error.
@@ -122,4 +120,6 @@ const tryRunOrWebpackError = (fn, hook) => {
 	return r;
 };
 
-module.exports.tryRunOrWebpackError = tryRunOrWebpackError;
+HookWebpackError.tryRunOrWebpackError = tryRunOrWebpackError;
+
+module.exports = HookWebpackError;

package/lib/errors/HotspotsWarning.js

@@ -0,0 +1,57 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} HotspotDetails
+ * @property {"loader" | "plugin"} kind what the name refers to
+ * @property {string} name the loader or plugin, as it identified itself
+ * @property {number} ms milliseconds it held the main thread
+ * @property {number} runs how many times it ran
+ */
+
+/**
+ * @typedef {object} HookDetails
+ * @property {string} name the hook
+ * @property {number} ms milliseconds its taps held the main thread
+ */
+
+class HotspotsWarning extends WebpackError {
+	/**
+	 * Creates an instance of HotspotsWarning.
+	 * @param {HotspotDetails[]} hotspots the worst offenders, slowest first
+	 * @param {number} total how many are over the threshold in all
+	 * @param {HookDetails[]} hooks the same time grouped by hook instead
+	 */
+	constructor(hotspots, total, hooks) {
+		const list = hotspots
+			.map(
+				(hotspot) =>
+					`\n  ${hotspot.kind} ${hotspot.name} (${Math.round(hotspot.ms)} ms over ${
+						hotspot.runs
+					} ${hotspot.runs === 1 ? "run" : "runs"})`
+			)
+			.join("");
+
+		const byHook =
+			hooks.length > 0
+				? `\nThe same time, grouped by the hook it ran under:${hooks
+						.map((hook) => `\n  ${hook.name} (${Math.round(hook.ms)} ms)`)
+						.join("")}`
+				: "";
+
+		super(
+			`hotspots: ${total} ${total === 1 ? "thing holds" : "things hold"} the main thread long enough to be worth looking at:${list}${byHook}\nThis is the time each one held the main thread itself, with anything it called out to charged to that instead — so it is what the loader or plugin costs, not what it waited for. Only synchronous stretches count, so work resumed after an await is missing from it. 'ProfilingPlugin' records the same work as a trace when the ordering matters.\nFor more info visit https://webpack.js.org/plugins/profiling-plugin/`
+		);
+
+		/** @type {string} */
+		this.name = "HotspotsWarning";
+	}
+}
+
+module.exports = HotspotsWarning;

package/lib/errors/IgnoreErrorModuleFactory.js

@@ -7,9 +7,13 @@
 
 const ModuleFactory = require("../ModuleFactory");
 
-/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../NormalModuleFactory")} NormalModuleFactory */
+/**
+ * @import {
+ * 	ModuleFactoryCallback,
+ * 	ModuleFactoryCreateData
+ * } from "../ModuleFactory"
+ */
+/** @import NormalModuleFactory from "../NormalModuleFactory" */
 
 /**
  * Ignores error when module is unresolved

package/lib/errors/ImportedBindingAssignmentError.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const WebpackError = require("./WebpackError");
+
+class ImportedBindingAssignmentError extends WebpackError {
+	/**
+	 * Creates an instance of ImportedBindingAssignmentError.
+	 * @param {string} name the local name of the namespace binding
+	 */
+	constructor(name) {
+		super(
+			`Assignment to the imported binding '${name}'. A namespace import is immutable, so this throws a TypeError where the module is a real ES module.`
+		);
+
+		this.name = "ImportedBindingAssignmentError";
+	}
+}
+
+makeSerializable(
+	ImportedBindingAssignmentError,
+	"webpack/lib/errors/ImportedBindingAssignmentError"
+);
+
+module.exports = ImportedBindingAssignmentError;

package/lib/errors/InlinedAssetsWarning.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} InlinedAssetDetails
+ * @property {string} name the asset, by path
+ * @property {number} size the bytes it adds to the JavaScript
+ */
+
+class InlinedAssetsWarning extends WebpackError {
+	/**
+	 * Creates an instance of InlinedAssetsWarning.
+	 * @param {InlinedAssetDetails[]} assets the assets inlined as data urls
+	 * @param {number} total the bytes they add between them
+	 */
+	constructor(assets, total) {
+		const list = assets
+			.map((it) => `\n  ${it.name} (${it.size} bytes)`)
+			.join("");
+
+		super(
+			`inlined assets: ${total} bytes of asset data are embedded in the JavaScript:${list}\nA data url is base64, so it costs about a third more than the file it replaces, cannot be cached on its own, and is downloaded again whenever the code around it changes. 'Rule.parser.dataUrlCondition.maxSize' decides which files are small enough to be worth that.\nFor more info visit https://webpack.js.org/guides/asset-modules/#general-asset-type`
+		);
+
+		/** @type {string} */
+		this.name = "InlinedAssetsWarning";
+	}
+}
+
+module.exports = InlinedAssetsWarning;

package/lib/errors/InvalidDependenciesModuleWarning.js

@@ -8,7 +8,7 @@
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../Module")} Module */
+/** @import Module from "../Module" */
 
 class InvalidDependenciesModuleWarning extends WebpackError {
 	/**

package/lib/errors/LargeModulesWarning.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const formatSize = require("../util/formatSize");
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} LargeModuleDetails
+ * @property {string} name the module, shortened for the report
+ * @property {string} chunk the chunk it weighs down
+ * @property {number} size bytes the module contributes
+ * @property {number} chunkSize bytes the whole chunk contributes
+ */
+
+class LargeModulesWarning extends WebpackError {
+	/**
+	 * Creates an instance of LargeModulesWarning.
+	 * @param {LargeModuleDetails[]} modules the worst offenders, largest first
+	 * @param {number} total how many dominating modules there are in all
+	 */
+	constructor(modules, total) {
+		const list = modules
+			.map((module) => {
+				const share = Math.round((module.size / module.chunkSize) * 100);
+
+				return `\n  ${module.name} is ${share}% of '${module.chunk}' (${formatSize(
+					module.size
+				)} of ${formatSize(module.chunkSize)})`;
+			})
+			.join("");
+
+		super(
+			`large modules: ${total} ${total === 1 ? "module carries" : "modules carry"} most of the chunk ${total === 1 ? "it is" : "they are"} in:${list}\nEverything else in the chunk together weighs less than this one module, so splitting it out with 'optimization.splitChunks', loading it on demand, or replacing it is what changes the size.\nFor more info visit https://webpack.js.org/guides/code-splitting/`
+		);
+
+		/** @type {string} */
+		this.name = "LargeModulesWarning";
+	}
+}
+
+module.exports = LargeModulesWarning;

package/lib/errors/LegacyJavascriptWarning.js

@@ -0,0 +1,48 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const formatSize = require("../util/formatSize");
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} LegacyPackageDetails
+ * @property {string} name the package doing the emulating
+ * @property {number} modules how many of its modules are in the build
+ * @property {number} size bytes they contribute
+ */
+
+class LegacyJavascriptWarning extends WebpackError {
+	/**
+	 * Creates an instance of LegacyJavascriptWarning.
+	 * @param {LegacyPackageDetails[]} packages the ones found, largest first
+	 * @param {number} totalSize bytes they contribute between them
+	 * @param {string[]} features the ones the target already has
+	 */
+	constructor(packages, totalSize, features) {
+		const list = packages
+			.map(
+				(item) =>
+					`\n  ${item.name} (${item.modules} ${
+						item.modules === 1 ? "module" : "modules"
+					}, ${formatSize(item.size)})`
+			)
+			.join("");
+
+		super(
+			`legacy javascript: ${formatSize(
+				totalSize
+			)} of the build emulates syntax the target already has natively:${list}\n'output.environment' says this target supports ${features.join(
+				", "
+			)}, so whatever lowers the syntax — usually '@babel/preset-env' — is compiling for older browsers than webpack is. Lining its targets up with the browserslist webpack reads drops them.\nFor more info visit https://webpack.js.org/configuration/target/#browserslist`
+		);
+
+		/** @type {string} */
+		this.name = "LegacyJavascriptWarning";
+	}
+}
+
+module.exports = LegacyJavascriptWarning;

package/lib/errors/MissingSideEffectsWarning.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("../WebpackError");
+
+/** @typedef {{ name: string, modules: number, size: number }} MissingSideEffectsDetails */
+
+class MissingSideEffectsWarning extends WebpackError {
+	/**
+	 * Creates an instance of MissingSideEffectsWarning.
+	 * @param {MissingSideEffectsDetails[]} packages the packages to name, costliest first
+	 * @param {number} total how many packages were found
+	 * @param {number} wasted the bytes they keep in the bundle
+	 */
+	constructor(packages, total, wasted) {
+		super(
+			`missing sideEffects: ${total} ${total === 1 ? "package keeps" : "packages keep"} ${wasted} bytes of unused code because ${total === 1 ? "its" : "their"} package.json does not declare 'sideEffects':
+${packages
+	.map(
+		({ name, modules, size }) =>
+			`  ${name} (${size} bytes in ${modules} ${modules === 1 ? "module" : "modules"})`
+	)
+	.join("\n")}
+
+Without the field webpack must assume every module runs code on import. For more info visit https://webpack.js.org/guides/tree-shaking/`
+		);
+
+		this.name = "MissingSideEffectsWarning";
+	}
+}
+
+module.exports = MissingSideEffectsWarning;

package/lib/errors/MixedExportsWarning.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} MixedExportsDetails
+ * @property {string} name the entry, by name
+ * @property {string[]} named the named exports sitting beside the default
+ */
+
+class MixedExportsWarning extends WebpackError {
+	/**
+	 * Creates an instance of MixedExportsWarning.
+	 * @param {MixedExportsDetails[]} entries the entries that mix them
+	 * @param {string} type the library type they are built for
+	 */
+	constructor(entries, type) {
+		const list = entries
+			.map(
+				(entry) =>
+					`\n  ${entry.name} (default and ${entry.named.length}: ${entry.named
+						.slice(0, 3)
+						.join(", ")}${entry.named.length > 3 ? ", …" : ""})`
+			)
+			.join("");
+
+		super(
+			`mixed exports: ${entries.length} ${entries.length === 1 ? "entry exports" : "entries export"} a default beside named exports for the '${type}' library:${list}\nA consumer calling 'require()' gets the namespace object, so the default arrives as '.default' rather than as the value itself. Exporting only a default, or only named exports, leaves no ambiguity — 'output.library.export' can also pick one.\nFor more info visit https://webpack.js.org/configuration/output/#outputlibraryexport`
+		);
+
+		/** @type {string} */
+		this.name = "MixedExportsWarning";
+	}
+}
+
+module.exports = MixedExportsWarning;

package/lib/errors/ModuleDependencyError.js

@@ -5,11 +5,13 @@
 
 "use strict";
 
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
+const deriveStackFromNestedError = require("./deriveStackFromNestedError");
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("./ModuleBuildError").ErrorWithHideStack} ErrorWithHideStack */
+/** @import { DependencyLocation } from "../Dependency" */
+/** @import Module from "../Module" */
+/** @import { ErrorWithHideStack } from "./ModuleBuildError" */
 
 class ModuleDependencyError extends WebpackError {
 	/**
@@ -19,15 +21,11 @@ class ModuleDependencyError extends WebpackError {
 	 * @param {DependencyLocation} loc location of dependency
 	 */
 	constructor(module, err, loc) {
-		super(err.message);
+		// Deserialization constructs with no arguments, so `err` is absent there.
+		super(err ? err.message : "");
 
 		/** @type {string} */
 		this.name = "ModuleDependencyError";
-		/** @type {string | undefined} */
-		this.details =
-			err && !err.hideStack
-				? /** @type {string} */ (err.stack).split("\n").slice(1).join("\n")
-				: undefined;
 		/** @type {Module} */
 		this.module = module;
 		/** @type {DependencyLocation} */
@@ -38,14 +36,13 @@ class ModuleDependencyError extends WebpackError {
 		 */
 		this.error = err;
 
-		if (err && err.hideStack && err.stack) {
-			/** @type {string | undefined} */
-			this.stack = /** @type {string} */ `${err.stack
-				.split("\n")
-				.slice(1)
-				.join("\n")}\n\n${this.stack}`;
-		}
+		deriveStackFromNestedError(this, err);
 	}
 }
 
+makeSerializable(
+	ModuleDependencyError,
+	"webpack/lib/errors/ModuleDependencyError"
+);
+
 module.exports = ModuleDependencyError;