webpack 5.111.0 → 5.112.0

package/lib/errors/AsyncDependencyToInitialChunkError.js

@@ -7,8 +7,8 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @import { DependencyLocation } from "../Dependency" */
-/** @import Module from "../Module" */
+/** @import { DependencyLocation } from "../graph/Dependency" */
+/** @import Module from "../module/Module" */
 
 /**
  * Error raised when webpack detects an attempt to lazy-load a chunk name that

package/lib/errors/BuildCycleError.js

@@ -7,7 +7,7 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @import Module from "../Module" */
+/** @import Module from "../module/Module" */
 
 class BuildCycleError extends WebpackError {
 	/**

package/lib/{WarnCaseSensitiveModulesPlugin.js → errors/CaseSensitiveModulesWarning.js}

@@ -5,12 +5,10 @@
 
 "use strict";
 
-/** @import Compiler from "./Compiler" */
-/** @import Module from "./Module" */
-/** @import ModuleGraph from "./ModuleGraph" */
-/** @import NormalModule from "./NormalModule" */
+const WebpackError = require("./WebpackError");
 
-const WebpackError = require("./errors/WebpackError");
+/** @import Module from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 
 /**
  * Sorts the conflicting modules by identifier to keep warning output stable.
@@ -80,54 +78,4 @@ ${modulesList}`);
 	}
 }
 
-const PLUGIN_NAME = "WarnCaseSensitiveModulesPlugin";
-
-class WarnCaseSensitiveModulesPlugin {
-	/**
-	 * Applies the plugin by registering its hooks on the compiler.
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
-			compilation.hooks.seal.tap(PLUGIN_NAME, () => {
-				/** @type {Map<string, Map<string, Module>>} */
-				const moduleWithoutCase = new Map();
-				for (const module of compilation.modules) {
-					const identifier = module.identifier();
-
-					// Ignore `data:` URLs, because it's not a real path
-					if (
-						/** @type {NormalModule} */
-						(module).resourceResolveData !== undefined &&
-						/** @type {NormalModule} */
-						(module).resourceResolveData.encodedContent !== undefined
-					) {
-						continue;
-					}
-
-					const lowerIdentifier = identifier.toLowerCase();
-					let map = moduleWithoutCase.get(lowerIdentifier);
-					if (map === undefined) {
-						map = new Map();
-						moduleWithoutCase.set(lowerIdentifier, map);
-					}
-					map.set(identifier, module);
-				}
-				for (const pair of moduleWithoutCase) {
-					const map = pair[1];
-					if (map.size > 1) {
-						compilation.warnings.push(
-							new CaseSensitiveModulesWarning(
-								map.values(),
-								compilation.moduleGraph
-							)
-						);
-					}
-				}
-			});
-		});
-	}
-}
-
-module.exports = WarnCaseSensitiveModulesPlugin;
+module.exports = CaseSensitiveModulesWarning;

package/lib/errors/ChunkRenderError.js

