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

package/lib/errors/LoaderLoadingError.js

@@ -0,0 +1,20 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class LoaderLoadingError extends WebpackError {
+	/**
+	 * @param {string} message message
+	 */
+	constructor(message) {
+		super(message);
+		this.name = "LoaderRunnerError";
+	}
+}
+
+module.exports = LoaderLoadingError;

package/lib/{ModuleBuildError.js → errors/ModuleBuildError.js}

@@ -5,17 +5,18 @@
 
 "use strict";
 
-const { cutOffLoaderExecution } = require("./ErrorHelpers");
+const { cutOffLoaderExecution } = require("../ErrorHelpers");
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
-
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 /** @typedef {Error & { hideStack?: boolean }} ErrorWithHideStack */
 
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string | ErrorWithHideStack]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string | ErrorWithHideStack]>} ObjectSerializerContext */
+
 class ModuleBuildError extends WebpackError {
 	/**
+	 * Creates an instance of ModuleBuildError.
 	 * @param {string | ErrorWithHideStack} err error thrown
 	 * @param {{ from?: string | null }} info additional info
 	 */
@@ -31,7 +32,14 @@ class ModuleBuildError extends WebpackError {
 				const stack = cutOffLoaderExecution(err.stack);
 
 				if (!err.hideStack) {
-					message += stack;
+					// V8 prefixes `.stack` with "Name: message"; JSC and others emit
+					// frames only, which would drop the message. Lead with it then.
+					message +=
+						typeof err.message === "string" &&
+						err.message &&
+						!stack.includes(err.message)
+							? `${err.name ? `${err.name}: ` : ""}${err.message}`
+							: stack;
 				} else {
 					details = stack;
 
@@ -51,33 +59,31 @@ class ModuleBuildError extends WebpackError {
 
 		/** @type {string} */
 		this.name = "ModuleBuildError";
+		/** @type {string | undefined} */
 		this.details = details;
+		/** @type {string | ErrorWithHideStack} */
 		this.error = err;
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.error);
-
+		context.write(this.error);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.error = read();
-
-		super.deserialize(context);
+		this.error = context.read();
+		super.deserialize(context.rest);
 	}
 }
 
-makeSerializable(ModuleBuildError, "webpack/lib/ModuleBuildError");
+makeSerializable(ModuleBuildError, "webpack/lib/errors/ModuleBuildError");
 
 module.exports = ModuleBuildError;

package/lib/{ModuleDependencyError.js → errors/ModuleDependencyError.js}

@@ -7,8 +7,8 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("./ModuleBuildError").ErrorWithHideStack} ErrorWithHideStack */
 
 class ModuleDependencyError extends WebpackError {
@@ -23,16 +23,23 @@ class ModuleDependencyError extends WebpackError {
 
 		/** @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} */
 		this.loc = loc;
-		/** error is not (de)serialized, so it might be undefined after deserialization */
+		/**
+		 * error is not (de)serialized, so it might be undefined after deserialization
+		 * @type {ErrorWithHideStack}
+		 */
 		this.error = err;
 
 		if (err && err.hideStack && err.stack) {
+			/** @type {string | undefined} */
 			this.stack = /** @type {string} */ `${err.stack
 				.split("\n")
 				.slice(1)

package/lib/{ModuleDependencyWarning.js → errors/ModuleDependencyWarning.js}

@@ -5,15 +5,16 @@
 
 "use strict";
 
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("./ModuleDependencyError").ErrorWithHideStack} ErrorWithHideStack */
 
 class ModuleDependencyWarning extends WebpackError {
 	/**
+	 * Creates an instance of ModuleDependencyWarning.
 	 * @param {Module} module module tied to dependency
 	 * @param {ErrorWithHideStack} err error thrown
 	 * @param {DependencyLocation} loc location of dependency
@@ -23,16 +24,23 @@ class ModuleDependencyWarning extends WebpackError {
 
 		/** @type {string} */
 		this.name = "ModuleDependencyWarning";
+		/** @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} */
 		this.loc = loc;
-		/** error is not (de)serialized, so it might be undefined after deserialization */
+		/**
+		 * error is not (de)serialized, so it might be undefined after deserialization
+		 * @type {ErrorWithHideStack}
+		 */
 		this.error = err;
 
 		if (err && err.hideStack && err.stack) {
+			/** @type {string | undefined} */
 			this.stack = /** @type {string} */ `${err.stack
 				.split("\n")
 				.slice(1)
@@ -43,7 +51,7 @@ class ModuleDependencyWarning extends WebpackError {
 
 makeSerializable(
 	ModuleDependencyWarning,
-	"webpack/lib/ModuleDependencyWarning"
+	"webpack/lib/errors/ModuleDependencyWarning"
 );
 
 module.exports = ModuleDependencyWarning;

package/lib/{ModuleError.js → errors/ModuleError.js}

@@ -5,12 +5,12 @@
 
 "use strict";
 
-const { cleanUp } = require("./ErrorHelpers");
+const { cleanUp } = require("../ErrorHelpers");
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Error]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Error]>} ObjectSerializerContext */
 
 class ModuleError extends WebpackError {
 	/**
@@ -42,28 +42,24 @@ class ModuleError extends WebpackError {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.error);
-
+		context.write(this.error);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.error = read();
-
-		super.deserialize(context);
+		this.error = context.read();
+		super.deserialize(context.rest);
 	}
 }
 
-makeSerializable(ModuleError, "webpack/lib/ModuleError");
+makeSerializable(ModuleError, "webpack/lib/errors/ModuleError");
 
 module.exports = ModuleError;

package/lib/{ModuleHashingError.js → errors/ModuleHashingError.js}

@@ -7,7 +7,7 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("../Module")} Module */
 
 class ModuleHashingError extends WebpackError {
 	/**
@@ -20,9 +20,13 @@ class ModuleHashingError extends WebpackError {
 
 		/** @type {string} */
 		this.name = "ModuleHashingError";
+		/** @type {Error} */
 		this.error = error;
+		/** @type {string} */
 		this.message = error.message;
+		/** @type {string | undefined} */
 		this.details = error.stack;
+		/** @type {Module} */
 		this.module = module;
 	}
 }

package/lib/errors/ModuleNotFoundError.js

@@ -0,0 +1,94 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
+
+const previouslyPolyfilledBuiltinModules = {
+	assert: "assert/",
+	buffer: "buffer/",
+	console: "console-browserify",
+	constants: "constants-browserify",
+	crypto: "crypto-browserify",
+	domain: "domain-browser",
+	events: "events/",
+	http: "stream-http",
+	https: "https-browserify",
+	os: "os-browserify/browser",
+	path: "path-browserify",
+	punycode: "punycode/",
+	process: "process/browser",
+	querystring: "querystring-es3",
+	stream: "stream-browserify",
+	_stream_duplex: "readable-stream/duplex",
+	_stream_passthrough: "readable-stream/passthrough",
+	_stream_readable: "readable-stream/readable",
+	_stream_transform: "readable-stream/transform",
+	_stream_writable: "readable-stream/writable",
+	string_decoder: "string_decoder/",
+	sys: "util/",
+	timers: "timers-browserify",
+	tty: "tty-browserify",
+	url: "url/",
+	util: "util/",
+	vm: "vm-browserify",
+	zlib: "browserify-zlib"
+};
+
+class ModuleNotFoundError extends WebpackError {
+	/**
+	 * Creates an instance of ModuleNotFoundError.
+	 * @param {Module | null} module module tied to dependency
+	 * @param {Error & { details?: string }} err error thrown
+	 * @param {DependencyLocation} loc location of dependency
+	 */
+	constructor(module, err, loc) {
+		let message = `Module not found: ${err.toString()}`;
+
+		// TODO remove in webpack 6
+		const match = err.message.match(/Can't resolve '([^']+)'/);
+		if (match) {
+			const request = match[1];
+			const alias =
+				previouslyPolyfilledBuiltinModules[
+					/** @type {keyof previouslyPolyfilledBuiltinModules} */ (request)
+				];
+			if (alias) {
+				const pathIndex = alias.indexOf("/");
+				const dependency = pathIndex > 0 ? alias.slice(0, pathIndex) : alias;
+				message +=
+					"\n\n" +
+					"BREAKING CHANGE: " +
+					"webpack < 5 used to include polyfills for node.js core modules by default.\n" +
+					"This is no longer the case. Verify if you need this module and configure a polyfill for it.\n\n";
+				message +=
+					"If you want to include a polyfill, you need to:\n" +
+					`\t- add a fallback 'resolve.fallback: { "${request}": require.resolve("${alias}") }'\n` +
+					`\t- install '${dependency}'\n`;
+				message +=
+					"If you don't want to include a polyfill, you can use an empty module like this:\n" +
+					`\tresolve.fallback: { "${request}": false }`;
+			}
+		}
+
+		super(message);
+
+		/** @type {string} */
+		this.name = "ModuleNotFoundError";
+		/** @type {string | undefined} */
+		this.details = err.details;
+		/** @type {Module | null} */
+		this.module = module;
+		this.error = err;
+		/** @type {DependencyLocation} */
+		this.loc = loc;
+	}
+}
+
+module.exports = ModuleNotFoundError;

package/lib/errors/ModuleParseError.js

@@ -0,0 +1,141 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const WebpackError = require("./WebpackError");
+
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Error]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Error]>} ObjectSerializerContext */
+
+const WASM_HEADER = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
+
+class ModuleParseError extends WebpackError {
+	/**
+	 * Creates an instance of ModuleParseError.
+	 * @param {string | Buffer} source source code
+	 * @param {Error & { loc?: SourcePosition }} err the parse error
+	 * @param {string[]} loaders the loaders used
+	 * @param {string} type module type
+	 */
+	constructor(source, err, loaders, type) {
+		let message = `Module parse failed: ${err && err.message}`;
+		/** @type {undefined | DependencyLocation} */
+		let loc;
+
+		if (
+			((Buffer.isBuffer(source) && source.subarray(0, 4).equals(WASM_HEADER)) ||
+				(typeof source === "string" && /^\0asm/.test(source))) &&
+			!type.startsWith("webassembly")
+		) {
+			message +=
+				"\nThe module seem to be a WebAssembly module, but module is not flagged as WebAssembly module for webpack.";
+			message +=
+				"\nBREAKING CHANGE: Since webpack 5 WebAssembly is not enabled by default and flagged as experimental feature.";
+			message +=
+				"\nYou need to enable one of the WebAssembly experiments via 'experiments.asyncWebAssembly: true' (based on async modules) or 'experiments.syncWebAssembly: true' (like webpack 4, deprecated).";
+			message +=
+				"\nFor files that transpile to WebAssembly, make sure to set the module type in the 'module.rules' section of the config (e. g. 'type: \"webassembly/async\"').";
+		} else {
+			message += `\nFile was parsed as module type '${type}'.`;
+			// `loaders` is undefined when the serializer re-runs this constructor
+			// during cache deserialization — keep that branch so it never throws.
+			if (!loaders) {
+				message +=
+					"\nYou may need an appropriate loader to handle this file type. " +
+					"See https://webpack.js.org/concepts/loaders";
+			} else if (loaders.length >= 1) {
+				message += `\nFile was processed with these loaders:${loaders
+					.map((loader) => `\n * ${loader}`)
+					.join("")}`;
+				message +=
+					"\nYou may need an additional loader to handle the result of these loaders.";
+			} else {
+				message +=
+					"\nYou may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders";
+			}
+		}
+
+		if (
+			err &&
+			err.loc &&
+			typeof err.loc === "object" &&
+			typeof err.loc.line === "number"
+		) {
+			const lineNumber = err.loc.line;
+
+			if (
+				Buffer.isBuffer(source) ||
+				// eslint-disable-next-line no-control-regex
+				/[\0\u0001\u0002\u0003\u0004\u0005\u0006\u0007]/.test(source)
+			) {
+				// binary file
+				message += "\n(Source code omitted for this binary file)";
+			} else {
+				const sourceLines = source.split(/\r?\n/);
+				if (lineNumber >= 1 && lineNumber <= sourceLines.length) {
+					// babel-like code frame: numbered gutter, `>` on the error line
+					// and a `^` caret at the error column
+					const column =
+						typeof err.loc.column === "number" ? err.loc.column : undefined;
+					const start = Math.max(1, lineNumber - 1);
+					const end = Math.min(sourceLines.length, lineNumber + 1);
+					const width = `${end}`.length;
+					for (let n = start; n <= end; n++) {
+						const line = sourceLines[n - 1];
+						const gutter = `${n}`.padStart(width);
+						message +=
+							n === lineNumber
+								? `\n> ${gutter} | ${line}`
+								: `\n  ${gutter} | ${line}`;
+						if (n === lineNumber && column !== undefined) {
+							// keep tabs so the caret stays aligned under tab-indented code
+							const align = line.slice(0, column).replace(/[^\t]/g, " ");
+							message += `\n  ${" ".repeat(width)} | ${align}^`;
+						}
+					}
+				}
+			}
+
+			loc = { start: err.loc };
+		} else if (err && err.stack) {
+			message += `\n${err.stack}`;
+		}
+
+		super(message);
+
+		/** @type {string} */
+		this.name = "ModuleParseError";
+		/** @type {undefined | DependencyLocation} */
+		this.loc = loc;
+		/** @type {Error} */
+		this.error = err;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.error);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.error = context.read();
+		super.deserialize(context.rest);
+	}
+}
+
+makeSerializable(ModuleParseError, "webpack/lib/errors/ModuleParseError");
+
+module.exports = ModuleParseError;

