webpack 5.103.0 → 5.104.1

package/hot/dev-server.js

@@ -61,14 +61,29 @@ if (module.hot) {
 				}
 			});
 	};
+	/** @type {EventTarget | NodeJS.EventEmitter} */
 	var hotEmitter = require("./emitter");
-	hotEmitter.on("webpackHotUpdate", function (currentHash) {
-		lastHash = currentHash;
+	/**
+	 * @param {CustomEvent<{ currentHash: string }>} event event or hash
+	 */
+	var handler = function (event) {
+		lastHash = typeof event === "string" ? event : event.detail.currentHash;
 		if (!upToDate() && module.hot.status() === "idle") {
 			log("info", "[HMR] Checking for updates on the server...");
 			check();
 		}
-	});
+	};
+
+	if (typeof EventTarget !== "undefined" && hotEmitter instanceof EventTarget) {
+		hotEmitter.addEventListener(
+			"webpackHotUpdate",
+			/** @type {EventListener} */
+			(handler)
+		);
+	} else {
+		hotEmitter.on("webpackHotUpdate", handler);
+	}
+
 	log("info", "[HMR] Waiting for update signal from WDS...");
 } else {
 	throw new Error("[HMR] Hot Module Replacement is disabled.");

package/hot/emitter-event-target.js

@@ -0,0 +1,7 @@
+if (typeof EventTarget !== "function") {
+	throw new Error(
+		"Environment doesn't support lazy compilation (requires EventTarget)"
+	);
+}
+
+module.exports = new EventTarget();

package/hot/lazy-compilation-node.js

@@ -1,7 +1,7 @@
-/* global __resourceQuery */
-
 "use strict";
 
+/* global __resourceQuery */
+
 var urlBase = decodeURIComponent(__resourceQuery.slice(1));
 
 /**
@@ -10,29 +10,6 @@ var urlBase = decodeURIComponent(__resourceQuery.slice(1));
  */
 exports.keepAlive = function (options) {
 	var data = options.data;
-	var onError = options.onError;
-	var active = options.active;
-	var module = options.module;
-	/** @type {import("http").IncomingMessage} */
-	var response;
-	var request = (
-		urlBase.startsWith("https") ? require("https") : require("http")
-	).request(
-		urlBase + data,
-		{
-			agent: false,
-			headers: { accept: "text/event-stream" }
-		},
-		function (res) {
-			response = res;
-			response.on("error", errorHandler);
-			if (!active && !module.hot) {
-				console.log(
-					"Hot Module Replacement is not enabled. Waiting for process restart..."
-				);
-			}
-		}
-	);
 
 	/**
 	 * @param {Error} err error
@@ -40,11 +17,50 @@ exports.keepAlive = function (options) {
 	function errorHandler(err) {
 		err.message =
 			"Problem communicating active modules to the server: " + err.message;
-		onError(err);
+		options.onError(err);
 	}
-	request.on("error", errorHandler);
-	request.end();
+
+	/** @type {Promise<import("http") | import("https")>} */
+	var mod = require("./load-http")(urlBase.startsWith("https"));
+
+	/** @type {import("http").ClientRequest} */
+	var request;
+	/** @type {import("http").IncomingMessage} */
+	var response;
+
+	mod.then(function (client) {
+		request = client.request(
+			urlBase + data,
+			{
+				agent: false,
+				headers: { accept: "text/event-stream" }
+			},
+			function (res) {
+				response = res;
+				response.on("error", errorHandler);
+
+				if (!options.active && !options.module.hot) {
+					console.log(
+						"Hot Module Replacement is not enabled. Waiting for process restart..."
+					);
+				}
+			}
+		);
+
+		request.on("error", errorHandler);
+		request.end();
+	});
+
 	return function () {
-		response.destroy();
+		if (response) {
+			response.destroy();
+		}
 	};
 };
+
+/**
+ * @param {string} value new url value
+ */
+exports.setUrl = function (value) {
+	urlBase = value;
+};

package/hot/lazy-compilation-universal.js

@@ -0,0 +1,18 @@
+"use strict";
+
+/* global __resourceQuery */
+
+var isNodeLikeEnv =
+	typeof global !== "undefined" && typeof global.process !== "undefined";
+
+var handler = isNodeLikeEnv
+	? require("./lazy-compilation-node")
+	: require("./lazy-compilation-web");
+
+handler.setUrl(decodeURIComponent(__resourceQuery.slice(1)));
+
+/**
+ * @param {{ data: string, onError: (err: Error) => void, active: boolean, module: module }} options options
+ * @returns {() => void} function to destroy response
+ */
+module.exports = handler;

package/hot/lazy-compilation-web.js

@@ -1,7 +1,7 @@
-/* global __resourceQuery */
-
 "use strict";
 
+/* global __resourceQuery */
+
 if (typeof EventSource !== "function") {
 	throw new Error(
 		"Environment doesn't support lazy compilation (requires EventSource)"
@@ -54,15 +54,18 @@ var updateEventSource = function updateEventSource() {
 exports.keepAlive = function (options) {
 	var data = options.data;
 	var onError = options.onError;
-	var active = options.active;
-	var module = options.module;
+
 	errorHandlers.add(onError);
+
 	var value = activeKeys.get(data) || 0;
+
 	activeKeys.set(data, value + 1);
+
 	if (value === 0) {
 		updateEventSource();
 	}
-	if (!active && !module.hot) {
+
+	if (!options.active && !options.module.hot) {
 		console.log(
 			"Hot Module Replacement is not enabled. Waiting for process restart..."
 		);
@@ -81,3 +84,10 @@ exports.keepAlive = function (options) {
 		}, 1000);
 	};
 };
+
+/**
+ * @param {string} value new url value
+ */
+exports.setUrl = function (value) {
+	urlBase = value;
+};

package/hot/load-http.js

@@ -0,0 +1,7 @@
+/**
+ * @param {boolean} isHTTPS true when need https module, otherwise false
+ * @returns {Promise<import("http") | import("https")>}
+ */
+module.exports = function (isHTTPS) {
+	return isHTTPS ? import("https") : import("http");
+};

package/hot/only-dev-server.js

@@ -4,7 +4,7 @@
 */
 /* globals __webpack_hash__ */
 if (module.hot) {
-	/** @type {undefined|string} */
+	/** @type {undefined | string} */
 	var lastHash;
 	var upToDate = function upToDate() {
 		return /** @type {string} */ (lastHash).indexOf(__webpack_hash__) >= 0;
@@ -79,9 +79,13 @@ if (module.hot) {
 				}
 			});
 	};
+	/** @type {EventTarget | NodeJS.EventEmitter} */
 	var hotEmitter = require("./emitter");
-	hotEmitter.on("webpackHotUpdate", function (currentHash) {
-		lastHash = currentHash;
+	/**
+	 * @param {CustomEvent<{ currentHash: string }>} event event or hash
+	 */
+	var handler = function (event) {
+		lastHash = typeof event === "string" ? event : event.detail.currentHash;
 		if (!upToDate()) {
 			var status = module.hot.status();
 			if (status === "idle") {
@@ -96,7 +100,18 @@ if (module.hot) {
 				);
 			}
 		}
-	});
+	};
+
+	if (typeof EventTarget !== "undefined" && hotEmitter instanceof EventTarget) {
+		hotEmitter.addEventListener(
+			"webpackHotUpdate",
+			/** @type {EventListener} */
+			(handler)
+		);
+	} else {
+		hotEmitter.on("webpackHotUpdate", handler);
+	}
+
 	log("info", "[HMR] Waiting for update signal from WDS...");
 } else {
 	throw new Error("[HMR] Hot Module Replacement is disabled.");

package/lib/APIPlugin.js

@@ -42,6 +42,12 @@ function getReplacements() {
 			type: "function",
 			assign: false
 		},
+		__webpack_global__: {
+			expr: RuntimeGlobals.require,
+			req: [RuntimeGlobals.require],
+			type: "function",
+			assign: false
+		},
 		__webpack_public_path__: {
 			expr: RuntimeGlobals.publicPath,
 			req: [RuntimeGlobals.publicPath],

package/lib/Chunk.js

@@ -207,7 +207,7 @@ class Chunk {
 
 	/**
 	 * @param {Chunk} otherChunk the chunk to compare with
-	 * @returns {-1|0|1} the comparison result
+	 * @returns {-1 | 0 | 1} the comparison result
 	 */
 	compareTo(otherChunk) {
 		const chunkGraph = ChunkGraph.getChunkGraphForChunk(

package/lib/ChunkGraph.js

@@ -35,8 +35,9 @@ const {
 /** @typedef {import("./Chunk").Entrypoints} Entrypoints */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./Module").SourceType} SourceType */
+/** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
@@ -97,7 +98,7 @@ const getModuleRuntimes = (chunks) => {
  * @returns {(set: SortableSet<Module>) => Map<string, SortableSet<Module>>} modules by source type
  */
 const modulesBySourceType = (sourceTypesByModule) => (set) => {
-	/** @type {Map<string, SortableSet<Module>>} */
+	/** @type {Map<SourceType, SortableSet<Module>>} */
 	const map = new Map();
 	for (const module of set) {
 		const sourceTypes =
@@ -220,7 +221,7 @@ class ChunkGraphModule {
 	}
 }
 
-/** @typedef {WeakMap<Module, Set<string>>} SourceTypesByModule */
+/** @typedef {WeakMap<Module, SourceTypes>} SourceTypesByModule */
 /** @typedef {Map<Module, Entrypoint>} EntryModules */
 
 class ChunkGraphChunk {
@@ -631,7 +632,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunk chunk
 	 * @param {Module} module chunk module
-	 * @param {Set<string>} sourceTypes source types
+	 * @param {SourceTypes} sourceTypes source types
 	 */
 	setChunkModuleSourceTypes(chunk, module, sourceTypes) {
 		const cgc = this._getChunkGraphChunk(chunk);
@@ -668,10 +669,11 @@ class ChunkGraph {
 
 	/**
 	 * @param {Module} module module
-	 * @returns {Set<string> | undefined} source types
+	 * @returns {SourceTypes | undefined} source types
 	 */
 	_getOverwrittenModuleSourceTypes(module) {
 		let newSet = false;
+		/** @type {Set<SourceType> | undefined} */
 		let sourceTypes;
 		for (const chunk of this.getModuleChunksIterable(module)) {
 			const cgc = this._getChunkGraphChunk(chunk);
@@ -679,7 +681,7 @@ class ChunkGraph {
 			const st = cgc.sourceTypesByModule.get(module);
 			if (st === undefined) return;
 			if (!sourceTypes) {
-				sourceTypes = st;
+				sourceTypes = /** @type {Set<SourceType>} */ (st);
 			} else if (!newSet) {
 				for (const type of st) {
 					if (!newSet) {
@@ -871,7 +873,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunkA first chunk
 	 * @param {Chunk} chunkB second chunk
-	 * @returns {-1|0|1} this is a comparator function like sort and returns -1, 0, or 1 based on sort order
+	 * @returns {-1 | 0 | 1} this is a comparator function like sort and returns -1, 0, or 1 based on sort order
 	 */
 	compareChunks(chunkA, chunkB) {
 		const cgcA = this._getChunkGraphChunk(chunkA);

package/lib/ChunkGroup.js

@@ -45,7 +45,7 @@ const getArray = (set) => [...set];
  * A convenience method used to sort chunks based on their id's
  * @param {ChunkGroup} a first sorting comparator
  * @param {ChunkGroup} b second sorting comparator
- * @returns {1|0|-1} a sorting index to determine order
+ * @returns {1 | 0 | -1} a sorting index to determine order
  */
 const sortById = (a, b) => {
 	if (a.id < b.id) return -1;
@@ -56,7 +56,7 @@ const sortById = (a, b) => {
 /**
  * @param {OriginRecord} a the first comparator in sort
  * @param {OriginRecord} b the second comparator in sort
- * @returns {1|-1|0} returns sorting order as index
+ * @returns {1 | -1| 0} returns sorting order as index
  */
 const sortOrigin = (a, b) => {
 	const aIdent = a.module ? a.module.identifier() : "";
@@ -91,16 +91,19 @@ class ChunkGroup {
 		this.chunks = [];
 		/** @type {OriginRecord[]} */
 		this.origins = [];
+
+		/** @typedef {Map<Module, number>} OrderIndices */
+
 		/** Indices in top-down order */
 		/**
 		 * @private
-		 * @type {Map<Module, number>}
+		 * @type {OrderIndices}
 		 */
 		this._modulePreOrderIndices = new Map();
 		/** Indices in bottom-up order */
 		/**
 		 * @private
-		 * @type {Map<Module, number>}
+		 * @type {OrderIndices}
 		 */
 		this._modulePostOrderIndices = new Map();
 		/** @type {number | undefined} */
@@ -485,7 +488,7 @@ class ChunkGroup {
 	 * Sorting values are based off of number of chunks in ChunkGroup.
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {ChunkGroup} otherGroup the chunkGroup to compare this against
-	 * @returns {-1|0|1} sort position for comparison
+	 * @returns {-1 | 0 | 1} sort position for comparison
 	 */
 	compareTo(chunkGraph, otherGroup) {
 		if (this.chunks.length > otherGroup.chunks.length) return -1;

package/lib/CleanPlugin.js

@@ -63,8 +63,10 @@ const mergeAssets = (as1, as2) => {
 	}
 };
 
+/** @typedef {Map<string, number>} CurrentAssets */
+
 /**
- * @param {Map<string, number>} assets current assets
+ * @param {CurrentAssets} assets current assets
  * @returns {Set<string>} Set of directory paths
  */
 function getDirectories(assets) {
@@ -92,12 +94,13 @@ function getDirectories(assets) {
 /**
  * @param {OutputFileSystem} fs filesystem
  * @param {string} outputPath output path
- * @param {Map<string, number>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
+ * @param {CurrentAssets} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
  * @param {(err?: Error | null, set?: Diff) => void} callback returns the filenames of the assets that shouldn't be there
  * @returns {void}
  */
 const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 	const directories = getDirectories(currentAssets);
+	/** @type {Diff} */
 	const diff = new Set();
 	asyncLib.forEachLimit(
 		directories,
@@ -388,7 +391,7 @@ class CleanPlugin {
 		// We assume that no external modification happens while the compiler is active
 		// So we can store the old assets and only diff to them to avoid fs access on
 		// incremental builds
-		/** @type {undefined|Assets} */
+		/** @type {undefined | Assets} */
 		let oldAssets;
 
 		compiler.hooks.emit.tapAsync(

package/lib/CodeGenerationResults.js

@@ -13,6 +13,7 @@ const { RuntimeSpecMap, runtimeToString } = require("./util/runtime");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./Module").SourceType} SourceType */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
@@ -96,7 +97,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @param {string} sourceType the source type
+	 * @param {SourceType} sourceType the source type
 	 * @returns {Source} a source
 	 */
 	getSource(module, runtime, sourceType) {

package/lib/CompatibilityPlugin.js

@@ -147,6 +147,9 @@ class CompatibilityPlugin {
 									range: /** @type {Range} */ (pattern.range)
 								}
 							});
+							if (!parser.scope.topLevelScope) {
+								return true;
+							}
 						});
 					parser.hooks.pattern
 						.for(RuntimeGlobals.exports)

package/lib/Compilation.js

@@ -84,7 +84,6 @@ const processAsyncTree = require("./util/processAsyncTree");
 const { getRuntimeKey } = require("./util/runtime");
 const { isSourceEqual } = require("./util/source");
 
-/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
@@ -135,6 +134,11 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./util/Hash")} Hash */
 
+/**
+ * @template T
+ * @typedef {import("tapable").AsArray<T>} AsArray<T>
+ */
+
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
@@ -200,9 +204,9 @@ const { isSourceEqual } = require("./util/source");
  * @property {string | number} id
  * @property {string=} name
  * @property {string} hash
- * @property {((length: number) => string)=} hashWithLength
+ * @property {HashWithLengthFunction=} hashWithLength
  * @property {(Record<string, string>)=} contentHash
- * @property {(Record<string, (length: number) => string>)=} contentHashWithLength
+ * @property {(Record<string, HashWithLengthFunction>)=} contentHashWithLength
  */
 
 /**
@@ -224,17 +228,19 @@ const { isSourceEqual } = require("./util/source");
  * @property {EntryOptions=} entryOptions
  */
 
+/** @typedef {LazySet<string>} FileSystemDependencies */
+
 /** @typedef {EXPECTED_ANY} ExecuteModuleExports */
 
 /**
  * @typedef {object} ExecuteModuleResult
  * @property {ExecuteModuleExports} exports
  * @property {boolean} cacheable
- * @property {Map<string, { source: Source, info: AssetInfo | undefined }>} assets
- * @property {LazySet<string>} fileDependencies
- * @property {LazySet<string>} contextDependencies
- * @property {LazySet<string>} missingDependencies
- * @property {LazySet<string>} buildDependencies
+ * @property {ExecuteModuleAssets} assets
+ * @property {FileSystemDependencies} fileDependencies
+ * @property {FileSystemDependencies} contextDependencies
+ * @property {FileSystemDependencies} missingDependencies
+ * @property {FileSystemDependencies} buildDependencies
  */
 
 /**
@@ -261,9 +267,11 @@ const { isSourceEqual } = require("./util/source");
  * @property {WebpackRequire} require require function
  */
 
+/** @typedef {Map<string, { source: Source, info: AssetInfo | undefined }>} ExecuteModuleAssets */
+
 /**
  * @typedef {object} ExecuteModuleContext
- * @property {Map<string, { source: Source, info: AssetInfo | undefined }>} assets
+ * @property {ExecuteModuleAssets} assets
  * @property {Chunk} chunk
  * @property {ChunkGraph} chunkGraph
  * @property {WebpackRequire=} __webpack_require__
@@ -312,18 +320,22 @@ const { isSourceEqual } = require("./util/source");
  * @property {AssetInfo} info info about the asset
  */
 
+/** @typedef {(length: number) => string} HashWithLengthFunction */
+
 /**
  * @typedef {object} ModulePathData
  * @property {string | number} id
  * @property {string} hash
- * @property {((length: number) => string)=} hashWithLength
+ * @property {HashWithLengthFunction=} hashWithLength
  */
 
+/** @typedef {(id: string | number) => string | number} PrepareIdFunction */
+
 /**
  * @typedef {object} PathData
  * @property {ChunkGraph=} chunkGraph
  * @property {string=} hash
- * @property {((length: number) => string)=} hashWithLength
+ * @property {HashWithLengthFunction=} hashWithLength
  * @property {(Chunk | ChunkPathData)=} chunk
  * @property {(Module | ModulePathData)=} module
  * @property {RuntimeSpec=} runtime
@@ -332,9 +344,10 @@ const { isSourceEqual } = require("./util/source");
  * @property {string=} query
  * @property {string=} contentHashType
  * @property {string=} contentHash
- * @property {((length: number) => string)=} contentHashWithLength
+ * @property {HashWithLengthFunction=} contentHashWithLength
  * @property {boolean=} noChunkHash
  * @property {string=} url
+ * @property {PrepareIdFunction=} prepareId
  */
 
 /** @typedef {"module" | "chunk" | "root-of-chunk" | "nested"} ExcludeModulesType */
@@ -697,8 +710,8 @@ class Compilation {
 			) => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
 BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
 			/**
-			 * @param {string | (import("tapable").TapOptions & { name: string; } & ProcessAssetsAdditionalOptions)} options hook options
-			 * @returns {import("tapable").TapOptions & { name: string; } & ProcessAssetsAdditionalOptions} modified options
+			 * @param {string | (import("tapable").TapOptions & { name: string } & ProcessAssetsAdditionalOptions)} options hook options
+			 * @returns {import("tapable").TapOptions & { name: string } & ProcessAssetsAdditionalOptions} modified options
 			 */
 			const getOptions = (options) => {
 				if (typeof options === "string") options = { name: options };
@@ -1218,20 +1231,20 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.emittedAssets = new Set();
 		/** @type {Set<string>} */
 		this.comparedForEmitAssets = new Set();
-		/** @type {LazySet<string>} */
+		/** @type {FileSystemDependencies} */
 		this.fileDependencies = new LazySet();
-		/** @type {LazySet<string>} */
+		/** @type {FileSystemDependencies} */
 		this.contextDependencies = new LazySet();
-		/** @type {LazySet<string>} */
+		/** @type {FileSystemDependencies} */
 		this.missingDependencies = new LazySet();
-		/** @type {LazySet<string>} */
+		/** @type {FileSystemDependencies} */
 		this.buildDependencies = new LazySet();
 		// TODO webpack 6 remove
 		this.compilationDependencies = {
 			add: util.deprecate(
 				/**
 				 * @param {string} item item
-				 * @returns {LazySet<string>} file dependencies
+				 * @returns {FileSystemDependencies} file dependencies
 				 */
 				(item) => this.fileDependencies.add(item),
 				"Compilation.compilationDependencies is deprecated (used Compilation.fileDependencies instead)",
@@ -3744,6 +3757,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						dependencyTemplates,
 						runtimeTemplate,
 						runtime,
+						runtimes,
 						codeGenerationResults: results,
 						compilation: this
 					});

package/lib/Compiler.js

@@ -719,9 +719,9 @@ class Compiler {
 				({ name: file, source, info }, callback) => {
 					let targetFile = file;
 					let immutable = info.immutable;
-					const queryStringIdx = targetFile.indexOf("?");
-					if (queryStringIdx >= 0) {
-						targetFile = targetFile.slice(0, queryStringIdx);
+					const queryOrHashStringIdx = targetFile.search(/[?#]/);
+					if (queryOrHashStringIdx >= 0) {
+						targetFile = targetFile.slice(0, queryOrHashStringIdx);
 						// We may remove the hash, which is in the query string
 						// So we recheck if the file is immutable
 						// This doesn't cover all cases, but immutable is only a performance optimization anyway

package/lib/ContextModule.js

@@ -9,7 +9,10 @@ const { OriginalSource, RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
 const { makeWebpackError } = require("./HookWebpackError");
 const Module = require("./Module");
-const { JS_TYPES } = require("./ModuleSourceTypesConstants");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("./ModuleSourceTypeConstants");
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
@@ -162,7 +165,7 @@ class ContextModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	/**
@@ -1184,7 +1187,7 @@ module.exports = webpackEmptyAsyncContext;`;
 		const { chunkGraph, compilation } = context;
 		const sources = new Map();
 		sources.set(
-			"javascript",
+			JAVASCRIPT_TYPE,
 			this.getSource(
 				this.getSourceString(this.options.mode, context),
 				compilation