webpack 5.97.1 → 5.104.1

package/lib/NormalModuleReplacementPlugin.js

@@ -5,18 +5,21 @@
 
 "use strict";
 
-const { join, dirname } = require("./util/fs");
+const { dirname, join } = require("./util/fs");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-/** @typedef {function(import("./NormalModuleFactory").ResolveData): void} ModuleReplacer */
+/** @typedef {(resolveData: ResolveData) => void} ModuleReplacer */
+
+const PLUGIN_NAME = "NormalModuleReplacementPlugin";
 
 class NormalModuleReplacementPlugin {
 	/**
 	 * Create an instance of the plugin
 	 * @param {RegExp} resourceRegExp the resource matcher
-	 * @param {string|ModuleReplacer} newResource the resource replacement
+	 * @param {string | ModuleReplacer} newResource the resource replacement
 	 */
 	constructor(resourceRegExp, newResource) {
 		this.resourceRegExp = resourceRegExp;
@@ -31,46 +34,41 @@ class NormalModuleReplacementPlugin {
 	apply(compiler) {
 		const resourceRegExp = this.resourceRegExp;
 		const newResource = this.newResource;
-		compiler.hooks.normalModuleFactory.tap(
-			"NormalModuleReplacementPlugin",
-			nmf => {
-				nmf.hooks.beforeResolve.tap("NormalModuleReplacementPlugin", result => {
-					if (resourceRegExp.test(result.request)) {
-						if (typeof newResource === "function") {
-							newResource(result);
-						} else {
-							result.request = newResource;
-						}
+		compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (nmf) => {
+			nmf.hooks.beforeResolve.tap(PLUGIN_NAME, (result) => {
+				if (resourceRegExp.test(result.request)) {
+					if (typeof newResource === "function") {
+						newResource(result);
+					} else {
+						result.request = newResource;
 					}
-				});
-				nmf.hooks.afterResolve.tap("NormalModuleReplacementPlugin", result => {
-					const createData = result.createData;
-					if (
-						resourceRegExp.test(/** @type {string} */ (createData.resource))
-					) {
-						if (typeof newResource === "function") {
-							newResource(result);
+				}
+			});
+			nmf.hooks.afterResolve.tap(PLUGIN_NAME, (result) => {
+				const createData = result.createData;
+				if (resourceRegExp.test(/** @type {string} */ (createData.resource))) {
+					if (typeof newResource === "function") {
+						newResource(result);
+					} else {
+						const fs =
+							/** @type {InputFileSystem} */
+							(compiler.inputFileSystem);
+						if (
+							newResource.startsWith("/") ||
+							(newResource.length > 1 && newResource[1] === ":")
+						) {
+							createData.resource = newResource;
 						} else {
-							const fs =
-								/** @type {InputFileSystem} */
-								(compiler.inputFileSystem);
-							if (
-								newResource.startsWith("/") ||
-								(newResource.length > 1 && newResource[1] === ":")
-							) {
-								createData.resource = newResource;
-							} else {
-								createData.resource = join(
-									fs,
-									dirname(fs, /** @type {string} */ (createData.resource)),
-									newResource
-								);
-							}
+							createData.resource = join(
+								fs,
+								dirname(fs, /** @type {string} */ (createData.resource)),
+								newResource
+							);
 						}
 					}
-				});
-			}
-		);
+				}
+			});
+		});
 	}
 }
 

package/lib/NullFactory.js

@@ -7,17 +7,18 @@
 
 const ModuleFactory = require("./ModuleFactory");
 
+/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 
 class NullFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {
 		return callback();
 	}
 }
+
 module.exports = NullFactory;

package/lib/OptimizationStages.js

@@ -5,6 +5,6 @@
 
 "use strict";
 
+module.exports.STAGE_ADVANCED = 10;
 module.exports.STAGE_BASIC = -10;
 module.exports.STAGE_DEFAULT = 0;
-module.exports.STAGE_ADVANCED = 10;

package/lib/OptionsApply.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Compiler")} Compiler */
 
 class OptionsApply {

package/lib/Parser.js

@@ -5,10 +5,11 @@
 
 "use strict";
 
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./NormalModule")} NormalModule */
 
-/** @typedef {Record<string, any>} PreparsedAst */
+/** @typedef {Record<string, EXPECTED_ANY>} PreparsedAst */
 
 /**
  * @typedef {object} ParserStateBase
@@ -16,10 +17,10 @@
  * @property {NormalModule} current
  * @property {NormalModule} module
  * @property {Compilation} compilation
- * @property {{[k: string]: any}} options
+ * @property {WebpackOptions} options
  */
 
-/** @typedef {Record<string, any> & ParserStateBase} ParserState */
+/** @typedef {ParserStateBase & Record<string, EXPECTED_ANY>} ParserState */
 
 class Parser {
 	/* istanbul ignore next */
@@ -31,6 +32,7 @@ class Parser {
 	 */
 	parse(source, state) {
 		const AbstractMethodError = require("./AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 }

package/lib/PlatformPlugin.js

@@ -8,6 +8,8 @@
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./config/target").PlatformTargetProperties} PlatformTargetProperties */
 
+const PLUGIN_NAME = "PlatformPlugin";
+
 /**
  * Should be used only for "target === false" or
  * when you want to overwrite platform target properties
@@ -27,7 +29,7 @@ class PlatformPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.environment.tap("PlatformPlugin", () => {
+		compiler.hooks.environment.tap(PLUGIN_NAME, () => {
 			compiler.platform = {
 				...compiler.platform,
 				...this.platform

package/lib/PrefetchPlugin.js

@@ -9,10 +9,12 @@ const PrefetchDependency = require("./dependencies/PrefetchDependency");
 
 /** @typedef {import("./Compiler")} Compiler */
 
+const PLUGIN_NAME = "PrefetchPlugin";
+
 class PrefetchPlugin {
 	/**
 	 * @param {string} context context or request if context is not set
-	 * @param {string} [request] request
+	 * @param {string=} request request
 	 */
 	constructor(context, request) {
 		if (request) {
@@ -31,7 +33,7 @@ class PrefetchPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"PrefetchPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					PrefetchDependency,
@@ -39,11 +41,11 @@ class PrefetchPlugin {
 				);
 			}
 		);
-		compiler.hooks.make.tapAsync("PrefetchPlugin", (compilation, callback) => {
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
 			compilation.addModuleChain(
 				this.context || compiler.context,
 				new PrefetchDependency(this.request),
-				err => {
+				(err) => {
 					callback(err);
 				}
 			);

package/lib/ProgressPlugin.js

@@ -12,9 +12,11 @@ const createSchemaValidation = require("./util/create-schema-validation");
 const { contextify } = require("./util/identifier");
 
 /** @typedef {import("tapable").Tap} Tap */
-/** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */
+/**
+ * @template T, R, AdditionalOptions
+ * @typedef {import("tapable").Hook<T, R, AdditionalOptions>} Hook
+ */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
-/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
 /** @typedef {import("./Compilation").FactorizeModuleOptions} FactorizeModuleOptions */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
@@ -34,7 +36,7 @@ const { contextify } = require("./util/identifier");
  */
 
 const validate = createSchemaValidation(
-	require("../schemas/plugins/ProgressPlugin.check.js"),
+	require("../schemas/plugins/ProgressPlugin.check"),
 	() => require("../schemas/plugins/ProgressPlugin.json"),
 	{
 		name: "Progress Plugin",
@@ -50,27 +52,25 @@ const validate = createSchemaValidation(
  */
 const median3 = (a, b, c) => a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
 
+/** @typedef {(percentage: number, msg: string, ...args: string[]) => void} HandlerFn */
+
 /**
  * @param {boolean | null | undefined} profile need profile
  * @param {Logger} logger logger
- * @returns {defaultHandler} default handler
+ * @returns {HandlerFn} default handler
  */
 const createDefaultHandler = (profile, logger) => {
 	/** @type {{ value: string | undefined, time: number }[]} */
 	const lastStateInfo = [];
 
-	/**
-	 * @param {number} percentage percentage
-	 * @param {string} msg message
-	 * @param {...string} args additional arguments
-	 */
+	/** @type {HandlerFn} */
 	const defaultHandler = (percentage, msg, ...args) => {
 		if (profile) {
 			if (percentage === 0) {
 				lastStateInfo.length = 0;
 			}
 			const fullState = [msg, ...args];
-			const state = fullState.map(s => s.replace(/\d+\/\d+ /g, ""));
+			const state = fullState.map((s) => s.replace(/\d+\/\d+ /g, ""));
 			const now = Date.now();
 			const len = Math.max(state.length, lastStateInfo.length);
 			for (let i = len; i >= 0; i--) {
@@ -140,6 +140,8 @@ const SKIPPED_QUEUE_CONTEXTS = ["import-module", "load-module"];
 /** @type {WeakMap<Compiler, ReportProgress | undefined>} */
 const progressReporters = new WeakMap();
 
+const PLUGIN_NAME = "ProgressPlugin";
+
 class ProgressPlugin {
 	/**
 	 * @param {Compiler} compiler the current compiler
@@ -193,7 +195,7 @@ class ProgressPlugin {
 
 	/**
 	 * @param {MultiCompiler} compiler webpack multi-compiler
-	 * @param {HandlerFunction} handler function that executes for every progress step
+	 * @param {HandlerFn} handler function that executes for every progress step
 	 * @returns {void}
 	 */
 	_applyOnMultiCompiler(compiler, handler) {
@@ -212,7 +214,7 @@ class ProgressPlugin {
 
 	/**
 	 * @param {Compiler} compiler webpack compiler
-	 * @param {HandlerFunction} handler function that executes for every progress step
+	 * @param {HandlerFn} handler function that executes for every progress step
 	 * @returns {void}
 	 */
 	_applyOnCompiler(compiler, handler) {
@@ -319,14 +321,16 @@ class ProgressPlugin {
 				skippedDependenciesCount++;
 			}
 			dependenciesCount++;
-			if (dependenciesCount < 50 || dependenciesCount % 100 === 0)
+			if (dependenciesCount < 50 || dependenciesCount % 100 === 0) {
 				updateThrottled();
+			}
 		};
 
 		const factorizeDone = () => {
 			doneDependencies++;
-			if (doneDependencies < 50 || doneDependencies % 100 === 0)
+			if (doneDependencies < 50 || doneDependencies % 100 === 0) {
 				updateThrottled();
+			}
 		};
 
 		/**
@@ -346,7 +350,7 @@ class ProgressPlugin {
 		/**
 		 * @param {Module} module the module
 		 */
-		const moduleBuild = module => {
+		const moduleBuild = (module) => {
 			const ident = module.identifier();
 			if (ident) {
 				activeModules.add(ident);
@@ -367,7 +371,7 @@ class ProgressPlugin {
 		/**
 		 * @param {Module} module the module
 		 */
-		const moduleDone = module => {
+		const moduleDone = (module) => {
 			doneModules++;
 			if (showActiveModules) {
 				const ident = module.identifier();
@@ -395,17 +399,15 @@ class ProgressPlugin {
 			update();
 		};
 
-		const cache = compiler
-			.getCache("ProgressPlugin")
-			.getItemCache("counts", null);
+		const cache = compiler.getCache(PLUGIN_NAME).getItemCache("counts", null);
 
 		/** @type {Promise<CountsData> | undefined} */
 		let cacheGetPromise;
 
-		compiler.hooks.beforeCompile.tap("ProgressPlugin", () => {
+		compiler.hooks.beforeCompile.tap(PLUGIN_NAME, () => {
 			if (!cacheGetPromise) {
 				cacheGetPromise = cache.getPromise().then(
-					data => {
+					(data) => {
 						if (data) {
 							lastModulesCount = lastModulesCount || data.modulesCount;
 							lastDependenciesCount =
@@ -413,17 +415,17 @@ class ProgressPlugin {
 						}
 						return data;
 					},
-					err => {
+					(_err) => {
 						// Ignore error
 					}
 				);
 			}
 		});
 
-		compiler.hooks.afterCompile.tapPromise("ProgressPlugin", compilation => {
+		compiler.hooks.afterCompile.tapPromise(PLUGIN_NAME, (compilation) => {
 			if (compilation.compiler.isChild()) return Promise.resolve();
 			return /** @type {Promise<CountsData>} */ (cacheGetPromise).then(
-				async oldData => {
+				async (oldData) => {
 					const realModulesCount = modulesCount - skippedModulesCount;
 					const realDependenciesCount =
 						dependenciesCount - skippedDependenciesCount;
@@ -442,7 +444,7 @@ class ProgressPlugin {
 			);
 		});
 
-		compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			if (compilation.compiler.isChild()) return;
 			lastModulesCount = modulesCount;
 			lastEntriesCount = entriesCount;
@@ -455,37 +457,33 @@ class ProgressPlugin {
 					0;
 			doneModules = doneDependencies = doneEntries = 0;
 
-			compilation.factorizeQueue.hooks.added.tap("ProgressPlugin", item =>
+			compilation.factorizeQueue.hooks.added.tap(PLUGIN_NAME, (item) =>
 				factorizeAdd(compilation.factorizeQueue, item)
 			);
-			compilation.factorizeQueue.hooks.result.tap(
-				"ProgressPlugin",
-				factorizeDone
-			);
+			compilation.factorizeQueue.hooks.result.tap(PLUGIN_NAME, factorizeDone);
 
-			compilation.addModuleQueue.hooks.added.tap("ProgressPlugin", item =>
+			compilation.addModuleQueue.hooks.added.tap(PLUGIN_NAME, (item) =>
 				moduleAdd(compilation.addModuleQueue, item)
 			);
 			compilation.processDependenciesQueue.hooks.result.tap(
-				"ProgressPlugin",
+				PLUGIN_NAME,
 				moduleDone
 			);
 
 			if (showActiveModules) {
-				compilation.hooks.buildModule.tap("ProgressPlugin", moduleBuild);
+				compilation.hooks.buildModule.tap(PLUGIN_NAME, moduleBuild);
 			}
 
-			compilation.hooks.addEntry.tap("ProgressPlugin", entryAdd);
-			compilation.hooks.failedEntry.tap("ProgressPlugin", entryDone);
-			compilation.hooks.succeedEntry.tap("ProgressPlugin", entryDone);
+			compilation.hooks.addEntry.tap(PLUGIN_NAME, entryAdd);
+			compilation.hooks.failedEntry.tap(PLUGIN_NAME, entryDone);
+			compilation.hooks.succeedEntry.tap(PLUGIN_NAME, entryDone);
 
-			// avoid dynamic require if bundled with webpack
-			// @ts-expect-error
+			// @ts-expect-error avoid dynamic require if bundled with webpack
 			if (typeof __webpack_require__ !== "function") {
 				const requiredLoaders = new Set();
 				NormalModule.getCompilationHooks(compilation).beforeLoaders.tap(
-					"ProgressPlugin",
-					loaders => {
+					PLUGIN_NAME,
+					(loaders) => {
 						for (const loader of loaders) {
 							if (
 								loader.type !== "module" &&
@@ -551,7 +549,7 @@ class ProgressPlugin {
 				const title = hooks[/** @type {keyof typeof hooks} */ (name)];
 				const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
 				compilation.hooks[/** @type {keyof typeof hooks} */ (name)].intercept({
-					name: "ProgressPlugin",
+					name: PLUGIN_NAME,
 					call() {
 						handler(percentage, "sealing", title);
 					},
@@ -577,7 +575,7 @@ class ProgressPlugin {
 			}
 		});
 		compiler.hooks.make.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			call() {
 				handler(0.1, "building");
 			},
@@ -586,14 +584,15 @@ class ProgressPlugin {
 			}
 		});
 		/**
-		 * @param {TODO} hook hook
+		 * @template {Hook<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>} T
+		 * @param {T} hook hook
 		 * @param {number} progress progress from 0 to 1
 		 * @param {string} category category
 		 * @param {string} name name
 		 */
 		const interceptHook = (hook, progress, category, name) => {
 			hook.intercept({
-				name: "ProgressPlugin",
+				name: PLUGIN_NAME,
 				call() {
 					handler(progress, category, name);
 				},
@@ -619,14 +618,14 @@ class ProgressPlugin {
 			});
 		};
 		compiler.cache.hooks.endIdle.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			call() {
 				handler(0, "");
 			}
 		});
 		interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle");
 		compiler.hooks.beforeRun.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			call() {
 				handler(0, "");
 			}
@@ -660,7 +659,7 @@ class ProgressPlugin {
 		interceptHook(compiler.hooks.afterEmit, 0.98, "emitting", "after emit");
 		interceptHook(compiler.hooks.done, 0.99, "done", "plugins");
 		compiler.hooks.done.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			done() {
 				handler(0.99, "");
 			}
@@ -680,13 +679,13 @@ class ProgressPlugin {
 			"closing watch compilation"
 		);
 		compiler.cache.hooks.beginIdle.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			done() {
 				handler(1, "");
 			}
 		});
 		compiler.cache.hooks.shutdown.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			done() {
 				handler(1, "");
 			}

package/lib/ProvidePlugin.js

@@ -59,9 +59,11 @@ class ProvidePlugin {
 				 */
 				const handler = (parser, parserOptions) => {
 					for (const name of Object.keys(definitions)) {
-						const request =
-							/** @type {string[]} */
-							([]).concat(definitions[name]);
+						const request = [
+							...(Array.isArray(definitions[name])
+								? definitions[name]
+								: [definitions[name]])
+						];
 						const splittedName = name.split(".");
 						if (splittedName.length > 0) {
 							for (const [i, _] of splittedName.slice(1).entries()) {
@@ -70,7 +72,7 @@ class ProvidePlugin {
 							}
 						}
 
-						parser.hooks.expression.for(name).tap(PLUGIN_NAME, expr => {
+						parser.hooks.expression.for(name).tap(PLUGIN_NAME, (expr) => {
 							const nameIdentifier = name.includes(".")
 								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
 								: name;
@@ -85,7 +87,7 @@ class ProvidePlugin {
 							return true;
 						});
 
-						parser.hooks.call.for(name).tap(PLUGIN_NAME, expr => {
+						parser.hooks.call.for(name).tap(PLUGIN_NAME, (expr) => {
 							const nameIdentifier = name.includes(".")
 								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
 								: name;

package/lib/RawModule.js

@@ -7,25 +7,27 @@
 
 const { OriginalSource, RawSource } = require("webpack-sources");
 const Module = require("./Module");
-const { JS_TYPES } = require("./ModuleSourceTypesConstants");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("./ModuleSourceTypeConstants");
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
+/** @typedef {import("./Module").BuildCallback} BuildCallback */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @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 */
@@ -50,7 +52,7 @@ class RawModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	/**
@@ -80,7 +82,7 @@ class RawModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -92,7 +94,7 @@ class RawModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -103,6 +105,18 @@ class RawModule extends Module {
 		callback();
 	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
+	 */
+	getSideEffectsConnectionState(moduleGraph) {
+		if (this.factoryMeta !== undefined) {
+			if (this.factoryMeta.sideEffectFree) return false;
+			if (this.factoryMeta.sideEffectFree === false) return true;
+		}
+		return true;
+	}
+
 	/**
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
@@ -111,11 +125,11 @@ class RawModule extends Module {
 		const sources = new Map();
 		if (this.useSourceMap || this.useSimpleSourceMap) {
 			sources.set(
-				"javascript",
+				JAVASCRIPT_TYPE,
 				new OriginalSource(this.sourceStr, this.identifier())
 			);
 		} else {
-			sources.set("javascript", new RawSource(this.sourceStr));
+			sources.set(JAVASCRIPT_TYPE, new RawSource(this.sourceStr));
 		}
 		return { sources, runtimeRequirements: this.runtimeRequirements };
 	}