webpack 5.102.1 → 5.104.0

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,13 +147,16 @@ class CompatibilityPlugin {
 									range: /** @type {Range} */ (pattern.range)
 								}
 							});
-							return true;
+							if (!parser.scope.topLevelScope) {
+								return true;
+							}
 						});
 					parser.hooks.pattern
 						.for(RuntimeGlobals.exports)
 						.tap(PLUGIN_NAME, (pattern) => {
+							const newName = "__nested_webpack_exports__";
 							parser.tagVariable(pattern.name, nestedWebpackIdentifierTag, {
-								name: "__nested_webpack_exports__",
+								name: newName,
 								declaration: {
 									updated: false,
 									loc: /** @type {DependencyLocation} */ (pattern.loc),
@@ -162,6 +165,28 @@ class CompatibilityPlugin {
 							});
 							return true;
 						});
+					// Update single `var __webpack_require__ = {};` and `var __webpack_exports__ = {};` without expression
+					parser.hooks.declarator.tap(PLUGIN_NAME, (declarator) => {
+						if (
+							declarator.id.type === "Identifier" &&
+							(declarator.id.name === RuntimeGlobals.exports ||
+								declarator.id.name === RuntimeGlobals.require)
+						) {
+							const { name, declaration } =
+								/** @type {CompatibilitySettings} */ (
+									parser.getTagData(
+										declarator.id.name,
+										nestedWebpackIdentifierTag
+									)
+								);
+							if (!declaration.updated) {
+								const dep = new ConstDependency(name, declaration.range);
+								dep.loc = declaration.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								declaration.updated = true;
+							}
+						}
+					});
 					parser.hooks.expression
 						.for(nestedWebpackIdentifierTag)
 						.tap(PLUGIN_NAME, (expr) => {
@@ -212,3 +237,4 @@ class CompatibilityPlugin {
 }
 
 module.exports = CompatibilityPlugin;
+module.exports.nestedWebpackIdentifierTag = nestedWebpackIdentifierTag;

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 */
@@ -134,6 +133,12 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
 /** @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>
@@ -199,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
  */
 
 /**
@@ -223,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
  */
 
 /**
@@ -260,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__
@@ -296,6 +305,7 @@ const { isSourceEqual } = require("./util/source");
  * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
  * @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR)
  * @property {boolean=} javascriptModule true, when asset is javascript and an ESM
+ * @property {boolean=} manifest true, when file is a manifest
  * @property {Record<string, null | string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
  */
 
@@ -310,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
@@ -330,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 */
@@ -695,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 };
@@ -1216,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)",
@@ -1635,6 +1650,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	_processModuleDependencies(module, callback) {
 		/** @type {{ factory: ModuleFactory, dependencies: Dependency[], context: string | undefined, originModule: Module | null }[]} */
 		const sortedDependencies = [];
+		/** @type {boolean} */
+		const hasLowPriorityDependencies = module.dependencies.some(
+			Dependency.isLowPriorityDependency
+		);
 
 		/** @type {DependenciesBlock} */
 		let currentBlock;
@@ -1882,12 +1901,29 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				if (list === undefined) {
 					/** @type {FactoryCacheValue} */
 					(factoryCacheValue).set(cacheKey, (list = []));
-					sortedDependencies.push({
+					const newItem = {
 						factory: factoryCacheKey2,
 						dependencies: list,
 						context: dep.getContext(),
 						originModule: module
-					});
+					};
+					if (hasLowPriorityDependencies) {
+						let insertIndex = sortedDependencies.length;
+						while (insertIndex > 0) {
+							const item = sortedDependencies[insertIndex - 1];
+							const isAllLowPriorityDependencies = item.dependencies.every(
+								Dependency.isLowPriorityDependency
+							);
+							if (isAllLowPriorityDependencies) {
+								insertIndex--;
+							} else {
+								break;
+							}
+						}
+						sortedDependencies.splice(insertIndex, 0, newItem);
+					} else {
+						sortedDependencies.push(newItem);
+					}
 				}
 				list.push(dep);
 				listCacheKey1 = category;
@@ -3721,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/ConcatenationScope.js

@@ -112,18 +112,6 @@ class ConcatenationScope {
 		this._currentModule.namespaceExportSymbol = symbol;
 	}
 
-	/**
-	 * @param {string} symbol identifier of the export in source code
-	 * @returns {boolean} registered success
-	 */
-	registerUsedName(symbol) {
-		if (this.usedNames.has(symbol)) {
-			return false;
-		}
-		this.usedNames.add(symbol);
-		return true;
-	}
-
 	/**
 	 * @param {Module} module the referenced module
 	 * @param {Partial<ModuleReferenceOptions>} options options
@@ -189,7 +177,4 @@ class ConcatenationScope {
 ConcatenationScope.DEFAULT_EXPORT = DEFAULT_EXPORT;
 ConcatenationScope.NAMESPACE_OBJECT_EXPORT = NAMESPACE_OBJECT_EXPORT;
 
-/** @type {WeakMap<Chunk, Set<string>>} */
-ConcatenationScope.chunkUsedNames = new WeakMap();
-
 module.exports = ConcatenationScope;

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

package/lib/ContextModuleFactory.js

@@ -15,6 +15,8 @@ const { cachedSetProperty } = require("./util/cleverMerge");
 const { createFakeHook } = require("./util/deprecation");
 const { join } = require("./util/fs");
 
+/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Compilation").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
 /** @typedef {import("./ContextModule").ResolveDependenciesCallback} ResolveDependenciesCallback */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
@@ -22,7 +24,7 @@ const { join } = require("./util/fs");
 /** @typedef {import("./ResolverFactory")} ResolverFactory */
 /** @typedef {import("./dependencies/ContextDependency")} ContextDependency */
 /** @typedef {import("./dependencies/ContextDependency").ContextOptions} ContextOptions */
-/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
+
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
@@ -36,9 +38,9 @@ const { join } = require("./util/fs");
  * @property {string} context
  * @property {string} request
  * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions
- * @property {LazySet<string>} fileDependencies
- * @property {LazySet<string>} missingDependencies
- * @property {LazySet<string>} contextDependencies
+ * @property {FileSystemDependencies} fileDependencies
+ * @property {FileSystemDependencies} missingDependencies
+ * @property {FileSystemDependencies} contextDependencies
  * @property {ContextDependency[]} dependencies
  */