webpack 5.94.0 → 5.96.0

package/lib/Module.js

@@ -9,6 +9,7 @@ const util = require("util");
 const ChunkGraph = require("./ChunkGraph");
 const DependenciesBlock = require("./DependenciesBlock");
 const ModuleGraph = require("./ModuleGraph");
+const { JS_TYPES } = require("./ModuleSourceTypesConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const { first } = require("./util/SetHelpers");
 const { compareChunksById } = require("./util/comparators");
@@ -23,7 +24,6 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").ValueCacheVersion} ValueCacheVersion */
 /** @typedef {import("./ConcatenationScope")} ConcatenationScope */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
@@ -56,6 +56,8 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {string=} type the type of source that should be generated
  */
 
+/** @typedef {ReadonlySet<string>} SourceTypes */
+
 // TODO webpack 6: compilation will be required in CodeGenerationContext
 /**
  * @typedef {object} CodeGenerationContext
@@ -67,7 +69,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
  * @property {CodeGenerationResults | undefined} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
  * @property {Compilation=} compilation the compilation
- * @property {ReadonlySet<string>=} sourceTypes source types
+ * @property {SourceTypes=} sourceTypes source types
  */
 
 /**
@@ -114,18 +116,20 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {LazySet<string>=} contextDependencies
  * @property {LazySet<string>=} missingDependencies
  * @property {LazySet<string>=} buildDependencies
- * @property {(Map<string, ValueCacheVersion>)=} valueDependencies
+ * @property {ValueCacheVersions=} valueDependencies
  * @property {TODO=} hash
  * @property {Record<string, Source>=} assets
  * @property {Map<string, AssetInfo | undefined>=} assetsInfo
  * @property {(Snapshot | null)=} snapshot
  */
 
+/** @typedef {Map<string, string | Set<string>>} ValueCacheVersions */
+
 /**
  * @typedef {object} NeedBuildContext
  * @property {Compilation} compilation
  * @property {FileSystemInfo} fileSystemInfo
- * @property {Map<string, string | Set<string>>} valueCacheVersions
+ * @property {ValueCacheVersions} valueCacheVersions
  */
 
 /** @typedef {KnownBuildMeta & Record<string, any>} BuildMeta */
@@ -136,8 +140,6 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {boolean=} sideEffectFree
  */
 
-/** @typedef {Set<string>} SourceTypes */
-
 /** @typedef {{ factoryMeta: FactoryMeta | undefined, resolveOptions: ResolveOptions | undefined }} UnsafeCacheData */
 
 const EMPTY_RESOLVE_OPTIONS = {};
@@ -145,7 +147,6 @@ const EMPTY_RESOLVE_OPTIONS = {};
 let debugId = 1000;
 
 const DEFAULT_TYPES_UNKNOWN = new Set(["unknown"]);
-const DEFAULT_TYPES_JS = new Set(["javascript"]);
 
 const deprecatedNeedRebuild = util.deprecate(
 	/**
@@ -873,7 +874,7 @@ class Module extends DependenciesBlock {
 		if (this.source === Module.prototype.source) {
 			return DEFAULT_TYPES_UNKNOWN;
 		}
-		return DEFAULT_TYPES_JS;
+		return JS_TYPES;
 	}
 
 	/**

package/lib/ModuleSourceTypesConstants.js

@@ -0,0 +1,100 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * @type {ReadonlySet<never>}
+ */
+const NO_TYPES = new Set();
+
+/**
+ * @type {ReadonlySet<"asset">}
+ */
+const ASSET_TYPES = new Set(["asset"]);
+
+/**
+ * @type {ReadonlySet<"asset" | "javascript" | "asset">}
+ */
+const ASSET_AND_JS_TYPES = new Set(["asset", "javascript"]);
+
+/**
+ * @type {ReadonlySet<"css-url" | "asset">}
+ */
+const ASSET_AND_CSS_URL_TYPES = new Set(["asset", "css-url"]);
+
+/**
+ * @type {ReadonlySet<"javascript" | "css-url" | "asset">}
+ */
+const ASSET_AND_JS_AND_CSS_URL_TYPES = new Set([
+	"asset",
+	"javascript",
+	"css-url"
+]);
+
+/**
+ * @type {ReadonlySet<"javascript">}
+ */
+const JS_TYPES = new Set(["javascript"]);
+
+/**
+ * @type {ReadonlySet<"javascript" | "css-url">}
+ */
+const JS_AND_CSS_URL_TYPES = new Set(["javascript", "css-url"]);
+
+/**
+ * @type {ReadonlySet<"css">}
+ */
+const CSS_TYPES = new Set(["css"]);
+
+/**
+ * @type {ReadonlySet<"css-url">}
+ */
+const CSS_URL_TYPES = new Set(["css-url"]);
+/**
+ * @type {ReadonlySet<"css-import">}
+ */
+const CSS_IMPORT_TYPES = new Set(["css-import"]);
+
+/**
+ * @type {ReadonlySet<"webassembly">}
+ */
+const WEBASSEMBLY_TYPES = new Set(["webassembly"]);
+
+/**
+ * @type {ReadonlySet<"runtime">}
+ */
+const RUNTIME_TYPES = new Set(["runtime"]);
+
+/**
+ * @type {ReadonlySet<"remote" | "share-init">}
+ */
+const REMOTE_AND_SHARE_INIT_TYPES = new Set(["remote", "share-init"]);
+
+/**
+ * @type {ReadonlySet<"consume-shared">}
+ */
+const CONSUME_SHARED_TYPES = new Set(["consume-shared"]);
+
+/**
+ * @type {ReadonlySet<"share-init">}
+ */
+const SHARED_INIT_TYPES = new Set(["share-init"]);
+
+module.exports.NO_TYPES = NO_TYPES;
+module.exports.JS_TYPES = JS_TYPES;
+module.exports.JS_AND_CSS_URL_TYPES = JS_AND_CSS_URL_TYPES;
+module.exports.ASSET_TYPES = ASSET_TYPES;
+module.exports.ASSET_AND_JS_TYPES = ASSET_AND_JS_TYPES;
+module.exports.ASSET_AND_CSS_URL_TYPES = ASSET_AND_CSS_URL_TYPES;
+module.exports.ASSET_AND_JS_AND_CSS_URL_TYPES = ASSET_AND_JS_AND_CSS_URL_TYPES;
+module.exports.CSS_TYPES = CSS_TYPES;
+module.exports.CSS_URL_TYPES = CSS_URL_TYPES;
+module.exports.CSS_IMPORT_TYPES = CSS_IMPORT_TYPES;
+module.exports.WEBASSEMBLY_TYPES = WEBASSEMBLY_TYPES;
+module.exports.RUNTIME_TYPES = RUNTIME_TYPES;
+module.exports.REMOTE_AND_SHARE_INIT_TYPES = REMOTE_AND_SHARE_INIT_TYPES;
+module.exports.CONSUME_SHARED_TYPES = CONSUME_SHARED_TYPES;
+module.exports.SHARED_INIT_TYPES = SHARED_INIT_TYPES;

package/lib/NormalModule.js

@@ -65,12 +65,13 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Module").KnownBuildInfo} KnownBuildInfo */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").SourceTypes} SourceTypes */
+/** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./ModuleTypeConstants").JavaScriptModuleTypes} JavaScriptModuleTypes */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("./NormalModuleFactory").ResourceDataWithData} ResourceDataWithData */
 /** @typedef {import("./Parser")} Parser */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolveContext} ResolveContext */
