webpack 5.101.0 → 5.101.1

package/lib/ChunkGraph.js

@@ -1238,6 +1238,48 @@ class ChunkGraph {
 		return set;
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<Chunk>} iterable of chunks and include chunks from children entrypoints
+	 */
+	getChunkEntryDependOnChunksIterable(chunk) {
+		/** @type {Set<Chunk>} */
+		const set = new Set();
+
+		/** @type {Set<Entrypoint>} */
+		const entrypoints = new Set();
+
+		for (const chunkGroup of chunk.groupsIterable) {
+			if (chunkGroup instanceof Entrypoint) {
+				const queue = [chunkGroup];
+				while (queue.length > 0) {
+					const current = queue.shift();
+					if (current) {
+						entrypoints.add(current);
+
+						let hasChildrenEntrypoint = false;
+						for (const child of current.childrenIterable) {
+							if (child.isInitial()) {
+								hasChildrenEntrypoint = true;
+								queue.push(/** @type {Entrypoint} */ (child));
+							}
+						}
+						// entryChunkB: hasChildrenEntrypoint = true
+						// entryChunkA: dependOn = entryChunkB
+						if (hasChildrenEntrypoint) {
+							const entrypointChunk = current.getEntrypointChunk();
+							if (entrypointChunk !== chunk && !entrypointChunk.hasRuntime()) {
+								// add entryChunkB to set
+								set.add(entrypointChunk);
+							}
+						}
+					}
+				}
+			}
+		}
+		return set;
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @returns {boolean} true, when it has dependent chunks

package/lib/Compilation.js

@@ -526,6 +526,21 @@ class Compilation {
 
 				/** @type {ProcessedAssets | undefined} */
 				const processedAssets = additionalAssetsFn ? new WeakSet() : undefined;
+				/**
+				 * @param {CompilationAssets} assets to be processed by additionalAssetsFn
+				 * @returns {CompilationAssets} available assets
+				 */
+				const getAvailableAssets = (assets) => {
+					/** @type {CompilationAssets} */
+					const availableAssets = {};
+					for (const file of Object.keys(assets)) {
+						// https://github.com/webpack-contrib/compression-webpack-plugin/issues/390
+						if (this.assets[file]) {
+							availableAssets[file] = assets[file];
+						}
+					}
+					return availableAssets;
+				};
 				switch (type) {
 					case "sync":
 						if (additionalAssetsFn) {
@@ -534,7 +549,7 @@ class Compilation {
 									/** @type {ProcessedAssets} */
 									(processedAssets).has(this.assets)
 								) {
-									additionalAssetsFn(assets);
+									additionalAssetsFn(getAvailableAssets(assets));
 								}
 							});
 						}
@@ -575,7 +590,10 @@ class Compilation {
 										/** @type {ProcessedAssets} */
 										(processedAssets).has(this.assets)
 									) {
-										return additionalAssetsFn(assets, callback);
+										return additionalAssetsFn(
+											getAvailableAssets(assets),
+											callback
+										);
 									}
 									callback();
 								}
@@ -620,7 +638,7 @@ class Compilation {
 									/** @type {ProcessedAssets} */
 									(processedAssets).has(this.assets)
 								) {
-									return additionalAssetsFn(assets);
+									return additionalAssetsFn(getAvailableAssets(assets));
 								}
 								return Promise.resolve();
 							});
@@ -3242,6 +3260,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				entry.setRuntimeChunk(chunk);
 			}
 		}
+
 		buildChunkGraph(this, chunkGraphInit);
 		this.hooks.afterChunks.call(this.chunks);
 		this.logger.timeEnd("create chunks");
@@ -3259,6 +3278,26 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 		this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups);
 