@@ -7,7 +7,7 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @import Chunk from "../Chunk" */
+/** @import Chunk from "../graph/Chunk" */
 
 class ChunkRenderError extends WebpackError {
 	/**

package/lib/errors/CodeGenerationError.js

@@ -7,7 +7,7 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @import Module from "../Module" */
+/** @import Module from "../module/Module" */
 
 class CodeGenerationError extends WebpackError {
 	/**

package/lib/errors/CommentCompilationWarning.js

@@ -8,7 +8,7 @@
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 
-/** @import { DependencyLocation } from "../Dependency" */
+/** @import { DependencyLocation } from "../graph/Dependency" */
 
 /**
  * Warning used for comment-related compilation issues, such as malformed magic

package/lib/errors/ConflictingEntryExportsWarning.js

@@ -0,0 +1,38 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @import Chunk from "../graph/Chunk" */
+
+/**
+ * Warning raised when several modules of an `entryExports: "all"` entry bind the same
+ * export name, which leaves the name out of the merged exports.
+ */
+class ConflictingEntryExportsWarning extends WebpackError {
+	/**
+	 * Captures the entry's chunk and the names it cannot expose.
+	 * @param {Chunk} chunk the chunk carrying the entry
+	 * @param {string[]} names the conflicting export names
+	 */
+	constructor(chunk, names) {
+		super(
+			`Entry "${chunk.name || chunk.id}" contains conflicting exports for the ${
+				names.length === 1 ? "name" : "names"
+			} ${names.map((name) => `'${name}'`).join(", ")}, so ${
+				names.length === 1 ? "it is" : "they are"
+			} not exposed by the merged exports.`
+		);
+
+		/** @type {string} */
+		this.name = "ConflictingEntryExportsWarning";
+		/** @type {Chunk} */
+		this.chunk = chunk;
+	}
+}
+
+module.exports = ConflictingEntryExportsWarning;

package/lib/{dependencies → errors}/CriticalDependencyWarning.js

@@ -23,9 +23,10 @@ class CriticalDependencyWarning extends WebpackError {
 	}
 }
 
-makeSerializable(
-	CriticalDependencyWarning,
+makeSerializable(CriticalDependencyWarning, [
+	"webpack/lib/errors/CriticalDependencyWarning",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/CriticalDependencyWarning"
-);
+]);
 
 module.exports = CriticalDependencyWarning;

package/lib/errors/DeprecatedOptionWarning.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class DeprecatedOptionWarning extends WebpackError {
+	/**
+	 * Create an instance deprecated option warning
+	 * @param {string} option the target option
+	 * @param {string | number} value the deprecated option value
+	 * @param {string} suggestion the suggestion replacement
+	 */
+	constructor(option, value, suggestion) {
+		super();
+
+		/** @type {string} */
+		this.name = "DeprecatedOptionWarning";
+		/** @type {string} */
+		this.message =
+			"configuration\n" +
+			`The value '${value}' for option '${option}' is deprecated. ` +
+			`Use '${suggestion}' instead.`;
+	}
+}
+
+module.exports = DeprecatedOptionWarning;

package/lib/errors/DllManifestError.js

@@ -0,0 +1,26 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class DllManifestError extends WebpackError {
+	/**
+	 * Creates an instance of DllManifestError.
+	 * @param {string} filename filename of the manifest
+	 * @param {string} message error message
+	 */
+	constructor(filename, message) {
+		super();
+
+		/** @type {string} */
+		this.name = "DllManifestError";
+		/** @type {string} */
+		this.message = `Dll manifest ${filename}\n${message}`;
+	}
+}
+
+module.exports = DllManifestError;

package/lib/{performance → errors}/DuplicatePackagesWarning.js

@@ -5,13 +5,13 @@
 
 "use strict";
 
-const WebpackError = require("../errors/WebpackError");
+const WebpackError = require("./WebpackError");
 
-/** @import Module from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import NormalModule from "../NormalModule" */
-/** @import RequestShortener from "../RequestShortener" */
-/** @import { PackageCopy } from "./DuplicatePackagesPlugin" */
+/** @import Module from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import NormalModule from "../module/NormalModule" */
+/** @import RequestShortener from "../util/RequestShortener" */
+/** @import { PackageCopy } from "../performance/DuplicatePackagesPlugin" */
 
 /**
  * @param {Module} module the module

package/lib/{dependencies/HarmonyLinkingError.js → errors/ESMLinkingError.js}

@@ -4,17 +4,17 @@
 
 "use strict";
 
-const WebpackError = require("../errors/WebpackError");
+const WebpackError = require("./WebpackError");
 
-class HarmonyLinkingError extends WebpackError {
+class ESMLinkingError extends WebpackError {
 	/** @param {string} message Error message */
 	constructor(message) {
 		super(message);
 		/** @type {string} */
-		this.name = "HarmonyLinkingError";
+		this.name = "ESMLinkingError";
 		/** @type {boolean} */
 		this.hideStack = true;
 	}
 }
 
-module.exports = HarmonyLinkingError;
+module.exports = ESMLinkingError;

package/lib/{performance → errors}/EntrypointsOverSizeLimitWarning.js

@@ -5,10 +5,10 @@
 
 "use strict";
 
-const WebpackError = require("../errors/WebpackError");
 const formatSize = require("../util/formatSize");
+const WebpackError = require("./WebpackError");
 