@@ -777,6 +778,10 @@ class NormalModule extends Module {
 			webpack: true,
 			sourceMap: Boolean(this.useSourceMap),
 			mode: options.mode || "production",
+			hashFunction: /** @type {TODO} */ (options.output.hashFunction),
+			hashDigest: /** @type {string} */ (options.output.hashDigest),
+			hashDigestLength: /** @type {number} */ (options.output.hashDigestLength),
+			hashSalt: /** @type {string} */ (options.output.hashSalt),
 			_module: this,
 			_compilation: compilation,
 			_compiler: compilation.compiler,
@@ -947,7 +952,7 @@ class NormalModule extends Module {
 				/** @type {LoaderContext<any>} */ (loaderContext)
 			);
 		} catch (err) {
-			processResult(err);
+			processResult(/** @type {Error} */ (err));
 			return;
 		}
 
@@ -961,6 +966,11 @@ class NormalModule extends Module {
 				resource: this.resource,
 				loaders: this.loaders,
 				context: loaderContext,
+				/**
+				 * @param {LoaderContext<TODO>} loaderContext the loader context
+				 * @param {string} resourcePath the resource Path
+				 * @param {(err: Error | null, result?: string | Buffer) => void} callback callback
+				 */
 				processResource: (loaderContext, resourcePath, callback) => {
 					const resource = loaderContext.resource;
 					const scheme = getScheme(resource);
@@ -1597,24 +1607,28 @@ class NormalModule extends Module {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {TODO} Module
+	 */
 	static deserialize(context) {
 		const obj = new NormalModule({
 			// will be deserialized by Module
-			layer: null,
+			layer: /** @type {EXPECTED_ANY} */ (null),
 			type: "",
 			// will be filled by updateCacheModule
 			resource: "",
 			context: "",
-			request: null,
-			userRequest: null,
-			rawRequest: null,
-			loaders: null,
-			matchResource: null,
-			parser: null,
-			parserOptions: null,
-			generator: null,
-			generatorOptions: null,
-			resolveOptions: null
+			request: /** @type {EXPECTED_ANY} */ (null),
+			userRequest: /** @type {EXPECTED_ANY} */ (null),
+			rawRequest: /** @type {EXPECTED_ANY} */ (null),
+			loaders: /** @type {EXPECTED_ANY} */ (null),
+			matchResource: /** @type {EXPECTED_ANY} */ (null),
+			parser: /** @type {EXPECTED_ANY} */ (null),
+			parserOptions: /** @type {EXPECTED_ANY} */ (null),
+			generator: /** @type {EXPECTED_ANY} */ (null),
+			generatorOptions: /** @type {EXPECTED_ANY} */ (null),
+			resolveOptions: /** @type {EXPECTED_ANY} */ (null)
 		});
 		obj.deserialize(context);
 		return obj;

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;
 	}
 
 	/**