package/lib/{ModuleRestoreError.js → errors/ModuleRestoreError.js}

@@ -7,10 +7,11 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("../Module")} Module */
 
 class ModuleRestoreError extends WebpackError {
 	/**
+	 * Creates an instance of ModuleRestoreError.
 	 * @param {Module} module module tied to dependency
 	 * @param {string | Error} err error thrown
 	 */
@@ -37,7 +38,9 @@ class ModuleRestoreError extends WebpackError {
 		this.name = "ModuleRestoreError";
 		/** @type {string | undefined} */
 		this.details = details;
+		/** @type {Module} */
 		this.module = module;
+		/** @type {string | Error} */
 		this.error = err;
 	}
 }

package/lib/{ModuleStoreError.js → errors/ModuleStoreError.js}

@@ -7,10 +7,11 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("../Module")} Module */
 
 class ModuleStoreError extends WebpackError {
 	/**
+	 * Creates an instance of ModuleStoreError.
 	 * @param {Module} module module tied to dependency
 	 * @param {string | Error} err error thrown
 	 */
@@ -35,8 +36,11 @@ class ModuleStoreError extends WebpackError {
 
 		/** @type {string} */
 		this.name = "ModuleStoreError";
+		/** @type {string | undefined} */
 		this.details = /** @type {string | undefined} */ (details);
+		/** @type {Module} */
 		this.module = module;
+		/** @type {string | Error} */
 		this.error = err;
 	}
 }

