webpack 5.95.0 → 5.96.1

package/lib/NormalModuleFactory.js

@@ -52,8 +52,8 @@ const {
 /** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-/** @typedef {Pick<RuleSetRule, 'type'|'sideEffects'|'parser'|'generator'|'resolve'|'layer'>} ModuleSettings */
-/** @typedef {Partial<NormalModuleCreateData & {settings: ModuleSettings}>} CreateData */
+/** @typedef {Pick<RuleSetRule, 'type' | 'sideEffects' | 'parser' | 'generator' | 'resolve' | 'layer'>} ModuleSettings */
+/** @typedef {Partial<NormalModuleCreateData & { settings: ModuleSettings }>} CreateData */
 
 /**
  * @typedef {object} ResolveData
@@ -68,6 +68,7 @@ const {
  * @property {LazySet<string>} fileDependencies
  * @property {LazySet<string>} missingDependencies
  * @property {LazySet<string>} contextDependencies
+ * @property {Module=} ignoredModule
  * @property {boolean} cacheable allow to use the unsafe cache
  */
 
@@ -169,7 +170,9 @@ const mergeGlobalOptions = (globalOptions, type, localOptions) => {
 	let current = "";
 	for (const part of parts) {
 		current = current ? `${current}/${part}` : part;
-		const options = globalOptions[current];
+		const options =
+			/** @type {T} */
+			(globalOptions[/** @type {keyof T} */ (current)]);
 		if (typeof options === "object") {
 			result =
 				result === undefined ? options : cachedCleverMerge(result, options);
@@ -219,16 +222,19 @@ const ruleSetCompiler = new RuleSetCompiler([
 	new BasicMatcherRulePlugin("issuer"),
 	new BasicMatcherRulePlugin("compiler"),
 	new BasicMatcherRulePlugin("issuerLayer"),
-	new ObjectMatcherRulePlugin(
-		"assert",
-		"assertions",
-		value => value && /** @type {any} */ (value)._isLegacyAssert !== undefined
-	),
-	new ObjectMatcherRulePlugin(
-		"with",
-		"assertions",
-		value => value && !(/** @type {any} */ (value)._isLegacyAssert)
-	),
+	new ObjectMatcherRulePlugin("assert", "assertions", value => {
+		if (value) {
+			return /** @type {any} */ (value)._isLegacyAssert !== undefined;
+		}
+
+		return false;
+	}),
+	new ObjectMatcherRulePlugin("with", "assertions", value => {
+		if (value) {
+			return !(/** @type {any} */ (value)._isLegacyAssert);
+		}
+		return false;
+	}),
 	new ObjectMatcherRulePlugin("descriptionData"),
 	new BasicEffectRulePlugin("type"),
 	new BasicEffectRulePlugin("sideEffects"),
@@ -246,7 +252,7 @@ class NormalModuleFactory extends ModuleFactory {
 	 * @param {InputFileSystem} param.fs file system
 	 * @param {ResolverFactory} param.resolverFactory resolverFactory
 	 * @param {ModuleOptions} param.options options
-	 * @param {object=} param.associatedObjectForCache an object to which the cache will be attached
+	 * @param {object} param.associatedObjectForCache an object to which the cache will be attached
 	 * @param {boolean=} param.layers enable layers
 	 */
 	constructor({
@@ -277,13 +283,13 @@ class NormalModuleFactory extends ModuleFactory {
 			afterResolve: new AsyncSeriesBailHook(["resolveData"]),
 			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
 			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
-			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */
+			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData]>} */
 			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
-			/** @type {HookMap<SyncBailHook<[ParserOptions], Parser>>} */
+			/** @type {HookMap<SyncBailHook<[ParserOptions], Parser | void>>} */
 			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
 			/** @type {HookMap<SyncBailHook<[TODO, ParserOptions], void>>} */
 			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
-			/** @type {HookMap<SyncBailHook<[GeneratorOptions], Generator>>} */
+			/** @type {HookMap<SyncBailHook<[GeneratorOptions], Generator | void>>} */
 			createGenerator: new HookMap(
 				() => new SyncBailHook(["generatorOptions"])
 			),
@@ -291,7 +297,7 @@ class NormalModuleFactory extends ModuleFactory {
 			generator: new HookMap(
 				() => new SyncHook(["generator", "generatorOptions"])
 			),
-			/** @type {HookMap<SyncBailHook<[TODO, ResolveData], Module>>} */
+			/** @type {HookMap<SyncBailHook<[TODO, ResolveData], Module | void>>} */
 			createModuleClass: new HookMap(
 				() => new SyncBailHook(["createData", "resolveData"])
 			)
@@ -374,14 +380,16 @@ class NormalModuleFactory extends ModuleFactory {
 									// TODO webpack 6 make it required and move javascript/wasm/asset properties to own module
 									createdModule = this.hooks.createModuleClass
 										.for(
-											/** @type {ModuleSettings} */ (createData.settings).type
+											/** @type {ModuleSettings} */
+											(createData.settings).type
 										)
 										.call(createData, resolveData);
 
 									if (!createdModule) {
 										createdModule = /** @type {Module} */ (
 											new NormalModule(
-												/** @type {NormalModuleCreateData} */ (createData)
+												/** @type {NormalModuleCreateData} */
+												(createData)
 											)
 										);
 									}
@@ -887,12 +895,19 @@ class NormalModuleFactory extends ModuleFactory {
 
 			// Ignored
 			if (result === false) {
-				return callback(null, {
+				/** @type {ModuleFactoryResult} * */
+				const factoryResult = {
 					fileDependencies,
 					missingDependencies,
 					contextDependencies,
 					cacheable: resolveData.cacheable
-				});
+				};
+
+				if (resolveData.ignoredModule) {
+					factoryResult.module = resolveData.ignoredModule;
+				}
+
+				return callback(null, factoryResult);
 			}
 
 			if (typeof result === "object")
@@ -913,6 +928,7 @@ class NormalModuleFactory extends ModuleFactory {
 					});
 				}
 
+				/** @type {ModuleFactoryResult} * */
 				const factoryResult = {
 					module,
 					fileDependencies,

package/lib/OptionsApply.js

@@ -5,7 +5,18 @@
 
 "use strict";
 
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./Compiler")} Compiler */
+
 class OptionsApply {
-	process(options, compiler) {}
+	/**
+	 * @param {WebpackOptions} options options object
+	 * @param {Compiler} compiler compiler object
+	 * @returns {WebpackOptions} options object
+	 */
+	process(options, compiler) {
+		return options;
+	}
 }
+
 module.exports = OptionsApply;

package/lib/ProgressPlugin.js

@@ -15,11 +15,18 @@ const { contextify } = require("./util/identifier");
 /** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */
 /** @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 */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./logging/Logger").Logger} Logger */
 
+/**
+ * @template T, K, R
+ * @typedef {import("./util/AsyncQueue")<T, K, R>} AsyncQueue
+ */
+
 /**
  * @typedef {object} CountsData
  * @property {number} modulesCount modules count
@@ -121,6 +128,8 @@ const createDefaultHandler = (profile, logger) => {
 	return defaultHandler;
 };
 
+const SKIPPED_QUEUE_CONTEXTS = ["import-module", "load-module"];
+
 /**
  * @callback ReportProgress
  * @param {number} p percentage
@@ -217,7 +226,9 @@ class ProgressPlugin {
 		let lastDependenciesCount = 0;
 		let lastEntriesCount = 0;
 		let modulesCount = 0;
+		let skippedModulesCount = 0;
 		let dependenciesCount = 0;
+		let skippedDependenciesCount = 0;
 		let entriesCount = 1;
 		let doneModules = 0;
 		let doneDependencies = 0;
@@ -298,7 +309,15 @@ class ProgressPlugin {
 			lastUpdate = Date.now();
 		};
 
-		const factorizeAdd = () => {
+		/**
+		 * @template T
+		 * @param {AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>} factorizeQueue async queue
+		 * @param {T} _item item
+		 */
+		const factorizeAdd = (factorizeQueue, _item) => {
+			if (SKIPPED_QUEUE_CONTEXTS.includes(factorizeQueue.getContext())) {
+				skippedDependenciesCount++;
+			}
 			dependenciesCount++;
 			if (dependenciesCount < 50 || dependenciesCount % 100 === 0)
 				updateThrottled();
@@ -310,7 +329,15 @@ class ProgressPlugin {
 				updateThrottled();
 		};
 
-		const moduleAdd = () => {
+		/**
+		 * @template T
+		 * @param {AsyncQueue<Module, string, Module>} addModuleQueue async queue
+		 * @param {T} _item item
+		 */
+		const moduleAdd = (addModuleQueue, _item) => {
+			if (SKIPPED_QUEUE_CONTEXTS.includes(addModuleQueue.getContext())) {
+				skippedModulesCount++;
+			}
 			modulesCount++;
 			if (modulesCount < 50 || modulesCount % 100 === 0) updateThrottled();
 		};
@@ -397,12 +424,19 @@ class ProgressPlugin {
 			if (compilation.compiler.isChild()) return Promise.resolve();
 			return /** @type {Promise<CountsData>} */ (cacheGetPromise).then(
 				async oldData => {
+					const realModulesCount = modulesCount - skippedModulesCount;
+					const realDependenciesCount =
+						dependenciesCount - skippedDependenciesCount;
+
 					if (
 						!oldData ||
-						oldData.modulesCount !== modulesCount ||
-						oldData.dependenciesCount !== dependenciesCount
+						oldData.modulesCount !== realModulesCount ||
+						oldData.dependenciesCount !== realDependenciesCount
 					) {
-						await cache.storePromise({ modulesCount, dependenciesCount });
+						await cache.storePromise({
+							modulesCount: realModulesCount,
+							dependenciesCount: realDependenciesCount
+						});
 					}
 				}
 			);
@@ -413,19 +447,25 @@ class ProgressPlugin {
 			lastModulesCount = modulesCount;
 			lastEntriesCount = entriesCount;
 			lastDependenciesCount = dependenciesCount;
-			modulesCount = dependenciesCount = entriesCount = 0;
+			modulesCount =
+				skippedModulesCount =
+				dependenciesCount =
+				skippedDependenciesCount =
+				entriesCount =
+					0;
 			doneModules = doneDependencies = doneEntries = 0;
 
-			compilation.factorizeQueue.hooks.added.tap(
-				"ProgressPlugin",
-				factorizeAdd
+			compilation.factorizeQueue.hooks.added.tap("ProgressPlugin", item =>
+				factorizeAdd(compilation.factorizeQueue, item)
 			);
 			compilation.factorizeQueue.hooks.result.tap(
 				"ProgressPlugin",
 				factorizeDone
 			);
 
-			compilation.addModuleQueue.hooks.added.tap("ProgressPlugin", moduleAdd);
+			compilation.addModuleQueue.hooks.added.tap("ProgressPlugin", item =>
+				moduleAdd(compilation.addModuleQueue, item)
+			);
 			compilation.processDependenciesQueue.hooks.result.tap(
 				"ProgressPlugin",
 				moduleDone

package/lib/RawModule.js

@@ -7,6 +7,7 @@
 
 const { OriginalSource, RawSource } = require("webpack-sources");
 const Module = require("./Module");
+const { JS_TYPES } = require("./ModuleSourceTypesConstants");
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const makeSerializable = require("./util/makeSerializable");
 
@@ -16,11 +17,11 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
-/** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
@@ -30,8 +31,6 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-const TYPES = new Set(["javascript"]);
-
 class RawModule extends Module {
 	/**
 	 * @param {string} source source code
@@ -51,7 +50,7 @@ class RawModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return TYPES;
+		return JS_TYPES;
 	}
 
 	/**

package/lib/RuntimeModule.js

@@ -8,6 +8,7 @@
 const { RawSource } = require("webpack-sources");
 const OriginalSource = require("webpack-sources").OriginalSource;
 const Module = require("./Module");
+const { RUNTIME_TYPES } = require("./ModuleSourceTypesConstants");
 const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -16,18 +17,16 @@ const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-const TYPES = new Set([WEBPACK_MODULE_TYPE_RUNTIME]);
-
 class RuntimeModule extends Module {
 	/**
 	 * @param {string} name a readable name
@@ -127,7 +126,7 @@ class RuntimeModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return TYPES;
+		return RUNTIME_TYPES;
 	}
 
 	/**

package/lib/RuntimePlugin.js

@@ -34,6 +34,7 @@ const RuntimeIdRuntimeModule = require("./runtime/RuntimeIdRuntimeModule");
 const SystemContextRuntimeModule = require("./runtime/SystemContextRuntimeModule");
 const ShareRuntimeModule = require("./sharing/ShareRuntimeModule");
 const StringXor = require("./util/StringXor");
+const memoize = require("./util/memoize");
 
 /** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
@@ -42,6 +43,11 @@ const StringXor = require("./util/StringXor");
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 
+const getJavascriptModulesPlugin = memoize(() =>
+	require("./javascript/JavascriptModulesPlugin")
+);
+const getCssModulesPlugin = memoize(() => require("./css/CssModulesPlugin"));
+
 const GLOBALS_ON_REQUIRE = [
 	RuntimeGlobals.chunkName,
 	RuntimeGlobals.runtimeId,
@@ -261,7 +267,7 @@ class RuntimePlugin {
 				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.getChunkScriptFilename)
-				.tap("RuntimePlugin", (chunk, set) => {
+				.tap("RuntimePlugin", (chunk, set, { chunkGraph }) => {
 					if (
 						typeof compilation.outputOptions.chunkFilename === "string" &&
 						/\[(full)?hash(:\d+)?\]/.test(
@@ -277,8 +283,8 @@ class RuntimePlugin {
 							"javascript",
 							RuntimeGlobals.getChunkScriptFilename,
 							chunk =>
-								/** @type {TemplatePath} */
-								(
+								getJavascriptModulesPlugin().chunkHasJs(chunk, chunkGraph) &&
+								/** @type {TemplatePath} */ (
 									chunk.filenameTemplate ||
 										(chunk.canBeInitial()
 											? compilation.outputOptions.filename
@@ -291,7 +297,7 @@ class RuntimePlugin {
 				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.getChunkCssFilename)
-				.tap("RuntimePlugin", (chunk, set) => {
+				.tap("RuntimePlugin", (chunk, set, { chunkGraph }) => {
 					if (
 						typeof compilation.outputOptions.cssChunkFilename === "string" &&
 						/\[(full)?hash(:\d+)?\]/.test(
@@ -307,6 +313,7 @@ class RuntimePlugin {
 							"css",
 							RuntimeGlobals.getChunkCssFilename,
 							chunk =>
+								getCssModulesPlugin().chunkHasCss(chunk, chunkGraph) &&
 								getChunkFilenameTemplate(chunk, compilation.outputOptions),
 							set.has(RuntimeGlobals.hmrDownloadUpdateHandlers)
 						)

package/lib/RuntimeTemplate.js

@@ -86,7 +86,7 @@ class RuntimeTemplate {
 	 */
 	constructor(compilation, outputOptions, requestShortener) {
 		this.compilation = compilation;
-		this.outputOptions = outputOptions || {};
+		this.outputOptions = /** @type {OutputOptions} */ (outputOptions || {});
 		this.requestShortener = requestShortener;
 		this.globalObject =
 			/** @type {string} */
@@ -106,55 +106,47 @@ class RuntimeTemplate {
 	}
 
 	supportsConst() {
-		return /** @type {Environment} */ (this.outputOptions.environment).const;
+		return this.outputOptions.environment.const;
 	}
 
 	supportsArrowFunction() {
-		return /** @type {Environment} */ (this.outputOptions.environment)
-			.arrowFunction;
+		return this.outputOptions.environment.arrowFunction;
 	}
 
 	supportsAsyncFunction() {
-		return /** @type {Environment} */ (this.outputOptions.environment)
-			.asyncFunction;
+		return this.outputOptions.environment.asyncFunction;
 	}
 
 	supportsOptionalChaining() {
-		return /** @type {Environment} */ (this.outputOptions.environment)
-			.optionalChaining;
+		return this.outputOptions.environment.optionalChaining;
 	}
 
 	supportsForOf() {
-		return /** @type {Environment} */ (this.outputOptions.environment).forOf;
+		return this.outputOptions.environment.forOf;
 	}
 
 	supportsDestructuring() {
-		return /** @type {Environment} */ (this.outputOptions.environment)
-			.destructuring;
+		return this.outputOptions.environment.destructuring;
 	}
 
 	supportsBigIntLiteral() {
-		return /** @type {Environment} */ (this.outputOptions.environment)
-			.bigIntLiteral;
+		return this.outputOptions.environment.bigIntLiteral;
 	}
 
 	supportsDynamicImport() {
-		return /** @type {Environment} */ (this.outputOptions.environment)
-			.dynamicImport;
+		return this.outputOptions.environment.dynamicImport;
 	}
 
 	supportsEcmaScriptModuleSyntax() {
-		return /** @type {Environment} */ (this.outputOptions.environment).module;
+		return this.outputOptions.environment.module;
 	}
 
 	supportTemplateLiteral() {
-		return /** @type {Environment} */ (this.outputOptions.environment)
-			.templateLiteral;
+		return this.outputOptions.environment.templateLiteral;
 	}
 
 	supportNodePrefixForCoreModules() {
-		return /** @type {Environment} */ (this.outputOptions.environment)
-			.nodePrefixForCoreModules;
+		return this.outputOptions.environment.nodePrefixForCoreModules;
 	}
 
 	/**
@@ -315,7 +307,7 @@ class RuntimeTemplate {
 	 * Add a comment
 	 * @param {object} options Information content of the comment
 	 * @param {string=} options.request request string used originally
-	 * @param {string=} options.chunkName name of the chunk referenced
+	 * @param {(string | null)=} options.chunkName name of the chunk referenced
 	 * @param {string=} options.chunkReason reason information of the chunk
 	 * @param {string=} options.message additional message
 	 * @param {string=} options.exportName name of the export
@@ -1105,27 +1097,6 @@ class RuntimeTemplate {
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		return `${RuntimeGlobals.makeNamespaceObject}(${exportsArgument});\n`;
 	}
-
-	/**
-	 * @param {object} options options object
-	 * @param {Module} options.module the module
-	 * @param {RuntimeSpec=} options.runtime runtime
-	 * @param {CodeGenerationResults} options.codeGenerationResults the code generation results
-	 * @returns {string} the url of the asset
-	 */
-	assetUrl({ runtime, module, codeGenerationResults }) {
-		if (!module) {
-			return "data:,";
-		}
-		const codeGen = codeGenerationResults.get(module, runtime);
-		const data = /** @type {NonNullable<CodeGenerationResult["data"]>} */ (
-			codeGen.data
-		);
-		const url = data.get("url");
-		if (url) return url.toString();
-		const assetPath = data.get("assetPathForCss");
-		return assetPath;
-	}
 }
 
 module.exports = RuntimeTemplate;

package/lib/SourceMapDevToolPlugin.js

@@ -236,11 +236,17 @@ class SourceMapDevToolPlugin {
 								fileIndex++;
 								return callback();
 							}
+
+							const chunk = fileToChunk.get(file);
+							const sourceMapNamespace = compilation.getPath(this.namespace, {
+								chunk
+							});
+
 							const cacheItem = cache.getItemCache(
 								file,
 								cache.mergeEtags(
 									cache.getLazyHashedEtag(asset.source),
-									namespace
+									sourceMapNamespace
 								)
 							);
 
@@ -270,11 +276,8 @@ class SourceMapDevToolPlugin {
 										/**
 										 * Add file to chunk, if not presented there
 										 */
-										if (cachedFile !== file) {
-											const chunk = fileToChunk.get(file);
-											if (chunk !== undefined)
-												chunk.auxiliaryFiles.add(cachedFile);
-										}
+										if (cachedFile !== file && chunk !== undefined)
+											chunk.auxiliaryFiles.add(cachedFile);
 									}
 
 									reportProgress(
@@ -326,7 +329,7 @@ class SourceMapDevToolPlugin {
 													module,
 													{
 														moduleFilenameTemplate,
-														namespace
+														namespace: sourceMapNamespace
 													},
 													{
 														requestShortener,

package/lib/Watching.js

@@ -77,8 +77,8 @@ class Watching {
 	}
 
 	/**
-	 * @param {ReadonlySet<string>=} changedFiles changed files
-	 * @param {ReadonlySet<string>=} removedFiles removed files
+	 * @param {ReadonlySet<string> | undefined | null} changedFiles changed files
+	 * @param {ReadonlySet<string> | undefined | null} removedFiles removed files
 	 */
 	_mergeWithCollected(changedFiles, removedFiles) {
 		if (!changedFiles) return;