webpack 5.79.0 → 5.81.0

package/lib/Module.js

@@ -33,6 +33,8 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
 /** @template T @typedef {import("./util/SortableSet")<T>} SortableSet<T> */
@@ -976,6 +978,9 @@ class Module extends DependenciesBlock {
 		buildDependencies
 	) {}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.type);
@@ -1002,6 +1007,9 @@ class Module extends DependenciesBlock {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.type = read();

package/lib/ModuleBuildError.js

@@ -9,6 +9,9 @@ const { cutOffLoaderExecution } = require("./ErrorHelpers");
 const WebpackError = require("./WebpackError");
 const makeSerializable = require("./util/makeSerializable");
 
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class ModuleBuildError extends WebpackError {
 	/**
 	 * @param {string | Error&any} err error thrown
@@ -55,6 +58,9 @@ class ModuleBuildError extends WebpackError {
 		this.error = err;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -63,6 +69,9 @@ class ModuleBuildError extends WebpackError {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/ModuleError.js

@@ -9,6 +9,9 @@ const { cleanUp } = require("./ErrorHelpers");
 const WebpackError = require("./WebpackError");
 const makeSerializable = require("./util/makeSerializable");
 
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class ModuleError extends WebpackError {
 	/**
 	 * @param {Error} err error thrown
@@ -39,6 +42,9 @@ class ModuleError extends WebpackError {
 				: undefined;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -47,6 +53,9 @@ class ModuleError extends WebpackError {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/ModuleFilenameHelpers.js

@@ -14,6 +14,9 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {typeof import("./util/Hash")} Hash */
 
+/** @typedef {string | RegExp | string[] | RegExp[]} Matcher */
+/** @typedef {{test?: Matcher, include?: Matcher, exclude?: Matcher }} MatchObject */
+
 const ModuleFilenameHelpers = exports;
 
 // TODO webpack 6: consider removing these
@@ -43,6 +46,12 @@ ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
 ModuleFilenameHelpers.NAMESPACE = "[namespace]";
 ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi;
 
+/**
+ * Returns a function that returns the part of the string after the token
+ * @param {() => string} strFn the function to get the string
+ * @param {string} token the token to search for
+ * @returns {() => string} a function that returns the part of the string after the token
+ */
 const getAfter = (strFn, token) => {
 	return () => {
 		const str = strFn();
@@ -51,6 +60,12 @@ const getAfter = (strFn, token) => {
 	};
 };
 
+/**
+ * Returns a function that returns the part of the string before the token
+ * @param {() => string} strFn the function to get the string
+ * @param {string} token the token to search for
+ * @returns {() => string} a function that returns the part of the string before the token
+ */
 const getBefore = (strFn, token) => {
 	return () => {
 		const str = strFn();
@@ -59,6 +74,12 @@ const getBefore = (strFn, token) => {
 	};
 };
 
+/**
+ * Returns a function that returns a hash of the string
+ * @param {() => string} strFn the function to get the string
+ * @param {string | Hash} hashFunction the hash function to use
+ * @returns {() => string} a function that returns the hash of the string
+ */
 const getHash = (strFn, hashFunction) => {
 	return () => {
 		const hash = createHash(hashFunction);
@@ -68,13 +89,35 @@ const getHash = (strFn, hashFunction) => {
 	};
 };
 
+/**
+ * Returns a function that returns the string with the token replaced with the replacement
+ * @param {string|RegExp} test A regular expression string or Regular Expression object
+ * @returns	{RegExp} A regular expression object
+ * @example
+ * ```js
+ * const test = asRegExp("test");
+ * test.test("test"); // true
+ *
+ * const test2 = asRegExp(/test/);
+ * test2.test("test"); // true
+ * ```
+ */
 const asRegExp = test => {
 	if (typeof test === "string") {
+		// Escape special characters in the string to prevent them from being interpreted as special characters in a regular expression. Do this by
+		// adding a backslash before each special character
 		test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
 	}
 	return test;
 };
 
+/**
+ * @template T
+ * Returns a lazy object. The object is lazy in the sense that the properties are
+ * only evaluated when they are accessed. This is only obtained by setting a function as the value for each key.
+ * @param {Record<string, () => T>} obj the object to covert to a lazy access object
+ * @returns {Object} the lazy access object
+ */
 const lazyObject = obj => {
 	const newObj = {};
 	for (const key of Object.keys(obj)) {
@@ -95,7 +138,7 @@ const lazyObject = obj => {
 	return newObj;
 };
 
-const REGEXP = /\[\\*([\w-]+)\\*\]/gi;
+const SQUARE_BRACKET_TAG_REGEXP = /\[\\*([\w-]+)\\*\]/gi;
 
 /**
  *
@@ -212,7 +255,7 @@ ModuleFilenameHelpers.createFilename = (
 			ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE,
 			"[short-identifier]"
 		)
-		.replace(REGEXP, (match, content) => {
+		.replace(SQUARE_BRACKET_TAG_REGEXP, (match, content) => {
 			if (content.length + 2 === match.length) {
 				const replacement = replacements.get(content.toLowerCase());
 				if (replacement !== undefined) {
@@ -225,9 +268,28 @@ ModuleFilenameHelpers.createFilename = (
 		});
 };
 
+/**
+ * Replaces duplicate items in an array with new values generated by a callback function.
+ * The callback function is called with the duplicate item, the index of the duplicate item, and the number of times the item has been replaced.
+ * The callback function should return the new value for the duplicate item.
+ *
+ * @template T
+ * @param {T[]} array the array with duplicates to be replaced
+ * @param {(duplicateItem: T, duplicateItemIndex: number, numberOfTimesReplaced: number) => T} fn callback function to generate new values for the duplicate items
+ * @param {(firstElement:T, nextElement:T) => -1 | 0 | 1} [comparator] optional comparator function to sort the duplicate items
+ * @returns {T[]} the array with duplicates replaced
+ *
+ * @example
+ * ```js
+ * const array = ["a", "b", "c", "a", "b", "a"];
+ * const result = ModuleFilenameHelpers.replaceDuplicates(array, (item, index, count) => `${item}-${count}`);
+ * // result: ["a-1", "b-1", "c", "a-2", "b-2", "a-3"]
+ * ```
+ */
 ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
 	const countMap = Object.create(null);
 	const posMap = Object.create(null);
+
 	array.forEach((item, idx) => {
 		countMap[item] = countMap[item] || [];
 		countMap[item].push(idx);
@@ -248,16 +310,63 @@ ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
 	});
 };
 
+/**
+ * Tests if a string matches a RegExp or an array of RegExp.
+ *
+ * @param {string} str string to test
+ * @param {Matcher} test value which will be used to match against the string
+ * @returns {boolean} true, when the RegExp matches
+ *
+ * @example
+ * ```js
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo"); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo.js"); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo."); // false
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo*"); // false
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo.*"); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", /^foo/); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, "bar"]); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, "bar"]); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, /^bar/]); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^baz/, /^bar/]); // false
+ * ```
+ */
 ModuleFilenameHelpers.matchPart = (str, test) => {
 	if (!test) return true;
-	test = asRegExp(test);
+
 	if (Array.isArray(test)) {
 		return test.map(asRegExp).some(regExp => regExp.test(str));
 	} else {
-		return test.test(str);
+		return asRegExp(test).test(str);
 	}
 };
 
+/**
+ * Tests if a string matches a match object. The match object can have the following properties:
+ * - `test`: a RegExp or an array of RegExp
+ * - `include`: a RegExp or an array of RegExp
+ * - `exclude`: a RegExp or an array of RegExp
+ *
+ * The `test` property is tested first, then `include` and then `exclude`.
+ *
+ * @param {MatchObject} obj a match object to test against the string
+ * @param {string} str string to test against the matching object
+ * @returns {boolean} true, when the object matches
+ * @example
+ * ```js
+ * ModuleFilenameHelpers.matchObject({ test: "foo.js" }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ test: /^foo/ }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ test: [/^foo/, "bar"] }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ test: [/^foo/, "bar"] }, "baz.js"); // false
+ * ModuleFilenameHelpers.matchObject({ include: "foo.js" }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ include: "foo.js" }, "bar.js"); // false
+ * ModuleFilenameHelpers.matchObject({ include: /^foo/ }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ include: [/^foo/, "bar"] }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ include: [/^foo/, "bar"] }, "baz.js"); // false
+ * ModuleFilenameHelpers.matchObject({ exclude: "foo.js" }, "foo.js"); // false
+ * ModuleFilenameHelpers.matchObject({ exclude: [/^foo/, "bar"] }, "foo.js"); // false
+ * ```
+ */
 ModuleFilenameHelpers.matchObject = (obj, str) => {
 	if (obj.test) {
 		if (!ModuleFilenameHelpers.matchPart(str, obj.test)) {

package/lib/ModuleParseError.js

@@ -8,6 +8,9 @@
 const WebpackError = require("./WebpackError");
 const makeSerializable = require("./util/makeSerializable");
 
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 const WASM_HEADER = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
 
 class ModuleParseError extends WebpackError {
@@ -87,6 +90,9 @@ class ModuleParseError extends WebpackError {
 		this.error = err;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -95,6 +101,9 @@ class ModuleParseError extends WebpackError {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/ModuleTypeConstants.js

@@ -42,9 +42,30 @@ const WEBASSEMBLY_MODULE_TYPE_ASYNC = "webassembly/async";
  */
 const WEBASSEMBLY_MODULE_TYPE_SYNC = "webassembly/sync";
 
+/**
+ * @type {Readonly<"css">}
+ * This is the module type used for CSS files.
+ */
+const CSS_MODULE_TYPE = "css";
+
+/**
+ * @type {Readonly<"css/global">}
+ * This is the module type used for CSS modules files where you need to use `:local` in selector list to hash classes.
+ */
+const CSS_MODULE_TYPE_GLOBAL = "css/global";
+
+/**
+ * @type {Readonly<"css/module">}
+ * This is the module type used for CSS modules files, by default all classes are hashed.
+ */
+const CSS_MODULE_TYPE_MODULE = "css/module";
+
 exports.JAVASCRIPT_MODULE_TYPE_AUTO = JAVASCRIPT_MODULE_TYPE_AUTO;
 exports.JAVASCRIPT_MODULE_TYPE_DYNAMIC = JAVASCRIPT_MODULE_TYPE_DYNAMIC;
 exports.JAVASCRIPT_MODULE_TYPE_ESM = JAVASCRIPT_MODULE_TYPE_ESM;
 exports.JSON_MODULE_TYPE = JSON_MODULE_TYPE;
 exports.WEBASSEMBLY_MODULE_TYPE_ASYNC = WEBASSEMBLY_MODULE_TYPE_ASYNC;
 exports.WEBASSEMBLY_MODULE_TYPE_SYNC = WEBASSEMBLY_MODULE_TYPE_SYNC;
+exports.CSS_MODULE_TYPE = CSS_MODULE_TYPE;
+exports.CSS_MODULE_TYPE_GLOBAL = CSS_MODULE_TYPE_GLOBAL;
+exports.CSS_MODULE_TYPE_MODULE = CSS_MODULE_TYPE_MODULE;

package/lib/ModuleWarning.js

@@ -9,6 +9,9 @@ const { cleanUp } = require("./ErrorHelpers");
 const WebpackError = require("./WebpackError");
 const makeSerializable = require("./util/makeSerializable");
 
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class ModuleWarning extends WebpackError {
 	/**
 	 * @param {Error} warning error thrown
@@ -39,6 +42,9 @@ class ModuleWarning extends WebpackError {
 				: undefined;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -47,6 +53,9 @@ class ModuleWarning extends WebpackError {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/NormalModule.js

@@ -71,6 +71,8 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./logging/Logger").Logger} WebpackLogger */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
@@ -1365,6 +1367,9 @@ class NormalModule extends Module {
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		// deserialize
@@ -1399,6 +1404,9 @@ class NormalModule extends Module {
 		return obj;
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this._source = read();

package/lib/NormalModuleFactory.js

@@ -233,6 +233,9 @@ class NormalModuleFactory extends ModuleFactory {
 			),
 			generator: new HookMap(
 				() => new SyncHook(["generator", "generatorOptions"])
+			),
+			createModuleClass: new HookMap(
+				() => new SyncBailHook(["createData", "resolveData"])
 			)
 		});
 		this.resolverFactory = resolverFactory;
@@ -308,9 +311,18 @@ class NormalModuleFactory extends ModuleFactory {
 										return callback(new Error("Empty dependency (no request)"));
 									}
 
-									createdModule = new NormalModule(
-										/** @type {NormalModuleCreateData} */ (createData)
-									);
+									// TODO webpack 6 make it required and move javascript/wasm/asset properties to own module
+									createdModule = this.hooks.createModuleClass
+										.for(createData.settings.type)
+										.call(createData, resolveData);
+
+									if (!createdModule) {
+										createdModule = /** @type {Module} */ (
+											new NormalModule(
+												/** @type {NormalModuleCreateData} */ (createData)
+											)
+										);
+									}
 								}
 
 								createdModule = this.hooks.module.call(
@@ -1020,7 +1032,7 @@ If changing the source code is not an option there is also a resolve options cal
 					context,
 					item.loader,
 					resolveContext,
-					(err, result) => {
+					(err, result, resolveRequest) => {
 						if (
 							err &&
 							/^[^/]*$/.test(item.loader) &&
@@ -1047,8 +1059,18 @@ If changing the source code is not an option there is also a resolve options cal
 						if (err) return callback(err);
 
 						const parsedResult = this._parseResourceWithoutFragment(result);
+
+						const type = /\.mjs$/i.test(parsedResult.path)
+							? "module"
+							: /\.cjs$/i.test(parsedResult.path)
+							? "commonjs"
+							: resolveRequest.descriptionFileData === undefined
+							? undefined
+							: resolveRequest.descriptionFileData.type;
+
 						const resolved = {
 							loader: parsedResult.path,
+							type,
 							options:
 								item.options === undefined
 									? parsedResult.query

package/lib/RawModule.js

@@ -23,6 +23,8 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
@@ -125,6 +127,9 @@ class RawModule extends Module {
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -136,6 +141,9 @@ class RawModule extends Module {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/WarnCaseSensitiveModulesPlugin.js

@@ -9,6 +9,7 @@ const CaseSensitiveModulesWarning = require("./CaseSensitiveModulesWarning");
 
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./NormalModule")} NormalModule */
 
 class WarnCaseSensitiveModulesPlugin {
 	/**
@@ -25,6 +26,17 @@ class WarnCaseSensitiveModulesPlugin {
 					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) {

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 {
 	/**
@@ -37,6 +39,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 +51,9 @@ class WebpackError extends Error {
 		write(this.hideStack);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize({ read }) {
 		this.name = read();
 		this.message = read();

package/lib/asset/AssetGenerator.js

@@ -108,9 +108,17 @@ const encodeDataUri = (encoding, source) => {
 
 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"]);

package/lib/asset/RawDataUrlModule.js

@@ -19,6 +19,8 @@ const makeSerializable = require("../util/makeSerializable");
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
@@ -122,6 +124,9 @@ class RawDataUrlModule extends Module {
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -132,6 +137,9 @@ class RawDataUrlModule extends Module {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/cache/ResolverCachePlugin.js

@@ -124,8 +124,11 @@ class ResolverCachePlugin {
 			const newResolveContext = {
 				...resolveContext,
 				stack: new Set(),
+				/** @type {LazySet<string>} */
 				missingDependencies: new LazySet(),
+				/** @type {LazySet<string>} */
 				fileDependencies: new LazySet(),
+				/** @type {LazySet<string>} */
 				contextDependencies: new LazySet()
 			};
 			let yieldResult;

package/lib/config/normalization.js

@@ -327,6 +327,7 @@ const getNormalizedWebpackOptions = config => {
 				hotUpdateChunkFilename: output.hotUpdateChunkFilename,
 				hotUpdateGlobal: output.hotUpdateGlobal,
 				hotUpdateMainFilename: output.hotUpdateMainFilename,
+				ignoreBrowserWarnings: output.ignoreBrowserWarnings,
 				iife: output.iife,
 				importFunctionName: output.importFunctionName,
 				importMetaName: output.importMetaName,

package/lib/container/ContainerEntryModule.js

@@ -26,6 +26,8 @@ const ContainerExposedDependency = require("./ContainerExposedDependency");
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
@@ -260,6 +262,9 @@ class ContainerEntryModule extends Module {
 		return 42;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this._name);

package/lib/container/ContainerExposedDependency.js

@@ -8,6 +8,9 @@
 const ModuleDependency = require("../dependencies/ModuleDependency");
 const makeSerializable = require("../util/makeSerializable");
 
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class ContainerExposedDependency extends ModuleDependency {
 	/**
 	 * @param {string} exposedName public name
@@ -33,11 +36,17 @@ class ContainerExposedDependency extends ModuleDependency {
 		return `exposed dependency ${this.exposedName}=${this.request}`;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		context.write(this.exposedName);
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		this.exposedName = context.read();
 		super.deserialize(context);