package/lib/{ModuleWarning.js → errors/ModuleWarning.js}

@@ -5,15 +5,16 @@
 
 "use strict";
 
-const { cleanUp } = require("./ErrorHelpers");
+const { cleanUp } = require("../ErrorHelpers");
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Error]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Error]>} ObjectSerializerContext */
 
 class ModuleWarning extends WebpackError {
 	/**
+	 * Creates an instance of ModuleWarning.
 	 * @param {Error} warning error thrown
 	 * @param {{ from?: string | null }} info additional info
 	 */
@@ -32,7 +33,9 @@ class ModuleWarning extends WebpackError {
 
 		/** @type {string} */
 		this.name = "ModuleWarning";
+		/** @type {Error} */
 		this.warning = warning;
+		/** @type {string | undefined} */
 		this.details =
 			warning && typeof warning === "object" && warning.stack
 				? cleanUp(warning.stack, this.message)
@@ -40,29 +43,25 @@ class ModuleWarning extends WebpackError {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.warning);
-
+		context.write(this.warning);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.warning = read();
-
-		super.deserialize(context);
+		this.warning = context.read();
+		super.deserialize(context.rest);
 	}
 }
 
-makeSerializable(ModuleWarning, "webpack/lib/ModuleWarning");
+makeSerializable(ModuleWarning, "webpack/lib/errors/ModuleWarning");
 
 /** @type {typeof ModuleWarning} */
 module.exports = ModuleWarning;

package/lib/{NodeStuffInWebError.js → errors/NodeStuffInWebError.js}

@@ -1,17 +1,18 @@
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 "use strict";
 
-const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+const makeSerializable = require("../util/makeSerializable");
+const WebpackError = require("./WebpackError");
 
 class NodeStuffInWebError extends WebpackError {
 	/**
+	 * Creates an instance of NodeStuffInWebError.
 	 * @param {DependencyLocation} loc loc
 	 * @param {string} expression expression
 	 * @param {string} description description
@@ -26,10 +27,11 @@ ${description}`
 
 		/** @type {string} */
 		this.name = "NodeStuffInWebError";
+		/** @type {DependencyLocation} */
 		this.loc = loc;
 	}
 }
 
-makeSerializable(NodeStuffInWebError, "webpack/lib/NodeStuffInWebError");
+makeSerializable(NodeStuffInWebError, "webpack/lib/errors/NodeStuffInWebError");
 
 module.exports = NodeStuffInWebError;