-/** @import { EntrypointDetails } from "./SizeLimitsPlugin" */
+/** @import { EntrypointDetails } from "../performance/SizeLimitsPlugin" */
 
 class EntrypointsOverSizeLimitWarning extends WebpackError {
 	/**

package/lib/errors/EnvironmentNotSupportAsyncWarning.js

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

package/lib/errors/ErrorHelpers.js

@@ -0,0 +1,222 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const path = require("path");
+const { fileUrlToPath } = require("../util/identifier");
+const memoize = require("../util/memoize");
+
+/** @import RequestShortener from "../util/RequestShortener" */
+
+const getNonErrorEmittedError = memoize(() =>
+	require("./NonErrorEmittedError")
+);
+
+const loaderFlag = "LOADER_EXECUTION";
+
+const webpackOptionsFlag = "WEBPACK_OPTIONS";
+
+// Every frame of a stack is indented, so a line opening with `at ` after
+// whitespace is a frame rather than a part of the message itself.
+const STACK_FRAME_REGEXP = /^\s+at\s/;
+
+// `at name (file:line:column)`, and the `at file:line:column` a frame with no
+// name is written as.
+const STACK_FRAME_FILE_REGEXP = /^(\s+at\s(?:.*\()?)(.+?):(\d+):(\d+)(\)?)$/;
+
+// A generated function nests its parentheses and carries a position of its
+// own, so each `file:line:column` in it is read on its own.
+const GENERATED_FRAME_REGEXP = /\beval at /;
+const POSITION_REGEXP = /([^\s()]+):\d+:\d+/g;
+
+// Every frame under lib/ is webpack's own, so this names that root rather
+// than this file's directory, which would narrow it to lib/errors/.
+const WEBPACK_SOURCE_PATH = path.join(__dirname, "..", path.sep);
+
+// The engine's own frames name no file of the project: `node:internal/…` under
+// node and deno, the bare `native` under bun.
+const ENGINE_FILE_REGEXP = /^(?:node:|native$)/;
+
+/**
+ * Returns stack trace without the specified flag included.
+ * @param {string} stack stack trace
+ * @param {string} flag flag to cut off
+ * @returns {string} stack trace without the specified flag included
+ */
+const cutOffByFlag = (stack, flag) => {
+	const errorStack = stack.split("\n");
+	for (let i = 0; i < errorStack.length; i++) {
+		if (errorStack[i].includes(flag)) {
+			errorStack.length = i;
+		}
+	}
+	return errorStack.join("\n");
+};
+
+/**
+ * Cut off loader execution.
+ * @param {string} stack stack trace
+ * @returns {string} stack trace without the loader execution flag included
+ */
+const cutOffLoaderExecution = (stack) => cutOffByFlag(stack, loaderFlag);
+
+/**
+ * Cut off webpack options.
+ * @param {string} stack stack trace
+ * @returns {string} stack trace without the webpack options flag included
+ */
+const cutOffWebpackOptions = (stack) => cutOffByFlag(stack, webpackOptionsFlag);
+
+/**
+ * Cut off multiline message.
+ * @param {string} stack stack trace
+ * @param {string} message error message
+ * @returns {string} stack trace without the message included
+ */
+const cutOffMultilineMessage = (stack, message) => {
+	const stackSplitByLines = stack.split("\n");
+	const messageSplitByLines = message.split("\n");
+
+	/** @type {string[]} */
+	const result = [];
+
+	for (const [idx, line] of stackSplitByLines.entries()) {
+		if (!line.includes(messageSplitByLines[idx])) result.push(line);
+	}
+
+	return result.join("\n");
+};
+
+/**
+ * Returns stack trace without the message included.
+ * @param {string} stack stack trace
+ * @param {string} message error message
+ * @returns {string} stack trace without the message included
+ */
+const cutOffMessage = (stack, message) => {
+	const nextLine = stack.indexOf("\n");
+	if (nextLine === -1) {
+		return stack === message ? "" : stack;
+	}
+	const firstLine = stack.slice(0, nextLine);
+	return firstLine === message ? stack.slice(nextLine + 1) : stack;
+};
+
+/**
+ * Returns the file a stack frame names, or undefined when the line names none.
+ * @param {string} line line of a stack
+ * @returns {string | undefined} the file the frame names
+ */
+const frameFile = (line) => {
+	const match = STACK_FRAME_FILE_REGEXP.exec(line);
+	return match === null ? undefined : fileUrlToPath(match[2]);
+};
+
+/**
+ * Returns the stack without the frames this file's own wrapping put on it.
+ * @param {string | undefined} stack stack trace
+ * @returns {string | undefined} stack trace starting at the caller
+ */
+const cutOffWrappingFrames = (stack) => {
+	if (typeof stack !== "string") return stack;
+	const lines = stack.split("\n");
+	const index = lines.findIndex((line) => STACK_FRAME_REGEXP.test(line));
+	if (index === -1) return stack;
+	while (index < lines.length && frameFile(lines[index]) === __filename) {
+		lines.splice(index, 1);
+	}
+	return lines.join("\n");
+};
+
+/**
+ * Returns the value as an error, naming whatever a tap, a loader or a plugin
+ * failed with when that is not one. Everything reading a failure expects one.
+ * @param {EXPECTED_ANY} value value something failed with
+ * @returns {Error} the value, or an error naming it
+ */
+const toError = (value) => {
+	if (value instanceof Error) return value;
+	const error = new (getNonErrorEmittedError())(value);
+	// The wrapping is not the site: the stack starts where the value was caught.
+	// Cut rather than `captureStackTrace`, which elides every frame under bun.
+	error.stack = cutOffWrappingFrames(error.stack);
+	return error;
+};
+
+/**
+ * Returns whether a rebuild of the same project names the same position in the
+ * file. Webpack's own sources move with a release, and the engine's with it.
+ * @param {string} file file a stack frame names
+ * @returns {boolean} whether the position is worth keeping
+ */
+const isReproduciblePosition = (file) =>
+	!file.startsWith(WEBPACK_SOURCE_PATH) && !ENGINE_FILE_REGEXP.test(file);
+
+/**
+ * Returns the message with every stack frame naming its file relative to the
+ * context, and a position only where {@link isReproduciblePosition} allows one.
+ * @param {string} message error message
+ * @param {RequestShortener} requestShortener request shortener
+ * @returns {string} message whose frames a second build writes the same way
+ */
+const contextifyStackFrames = (message, requestShortener) =>
+	message
+		.split("\n")
+		.map((line) => {
+			if (!STACK_FRAME_REGEXP.test(line)) return line;
+			if (GENERATED_FRAME_REGEXP.test(line)) {
+				return line.replace(
+					POSITION_REGEXP,
+					(position, file) =>
+						/** @type {string} */
+						(requestShortener.shorten(fileUrlToPath(file)))
+				);
+			}
+			const match = STACK_FRAME_FILE_REGEXP.exec(line);
+			if (match === null) return line;
+			const [, frame, url, lineNumber, column, end] = match;
+			// An engine may name the file as a URL rather than as a path.
+			const file = fileUrlToPath(url);
+			const position = isReproduciblePosition(file)
+				? `:${lineNumber}:${column}`
+				: "";
+			return `${frame}${requestShortener.shorten(file)}${position}${end}`;
+		})
+		.join("\n");
+
+/**
+ * Returns stack trace without the loader execution flag and message included.
+ * @param {string} stack stack trace
+ * @param {string} message error message
+ * @returns {string} stack trace without the loader execution flag and message included
+ */
+const cleanUp = (stack, message) => {
+	stack = cutOffLoaderExecution(stack);
+	stack = cutOffMessage(stack, message);
+	return stack;
+};
+
+/**
+ * Clean up webpack options.
+ * @param {string} stack stack trace
+ * @param {string} message error message
+ * @returns {string} stack trace without the webpack options flag and message included
+ */
+const cleanUpWebpackOptions = (stack, message) => {
+	stack = cutOffWebpackOptions(stack);
+	stack = cutOffMultilineMessage(stack, message);
+	return stack;
+};
+
+module.exports.cleanUp = cleanUp;
+module.exports.cleanUpWebpackOptions = cleanUpWebpackOptions;
+module.exports.contextifyStackFrames = contextifyStackFrames;
+module.exports.cutOffByFlag = cutOffByFlag;
+module.exports.cutOffLoaderExecution = cutOffLoaderExecution;
+module.exports.cutOffMessage = cutOffMessage;
+module.exports.cutOffMultilineMessage = cutOffMultilineMessage;
+module.exports.cutOffWebpackOptions = cutOffWebpackOptions;
+module.exports.toError = toError;

package/lib/errors/ExternalStarReexportError.js

@@ -7,8 +7,8 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @import ExternalModule from "../ExternalModule" */
-/** @import Module from "../Module" */
+/** @import ExternalModule from "../externals/ExternalModule" */
+/** @import Module from "../module/Module" */
 
 /**
  * Error raised when a `module` library reexports everything from an external

package/lib/{library → errors}/FalseIIFEUmdWarning.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const WebpackError = require("../errors/WebpackError");
+const WebpackError = require("./WebpackError");
 
 class FalseIIFEUmdWarning extends WebpackError {
 	constructor() {

package/lib/errors/HookWebpackError.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const makeSerializable = require("../util/makeSerializable");
+const { toError } = require("./ErrorHelpers");
 const WebpackError = require("./WebpackError");
 
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Error, string]>} ObjectDeserializerContext */
@@ -67,13 +68,13 @@ makeSerializable(HookWebpackError, "webpack/lib/errors/HookWebpackError");
 
 /**
  * Creates webpack error.
- * @param {Error} error an error
+ * @param {EXPECTED_ANY} error what a plugin failed with
  * @param {string} hook name of the hook
  * @returns {WebpackError} a webpack error
  */
 const makeWebpackError = (error, hook) => {
-	if (error instanceof WebpackError) return error;
-	return new HookWebpackError(error, hook);
+	if (WebpackError.isWebpackError(error)) return error;
+	return new HookWebpackError(toError(error), hook);
 };
 
 HookWebpackError.makeWebpackError = makeWebpackError;
@@ -87,7 +88,7 @@ HookWebpackError.makeWebpackError = makeWebpackError;
  */
 const makeWebpackErrorCallback = (callback, hook) => (err, result) => {
 	if (err) {
-		if (err instanceof WebpackError) {
+		if (WebpackError.isWebpackError(err)) {
 			callback(err);
 			return;
 		}
@@ -112,7 +113,7 @@ const tryRunOrWebpackError = (fn, hook) => {
 	try {
 		r = fn();
 	} catch (err) {
-		if (err instanceof WebpackError) {
+		if (WebpackError.isWebpackError(err)) {
 			throw err;
 		}
 		throw new HookWebpackError(/** @type {Error} */ (err), hook);

package/lib/errors/IgnoreErrorModuleFactory.js

@@ -5,15 +5,15 @@
 
 "use strict";
 
-const ModuleFactory = require("../ModuleFactory");
+const ModuleFactory = require("../module/ModuleFactory");
 
 /**
  * @import {
  * 	ModuleFactoryCallback,
  * 	ModuleFactoryCreateData
- * } from "../ModuleFactory"
+ * } from "../module/ModuleFactory"
  */
-/** @import NormalModuleFactory from "../NormalModuleFactory" */
+/** @import NormalModuleFactory from "../module/NormalModuleFactory" */
 
 /**
  * Ignores error when module is unresolved

package/lib/errors/InvalidDependenciesModuleWarning.js

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

package/lib/{optimize → errors}/MinMaxSizeWarning.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const WebpackError = require("../errors/WebpackError");
 const formatSize = require("../util/formatSize");
+const WebpackError = require("./WebpackError");
 
 class MinMaxSizeWarning extends WebpackError {
 	/**

package/lib/errors/ModuleBuildError.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const { cutOffLoaderExecution } = require("../ErrorHelpers");
 const makeSerializable = require("../util/makeSerializable");
+const { cutOffLoaderExecution } = require("./ErrorHelpers");
 const WebpackError = require("./WebpackError");
 
 /** @typedef {Error & { hideStack?: boolean }} ErrorWithHideStack */

package/lib/errors/ModuleDependencyError.js

@@ -9,8 +9,8 @@ const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 const deriveStackFromNestedError = require("./deriveStackFromNestedError");
 
-/** @import { DependencyLocation } from "../Dependency" */
-/** @import Module from "../Module" */
+/** @import { DependencyLocation } from "../graph/Dependency" */
+/** @import Module from "../module/Module" */
 /** @import { ErrorWithHideStack } from "./ModuleBuildError" */
 
 class ModuleDependencyError extends WebpackError {

package/lib/errors/ModuleDependencyWarning.js

@@ -9,8 +9,8 @@ const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 const deriveStackFromNestedError = require("./deriveStackFromNestedError");
 
-/** @import { DependencyLocation } from "../Dependency" */
-/** @import Module from "../Module" */
+/** @import { DependencyLocation } from "../graph/Dependency" */
+/** @import Module from "../module/Module" */
 /** @import { ErrorWithHideStack } from "./ModuleBuildError" */
 
 class ModuleDependencyWarning extends WebpackError {