webpack 5.76.1 → 5.88.2

package/lib/Watching.js

@@ -11,6 +11,8 @@ const Stats = require("./Stats");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./logging/Logger").Logger} Logger */
 
 /**
  * @template T
@@ -58,9 +60,9 @@ class Watching {
 		this._needRecords = true;
 		this.watcher = undefined;
 		this.pausedWatcher = undefined;
-		/** @type {Set<string>} */
+		/** @type {Set<string> | undefined} */
 		this._collectedChangedFiles = undefined;
-		/** @type {Set<string>} */
+		/** @type {Set<string> | undefined} */
 		this._collectedRemovedFiles = undefined;
 		this._done = this._done.bind(this);
 		process.nextTick(() => {
@@ -69,8 +71,8 @@ class Watching {
 	}
 
 	/**
-	 * @param {ReadonlySet<string>} changedFiles changed files
-	 * @param {ReadonlySet<string>} removedFiles removed files
+	 * @param {ReadonlySet<string>=} changedFiles changed files
+	 * @param {ReadonlySet<string>=} removedFiles removed files
 	 */
 	_mergeWithCollected(changedFiles, removedFiles) {
 		if (!changedFiles) return;
@@ -80,11 +82,13 @@ class Watching {
 		} else {
 			for (const file of changedFiles) {
 				this._collectedChangedFiles.add(file);
-				this._collectedRemovedFiles.delete(file);
+				/** @type {Set<string>} */
+				(this._collectedRemovedFiles).delete(file);
 			}
-			for (const file of removedFiles) {
+			for (const file of /** @type {ReadonlySet<string>} */ (removedFiles)) {
 				this._collectedChangedFiles.delete(file);
-				this._collectedRemovedFiles.add(file);
+				/** @type {Set<string>} */
+				(this._collectedRemovedFiles).add(file);
 			}
 		}
 	}
@@ -228,7 +232,7 @@ class Watching {
 	}
 
 	/**
-	 * @param {Error=} err an optional error
+	 * @param {(Error | null)=} err an optional error
 	 * @param {Compilation=} compilation the compilation
 	 * @returns {void}
 	 */
@@ -237,13 +241,18 @@ class Watching {
 
 		const logger = compilation && compilation.getLogger("webpack.Watching");
 
+		/** @type {Stats | null} */
 		let stats = null;
 
+		/**
+		 * @param {Error} err error
+		 * @param {Callback<void>[]=} cbs callbacks
+		 */
 		const handleError = (err, cbs) => {
 			this.compiler.hooks.failed.call(err);
 			this.compiler.cache.beginIdle();
 			this.compiler.idle = true;
-			this.handler(err, stats);
+			this.handler(err, /** @type {Stats} */ (stats));
 			if (!cbs) {
 				cbs = this.callbacks;
 				this.callbacks = [];
@@ -258,11 +267,13 @@ class Watching {
 			!(this._isBlocked() && (this.blocked = true))
 		) {
 			if (compilation) {
-				logger.time("storeBuildDependencies");
+				/** @type {Logger} */
+				(logger).time("storeBuildDependencies");
 				this.compiler.cache.storeBuildDependencies(
 					compilation.buildDependencies,
 					err => {
-						logger.timeEnd("storeBuildDependencies");
+						/** @type {Logger} */
+						(logger).timeEnd("storeBuildDependencies");
 						if (err) return handleError(err);
 						this._go();
 					}
@@ -283,32 +294,42 @@ class Watching {
 
 		const cbs = this.callbacks;
 		this.callbacks = [];
-		logger.time("done hook");
-		this.compiler.hooks.done.callAsync(stats, err => {
-			logger.timeEnd("done hook");
+		/** @type {Logger} */
+		(logger).time("done hook");
+		this.compiler.hooks.done.callAsync(/** @type {Stats} */ (stats), err => {
+			/** @type {Logger} */
+			(logger).timeEnd("done hook");
 			if (err) return handleError(err, cbs);
-			this.handler(null, stats);
-			logger.time("storeBuildDependencies");
+			this.handler(null, /** @type {Stats} */ (stats));
+			/** @type {Logger} */
+			(logger).time("storeBuildDependencies");
 			this.compiler.cache.storeBuildDependencies(
-				compilation.buildDependencies,
+				/** @type {Compilation} */
+				(compilation).buildDependencies,
 				err => {
-					logger.timeEnd("storeBuildDependencies");
+					/** @type {Logger} */
+					(logger).timeEnd("storeBuildDependencies");
 					if (err) return handleError(err, cbs);
-					logger.time("beginIdle");
+					/** @type {Logger} */
+					(logger).time("beginIdle");
 					this.compiler.cache.beginIdle();
 					this.compiler.idle = true;
-					logger.timeEnd("beginIdle");
+					/** @type {Logger} */
+					(logger).timeEnd("beginIdle");
 					process.nextTick(() => {
 						if (!this.closed) {
 							this.watch(
-								compilation.fileDependencies,
-								compilation.contextDependencies,
-								compilation.missingDependencies
+								/** @type {Compilation} */
+								(compilation).fileDependencies,
+								/** @type {Compilation} */
+								(compilation).contextDependencies,
+								/** @type {Compilation} */
+								(compilation).missingDependencies
 							);
 						}
 					});
 					for (const cb of cbs) cb(null);
-					this.compiler.hooks.afterDone.call(stats);
+					this.compiler.hooks.afterDone.call(/** @type {Stats} */ (stats));
 				}
 			);
 		});
@@ -377,6 +398,13 @@ class Watching {
 		this._invalidate();
 	}
 
+	/**
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} fileTimeInfoEntries info for files
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} contextTimeInfoEntries info for directories
+	 * @param {ReadonlySet<string>=} changedFiles changed files
+	 * @param {ReadonlySet<string>=} removedFiles removed files
+	 * @returns {void}
+	 */
 	_invalidate(
 		fileTimeInfoEntries,
 		contextTimeInfoEntries,
@@ -423,6 +451,10 @@ class Watching {
 			}
 			return;
 		}
+		/**
+		 * @param {(WebpackError | null)=} err error if any
+		 * @param {Compilation=} compilation compilation if any
+		 */
 		const finalCallback = (err, compilation) => {
 			this.running = false;
 			this.compiler.running = false;
@@ -433,9 +465,14 @@ class Watching {
 			this.compiler.fileTimestamps = undefined;
 			this.compiler.contextTimestamps = undefined;
 			this.compiler.fsStartTime = undefined;
+			/**
+			 * @param {(WebpackError | null)=} err error if any
+			 */
 			const shutdown = err => {
 				this.compiler.hooks.watchClose.call();
-				const closeCallbacks = this._closeCallbacks;
+				const closeCallbacks =
+					/** @type {Callback<void>[]} */
+					(this._closeCallbacks);
 				this._closeCallbacks = undefined;
 				for (const cb of closeCallbacks) cb(err);
 			};

package/lib/WebpackError.js

@@ -11,6 +11,8 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class WebpackError extends Error {
 	/**
@@ -20,16 +22,17 @@ class WebpackError extends Error {
 	constructor(message) {
 		super(message);
 
+		/** @type {string | undefined} */
 		this.details = undefined;
-		/** @type {Module} */
+		/** @type {Module | undefined | null} */
 		this.module = undefined;
-		/** @type {DependencyLocation} */
+		/** @type {DependencyLocation | undefined} */
 		this.loc = undefined;
-		/** @type {boolean} */
+		/** @type {boolean | undefined} */
 		this.hideStack = undefined;
-		/** @type {Chunk} */
+		/** @type {Chunk | undefined} */
 		this.chunk = undefined;
-		/** @type {string} */
+		/** @type {string | undefined} */
 		this.file = undefined;
 	}
 
@@ -37,6 +40,9 @@ class WebpackError extends Error {
 		return this.stack + (this.details ? `\n${this.details}` : "");
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize({ write }) {
 		write(this.name);
 		write(this.message);
@@ -46,6 +52,9 @@ class WebpackError extends Error {
 		write(this.hideStack);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize({ read }) {
 		this.name = read();
 		this.message = read();

package/lib/WebpackIsIncludedPlugin.js

@@ -6,15 +6,24 @@
 "use strict";
 
 const IgnoreErrorModuleFactory = require("./IgnoreErrorModuleFactory");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("./ModuleTypeConstants");
 const WebpackIsIncludedDependency = require("./dependencies/WebpackIsIncludedDependency");
 const {
 	toConstantDependency
 } = require("./javascript/JavascriptParserHelpers");
 
-/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("enhanced-resolve").Resolver} Resolver */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "WebpackIsIncludedPlugin";
 
 class WebpackIsIncludedPlugin {
 	/**
@@ -23,7 +32,7 @@ class WebpackIsIncludedPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"WebpackIsIncludedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					WebpackIsIncludedDependency,
@@ -41,7 +50,7 @@ class WebpackIsIncludedPlugin {
 				const handler = parser => {
 					parser.hooks.call
 						.for("__webpack_is_included__")
-						.tap("WebpackIsIncludedPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							if (
 								expr.type !== "CallExpression" ||
 								expr.arguments.length !== 1 ||
@@ -54,29 +63,29 @@ class WebpackIsIncludedPlugin {
 							if (!request.isString()) return;
 
 							const dep = new WebpackIsIncludedDependency(
-								request.string,
-								expr.range
+								/** @type {string} */ (request.string),
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addDependency(dep);
 							return true;
 						});
 					parser.hooks.typeof
 						.for("__webpack_is_included__")
 						.tap(
-							"WebpackIsIncludedPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("function"))
 						);
 				};
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("WebpackIsIncludedPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("WebpackIsIncludedPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("WebpackIsIncludedPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}

package/lib/WebpackOptionsApply.js

@@ -119,47 +119,40 @@ class WebpackOptionsApply extends OptionsApply {
 		if (options.externalsPresets.webAsync) {
 			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
-			new ExternalsPlugin(
-				"import",
-				options.experiments.css
-					? ({ request, dependencyType }, callback) => {
-							if (dependencyType === "url") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `asset ${request}`);
-							} else if (dependencyType === "css-import") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `css-import ${request}`);
-							} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
-								if (/^\.css(\?|$)/.test(request))
-									return callback(null, `css-import ${request}`);
-								return callback(null, `import ${request}`);
-							}
-							callback();
-					  }
-					: /^(\/\/|https?:\/\/|std:)/
-			).apply(compiler);
+			new ExternalsPlugin("import", ({ request, dependencyType }, callback) => {
+				if (dependencyType === "url") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `asset ${request}`);
+				} else if (options.experiments.css && dependencyType === "css-import") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `css-import ${request}`);
+				} else if (
+					options.experiments.css &&
+					/^(\/\/|https?:\/\/|std:)/.test(request)
+				) {
+					if (/^\.css(\?|$)/.test(request))
+						return callback(null, `css-import ${request}`);
+					return callback(null, `import ${request}`);
+				}
+				callback();
+			}).apply(compiler);
 		} else if (options.externalsPresets.web) {
 			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
-			new ExternalsPlugin(
-				"module",
-				options.experiments.css
-					? ({ request, dependencyType }, callback) => {
-							if (dependencyType === "url") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `asset ${request}`);
-							} else if (dependencyType === "css-import") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `css-import ${request}`);
-							} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
-								if (/^\.css(\?|$)/.test(request))
-									return callback(null, `css-import ${request}`);
-								return callback(null, `module ${request}`);
-							}
-							callback();
-					  }
-					: /^(\/\/|https?:\/\/|std:)/
-			).apply(compiler);
+			new ExternalsPlugin("module", ({ request, dependencyType }, callback) => {
+				if (dependencyType === "url") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `asset ${request}`);
+				} else if (options.experiments.css && dependencyType === "css-import") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `css-import ${request}`);
+				} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
+					if (options.experiments.css && /^\.css((\?)|$)/.test(request))
+						return callback(null, `css-import ${request}`);
+					return callback(null, `module ${request}`);
+				}
+				callback();
+			}).apply(compiler);
 		} else if (options.externalsPresets.node) {
 			if (options.experiments.css) {
 				//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
@@ -168,10 +161,10 @@ class WebpackOptionsApply extends OptionsApply {
 					"module",
 					({ request, dependencyType }, callback) => {
 						if (dependencyType === "url") {
-							if (/^(\/\/|https?:\/\/)/.test(request))
+							if (/^(\/\/|https?:\/\/|#)/.test(request))
 								return callback(null, `asset ${request}`);
 						} else if (dependencyType === "css-import") {
-							if (/^(\/\/|https?:\/\/)/.test(request))
+							if (/^(\/\/|https?:\/\/|#)/.test(request))
 								return callback(null, `css-import ${request}`);
 						} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
 							if (/^\.css(\?|$)/.test(request))
@@ -375,7 +368,9 @@ class WebpackOptionsApply extends OptionsApply {
 			const NodeStuffPlugin = require("./NodeStuffPlugin");
 			new NodeStuffPlugin(options.node).apply(compiler);
 		}
-		new APIPlugin().apply(compiler);
+		new APIPlugin({
+			module: options.output.module
+		}).apply(compiler);
 		new ExportsInfoApiPlugin().apply(compiler);
 		new WebpackIsIncludedPlugin().apply(compiler);
 		new ConstPlugin().apply(compiler);
@@ -391,7 +386,8 @@ class WebpackOptionsApply extends OptionsApply {
 		new WorkerPlugin(
 			options.output.workerChunkLoading,
 			options.output.workerWasmLoading,
-			options.output.module
+			options.output.module,
+			options.output.workerPublicPath
 		).apply(compiler);
 
 		new DefaultStatsFactoryPlugin().apply(compiler);
@@ -570,7 +566,7 @@ class WebpackOptionsApply extends OptionsApply {
 			for (const minimizer of options.optimization.minimizer) {
 				if (typeof minimizer === "function") {
 					minimizer.call(compiler, compiler);
-				} else if (minimizer !== "...") {
+				} else if (minimizer !== "..." && minimizer) {
 					minimizer.apply(compiler);
 				}
 			}
@@ -663,7 +659,8 @@ class WebpackOptionsApply extends OptionsApply {
 									maxAge: cacheOptions.maxAge,
 									profile: cacheOptions.profile,
 									allowCollectingMemory: cacheOptions.allowCollectingMemory,
-									compression: cacheOptions.compression
+									compression: cacheOptions.compression,
+									readonly: cacheOptions.readonly
 								}),
 								cacheOptions.idleTimeout,
 								cacheOptions.idleTimeoutForInitialStore,

package/lib/WebpackOptionsDefaulter.js

@@ -8,11 +8,18 @@
 const { applyWebpackOptionsDefaults } = require("./config/defaults");
 const { getNormalizedWebpackOptions } = require("./config/normalization");
 
+/** @typedef {import("./config/normalization").WebpackOptions} WebpackOptions */
+/** @typedef {import("./config/normalization").WebpackOptionsNormalized} WebpackOptionsNormalized */
+
 class WebpackOptionsDefaulter {
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @returns {WebpackOptionsNormalized} normalized webpack options
+	 */
 	process(options) {
-		options = getNormalizedWebpackOptions(options);
-		applyWebpackOptionsDefaults(options);
-		return options;
+		const normalizedOptions = getNormalizedWebpackOptions(options);
+		applyWebpackOptionsDefaults(normalizedOptions);
+		return normalizedOptions;
 	}
 }
 

package/lib/asset/AssetGenerator.js

@@ -10,6 +10,7 @@ const path = require("path");
 const { RawSource } = require("webpack-sources");
 const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
+const { ASSET_MODULE_TYPE } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const createHash = require("../util/createHash");
 const { makePathsRelative } = require("../util/identifier");
@@ -106,15 +107,28 @@ const encodeDataUri = (encoding, source) => {
 	return encodedContent;
 };
 
+/**
+ * @param {string} encoding encoding
+ * @param {string} content content
+ * @returns {Buffer} decoded content
+ */
 const decodeDataUriContent = (encoding, content) => {
 	const isBase64 = encoding === "base64";
-	return isBase64
-		? Buffer.from(content, "base64")
-		: Buffer.from(decodeURIComponent(content), "ascii");
+
+	if (isBase64) {
+		return Buffer.from(content, "base64");
+	}
+
+	// If we can't decode return the original body
+	try {
+		return Buffer.from(decodeURIComponent(content), "ascii");
+	} catch (_) {
+		return Buffer.from(content, "ascii");
+	}
 };
 
 const JS_TYPES = new Set(["javascript"]);
-const JS_AND_ASSET_TYPES = new Set(["javascript", "asset"]);
+const JS_AND_ASSET_TYPES = new Set(["javascript", ASSET_MODULE_TYPE]);
 const DEFAULT_ENCODING = "base64";
 
 class AssetGenerator extends Generator {
@@ -167,6 +181,7 @@ class AssetGenerator extends Generator {
 			);
 		}
 
+		/** @type {string | boolean | undefined} */
 		let mimeType = this.dataUrlOptions.mimetype;
 		if (mimeType === undefined) {
 			const ext = path.extname(module.nameForCondition());
@@ -199,7 +214,7 @@ class AssetGenerator extends Generator {
 			);
 		}
 
-		return mimeType;
+		return /** @type {string} */ (mimeType);
 	}
 
 	/**
@@ -220,11 +235,11 @@ class AssetGenerator extends Generator {
 		}
 	) {
 		switch (type) {
-			case "asset":
-				return module.originalSource();
+			case ASSET_MODULE_TYPE:
+				return /** @type {Source} */ (module.originalSource());
 			default: {
 				let content;
-				const originalSource = module.originalSource();
+				const originalSource = /** @type {Source} */ (module.originalSource());
 				if (module.buildInfo.dataUrl) {
 					let encodedSource;
 					if (typeof this.dataUrlOptions === "function") {
@@ -398,7 +413,7 @@ class AssetGenerator extends Generator {
 	 */
 	getSize(module, type) {
 		switch (type) {
-			case "asset": {
+			case ASSET_MODULE_TYPE: {
 				const originalSource = module.originalSource();
 
 				if (!originalSource) {