+		for (const [
+			name,
+			{
+				options: { dependOn }
+			}
+		] of this.entries) {
+			if (dependOn) {
+				const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name));
+				for (const dep of dependOn) {
+					const depEntry = /** @type {Entrypoint} */ (
+						this.entrypoints.get(dep)
+					);
+					const runtimeChunk = depEntry.getRuntimeChunk();
+					if (runtimeChunk) {
+						runtimeChunk.addGroup(entry);
+					}
+				}
+			}
+		}
+
 		this.hooks.optimizeTree.callAsync(this.chunks, this.modules, (err) => {
 			if (err) {
 				return finalCallback(

package/lib/Dependency.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const RawModule = require("./RawModule");
 const memoize = require("./util/memoize");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -86,6 +85,8 @@ const memoize = require("./util/memoize");
 const TRANSITIVE = Symbol("transitive");
 
 const getIgnoredModule = memoize(() => {
+	const RawModule = require("./RawModule");
+
 	const module = new RawModule("/* (ignored) */", "ignored", "(ignored)");
 	module.factoryMeta = { sideEffectFree: true };
 	return module;

package/lib/Module.js

@@ -115,9 +115,10 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {boolean=} strictHarmonyModule
  * @property {boolean=} async
  * @property {boolean=} sideEffectFree
- * @property {Record<string, string>=} exportsFinalName
  * @property {boolean=} isCSSModule
  * @property {Record<string, string>=} jsIncompatibleExports
+ * @property {Record<string, string>=} exportsFinalName
+ * @property {string=} factoryExportsBinding
  */
 
 /**

package/lib/ModuleGraph.js

@@ -8,10 +8,10 @@
 const util = require("util");
 const ExportsInfo = require("./ExportsInfo");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
+const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
 const SortableSet = require("./util/SortableSet");
 const WeakTupleMap = require("./util/WeakTupleMap");
 const { sortWithSourceOrder } = require("./util/comparators");
-const memoize = require("./util/memoize");
 
 /** @typedef {import("./Compilation").ModuleMemCaches} ModuleMemCaches */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
@@ -25,10 +25,6 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
 /** @typedef {import("./util/comparators").DependencySourceOrder} DependencySourceOrder */
 
-const getCommonJsSelfReferenceDependency = memoize(() =>
-	require("./dependencies/CommonJsSelfReferenceDependency")
-);
-
 /**
  * @callback OptimizationBailoutFunction
  * @param {RequestShortener} requestShortener
@@ -38,66 +34,51 @@ const getCommonJsSelfReferenceDependency = memoize(() =>
 const EMPTY_SET = new Set();
 
 /**
+ * @template {Module | null | undefined} T
  * @param {SortableSet<ModuleGraphConnection>} set input
- * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by origin module
+ * @param {(connection: ModuleGraphConnection) => T} getKey function to extract key from connection
+ * @returns {readonly Map<T, readonly ModuleGraphConnection[]>} mapped by key
  */
-const getConnectionsByOriginModule = (set) => {
+const getConnectionsByKey = (set, getKey) => {
 	const map = new Map();
-	/** @type {Module | 0} */
-	let lastModule = 0;
+	/** @type {T | 0} */
+	let lastKey = 0;
 	/** @type {ModuleGraphConnection[] | undefined} */
 	let lastList;
 	for (const connection of set) {
-		const { originModule } = connection;
-		if (lastModule === originModule) {
+		const key = getKey(connection);
+		if (lastKey === key) {
 			/** @type {ModuleGraphConnection[]} */
 			(lastList).push(connection);
 		} else {
-			lastModule = /** @type {Module} */ (originModule);
-			const list = map.get(originModule);
+			lastKey = key;
+			const list = map.get(key);
 			if (list !== undefined) {
 				lastList = list;
 				list.push(connection);
 			} else {
 				const list = [connection];
 				lastList = list;
-				map.set(originModule, list);
+				map.set(key, list);
 			}
 		}
 	}
 	return map;
 };
 
+/**
+ * @param {SortableSet<ModuleGraphConnection>} set input
+ * @returns {readonly Map<Module | undefined | null, readonly ModuleGraphConnection[]>} mapped by origin module
+ */
+const getConnectionsByOriginModule = (set) =>
+	getConnectionsByKey(set, (connection) => connection.originModule);
+
 /**
  * @param {SortableSet<ModuleGraphConnection>} set input
  * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by module
  */
-const getConnectionsByModule = (set) => {
-	const map = new Map();
-	/** @type {Module | 0} */
-	let lastModule = 0;
-	/** @type {ModuleGraphConnection[] | undefined} */
-	let lastList;
-	for (const connection of set) {
-		const { module } = connection;
-		if (lastModule === module) {
-			/** @type {ModuleGraphConnection[]} */
-			(lastList).push(connection);
-		} else {
-			lastModule = module;
-			const list = map.get(module);
-			if (list !== undefined) {
-				lastList = list;
-				list.push(connection);
-			} else {
-				const list = [connection];
-				lastList = list;
-				map.set(module, list);
-			}
-		}
-	}
-	return map;
-};
+const getConnectionsByModule = (set) =>
+	getConnectionsByKey(set, (connection) => connection.module);
 
 /** @typedef {SortableSet<ModuleGraphConnection>} IncomingConnections */
 /** @typedef {SortableSet<ModuleGraphConnection>} OutgoingConnections */
@@ -845,7 +826,7 @@ class ModuleGraph {
 		for (const connection of connections) {
 			if (
 				!connection.dependency ||
-				connection.dependency instanceof getCommonJsSelfReferenceDependency()
+				!(connection.dependency instanceof HarmonyImportDependency)
 			) {
 				continue;
 			}

package/lib/ModuleTemplate.js

@@ -18,6 +18,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ModuleRenderContext}  ModuleRenderContext */
 /** @typedef {import("./util/Hash")} Hash */
 
 /**
@@ -44,7 +45,7 @@ class ModuleTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {(source: Source, module: Module, chunkRenderContext: ChunkRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
+					 * @param {(source: Source, module: Module, moduleRenderContext: ModuleRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -69,7 +70,7 @@ class ModuleTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {(source: Source, module: Module, chunkRenderContext: ChunkRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
+					 * @param {(source: Source, module: Module, moduleRenderContext: ModuleRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()

package/lib/Watching.js

@@ -187,8 +187,6 @@ class Watching {
 
 					const compilation = /** @type {Compilation} */ (_compilation);
 
-					if (this.invalid) return this._done(null, compilation);
-
 					if (this.compiler.hooks.shouldEmit.call(compilation) === false) {
 						return this._done(null, compilation);
 					}

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -18,6 +18,8 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ModuleId} ModuleId */
 
 class HarmonyAcceptDependency extends NullDependency {
 	/**
@@ -84,7 +86,57 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 			chunkGraph
 		} = templateContext;
 
-		/** @type {HarmonyAcceptImportDependency[]} */
+		/**
+		 * @param {Dependency} dependency the dependency to get module id for
+		 * @returns {ModuleId | null} the module id or null if not found
+		 */
+		const getDependencyModuleId = (dependency) =>
+			chunkGraph.getModuleId(
+				/** @type {Module} */ (moduleGraph.getModule(dependency))
+			);
+
+		/**
+		 * @param {Dependency} a the first dependency
+		 * @param {Dependency} b the second dependency
+		 * @returns {boolean} true if the dependencies are related
+		 */
+		const isRelatedHarmonyImportDependency = (a, b) =>
+			a !== b &&
+			b instanceof HarmonyImportDependency &&
+			getDependencyModuleId(a) === getDependencyModuleId(b);
+
+		/**
+		 * HarmonyAcceptImportDependency lacks a lot of information, such as the defer property.
+		 * One HarmonyAcceptImportDependency may need to generate multiple ImportStatements.
+		 * Therefore, we find its original HarmonyImportDependency for code generation.
+		 * @param {HarmonyAcceptImportDependency} dependency the dependency to get harmony import dependencies for
+		 * @returns {HarmonyImportDependency[]} array of related harmony import dependencies
+		 */
+		const getHarmonyImportDependencies = (dependency) => {
+			const result = [];
+			let deferDependency = null;
+			let noDeferredDependency = null;
+
+			for (const d of module.dependencies) {
+				if (deferDependency && noDeferredDependency) break;
+				if (isRelatedHarmonyImportDependency(dependency, d)) {
+					if (d.defer) {
+						deferDependency = /** @type {HarmonyImportDependency} */ (d);
+					} else {
+						noDeferredDependency = /** @type {HarmonyImportDependency} */ (d);
+					}
+				}
+			}
+			if (deferDependency) result.push(deferDependency);
+			if (noDeferredDependency) result.push(noDeferredDependency);
+			if (result.length === 0) {
+				// fallback to the original dependency
+				result.push(dependency);
+			}
+			return result;
+		};
+
+		/** @type {HarmonyImportDependency[]} */
 		const syncDeps = [];
 
 		/** @type {HarmonyAcceptImportDependency[]} */
@@ -96,7 +148,7 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 			if (connection && moduleGraph.isAsync(connection.module)) {
 				asyncDeps.push(dependency);
 			} else {
-				syncDeps.push(dependency);
+				syncDeps.push(...getHarmonyImportDependencies(dependency));
 			}
 		}
 

package/lib/dependencies/JsonExportsDependency.js

@@ -55,7 +55,12 @@ const getExportsWithDepth = (exportsDepth) =>
 				exports.push({
 					name: key,
 					canMangle: true,
-					exports: getExportsFromData(data[key], curDepth + 1) || undefined
+					exports:
+						getExportsFromData(
+							/** @type {JsonValue} */
+							(data[key]),
+							curDepth + 1
+						) || undefined
 				});
 			}
 

package/lib/dependencies/ModuleDependency.js

@@ -7,7 +7,6 @@
 
 const Dependency = require("../Dependency");
 const DependencyTemplate = require("../DependencyTemplate");
-const RawModule = require("../RawModule");
 
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../Module")} Module */
@@ -61,6 +60,8 @@ class ModuleDependency extends Dependency {
 	 * @returns {Module} ignored module
 	 */
 	createIgnoredModule(context) {
+		const RawModule = require("../RawModule");
+
 		const module = new RawModule(
 			"/* (ignored) */",
 			`ignored|${context}|${this.request}`,

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -6,6 +6,10 @@
 
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+// CompatibilityPlugin renames `__webpack_require__` but doesn’t account for `export { __webpack_require__ }`, so we create a temporary variable to handle it.
+const EXPORT_TEMP_NAME = "__webpack_require_temp__";
 
 class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	constructor() {
@@ -23,7 +27,10 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		return `export default ${RuntimeGlobals.require};`;
+		return Template.asString([
+			`var ${EXPORT_TEMP_NAME} = ${RuntimeGlobals.require};`,
+			`export { ${EXPORT_TEMP_NAME} as ${RuntimeGlobals.require} };`
+		]);
 	}
 }
 

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -8,13 +8,16 @@
 const { ConcatSource } = require("webpack-sources");
 const { HotUpdateChunk, RuntimeGlobals } = require("..");
 const Template = require("../Template");
+const {
+	createChunkHashHandler,
+	getChunkInfo
+} = require("../javascript/ChunkFormatHelpers");
 const { getAllChunks } = require("../javascript/ChunkHelpers");
 const {
 	chunkHasJs,
 	getChunkFilenameTemplate,
 	getCompilationHooks
 } = require("../javascript/JavascriptModulesPlugin");
-const { updateHashForEntryStartup } = require("../javascript/StartupHelpers");
 const { getUndoPath } = require("../util/identifier");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -27,28 +30,6 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 
-/**
- * Gets information about a chunk including its entries and runtime chunk
- * @param {Chunk} chunk The chunk to get information for
- * @param {ChunkGraph} chunkGraph The chunk graph containing the chunk
- * @returns {{entries: Array<[Module, Entrypoint | undefined]>, runtimeChunk: Chunk|null}} Object containing chunk entries and runtime chunk
- */
-function getChunkInfo(chunk, chunkGraph) {
-	const entries = [
-		...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-	];
-	const runtimeChunk =
-		entries.length > 0
-			? /** @type {Entrypoint[][]} */
-				(entries)[0][1].getRuntimeChunk()
-			: null;
-
-	return {
-		entries,
-		runtimeChunk
-	};
-}
-
 /**
  * @param {Compilation} compilation the compilation instance
  * @param {Chunk} chunk the chunk
@@ -97,7 +78,7 @@ const getRelativePath = (compilation, chunk, runtimeChunk) => {
  * @returns {string} the import source
  */
 function renderChunkImport(compilation, chunk, namedImport, runtimeChunk) {
-	return `import ${namedImport ? `* as ${namedImport}` : RuntimeGlobals.require} from ${JSON.stringify(
+	return `import ${namedImport ? `* as ${namedImport}` : `{ ${RuntimeGlobals.require} }`} from ${JSON.stringify(
 		getRelativePath(compilation, chunk, runtimeChunk || chunk)
 	)};\n`;
 }
@@ -168,27 +149,30 @@ class ModuleChunkFormatPlugin {
 				PLUGIN_NAME,
 				(modules, _lastModule, renderContext) => {
 					const { chunk, chunkGraph } = renderContext;
-					if (!chunk.hasRuntime()) {
-						return modules;
-					}
-					const entryDependentChunks =
-						chunkGraph.getChunkEntryDependentChunksIterable(chunk);
-					const sourceWithDependentChunks = withDependentChunks(
-						/** @type {Set<Chunk>} */ (entryDependentChunks),
-						chunkGraph,
-						chunk
-					);
-					if (!sourceWithDependentChunks) {
-						return modules;
-					}
-					if (modules.size() === 0) {
-						return sourceWithDependentChunks;
+					if (
+						chunkGraph.getNumberOfEntryModules(chunk) > 0 &&
+						chunk.hasRuntime()
+					) {
+						const entryDependentChunks =
+							chunkGraph.getChunkEntryDependentChunksIterable(chunk);
+						const sourceWithDependentChunks = withDependentChunks(
+							/** @type {Set<Chunk>} */ (entryDependentChunks),
+							chunkGraph,
+							chunk
+						);
+						if (!sourceWithDependentChunks) {
+							return modules;
+						}
+						if (modules.size() === 0) {
+							return sourceWithDependentChunks;
+						}
+						const source = new ConcatSource();
+						source.add(sourceWithDependentChunks);
+						source.add("\n");
+						source.add(modules);
+						return source;
 					}
-					const source = new ConcatSource();
-					source.add(sourceWithDependentChunks);
-					source.add("\n");
-					source.add(modules);
-					return source;
+					return modules;
 				}
 			);
 			hooks.renderChunk.tap(PLUGIN_NAME, (modules, renderContext) => {
@@ -238,9 +222,6 @@ class ModuleChunkFormatPlugin {
 						}
 						const final = i + 1 === entries.length;
 						const moduleId = chunkGraph.getModuleId(module);
-						const entryDependentChunks = /** @type {Set<Chunk>} */ (
-							chunkGraph.getChunkEntryDependentChunksIterable(chunk)
-						);
 						const chunks = getAllChunks(
 							/** @type {Entrypoint} */ (entrypoint),
 							/** @type {Chunk} */ (runtimeChunk),
@@ -248,10 +229,7 @@ class ModuleChunkFormatPlugin {
 						);
 						const processChunks = new Set();
 						for (const _chunk of chunks) {
-							if (
-								loadedChunks.has(_chunk) ||
-								entryDependentChunks.has(_chunk)
-							) {
+							if (loadedChunks.has(_chunk)) {
 								continue;
 							}
 							loadedChunks.add(_chunk);
@@ -287,19 +265,7 @@ class ModuleChunkFormatPlugin {
 				}
 				return source;
 			});
-			hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash, { chunkGraph }) => {
-				if (chunk.hasRuntime()) return;
-				const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
-				hash.update(PLUGIN_NAME);
-				hash.update("1");
-				if (runtimeChunk && runtimeChunk.hash) {
-					// Any change to runtimeChunk should trigger a hash update,
-					// we shouldn't depend on or inspect its internal implementation.
-					// import __webpack_require__ from "./runtime-main.e9400aee33633a3973bd.js";
-					hash.update(runtimeChunk.hash);
-				}
-				updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
-			});
+			hooks.chunkHash.tap(PLUGIN_NAME, createChunkHashHandler(PLUGIN_NAME));
 		});
 	}
 }

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -71,11 +71,8 @@ class ModuleChunkLoadingPlugin {
 				.tap(PLUGIN_NAME, handler);
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.externalInstallChunk)
-				.tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
+				.tap(PLUGIN_NAME, (chunk) => {
 					if (!isEnabledForChunk(chunk)) return;
-					// If a chunk contains an entryModule, all exports are determined by the entryModule.
-					// The ExportWebpackRequireRuntimeModule is for internal use only and not exposed to users.
-					if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return;
 					compilation.addRuntimeModule(
 						chunk,
 						new ExportWebpackRequireRuntimeModule()

package/lib/index.js

@@ -56,6 +56,9 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Parser").ParserState} ParserState */
 /** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
 /** @typedef {import("./ResolverFactory").Resolver} Resolver */
+/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
+/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./Watching")} Watching */
 /** @typedef {import("./cli").Argument} Argument */
 /** @typedef {import("./cli").Problem} Problem */
@@ -75,6 +78,8 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 
@@ -288,6 +293,9 @@ module.exports = mergeExports(fn, {
 	get Module() {
 		return require("./Module");
 	},
+	get ModuleFactory() {
+		return require("./ModuleFactory");
+	},
 	get ModuleFilenameHelpers() {
 		return require("./ModuleFilenameHelpers");
 	},