Framework updates

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

node_modules/webpack/lib/CleanPlugin.js

@@ -369,6 +369,7 @@ class CleanPlugin {
 	/** @param {CleanOptions} options options */
 	constructor(options = {}) {
 		validate(options);
+		/** @type {CleanOptions & { dry: boolean }} */
 		this.options = { dry: false, ...options };
 	}
 

node_modules/webpack/lib/Compilation.js

@@ -4019,7 +4019,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 * @param {string | ChunkGroupOptions} groupOptions options for the chunk group
 	 * @param {Module=} module the module the references the chunk group
 	 * @param {DependencyLocation=} loc the location from with the chunk group is referenced (inside of module)
-	 * @param {string=} request the request from which the the chunk group is referenced
+	 * @param {string=} request the request from which the chunk group is referenced
 	 * @returns {ChunkGroup} the new or existing chunk group
 	 */
 	addChunkInGroup(groupOptions, module, loc, request) {
@@ -4067,7 +4067,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 * @param {EntryOptions} options options for the entrypoint
 	 * @param {Module} module the module the references the chunk group
 	 * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)
-	 * @param {string} request the request from which the the chunk group is referenced
+	 * @param {string} request the request from which the chunk group is referenced
 	 * @returns {Entrypoint} the new or existing entrypoint
 	 */
 	addAsyncEntrypoint(options, module, loc, request) {
@@ -4531,12 +4531,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					(e) => e.chunks[e.chunks.length - 1]
 				)
 			)) {
-				const otherInfo =
-					/** @type {RuntimeChunkInfo} */
-					(runtimeChunksMap.get(other));
-				otherInfo.referencedBy.push(info);
-				info.remaining++;
-				remaining++;
+				const otherInfo = runtimeChunksMap.get(other);
+				// other may be a non-runtime chunk (e.g. worker chunk)
+				// when you have a worker chunk in your app.js (new Worker(...)) and as a separate entry point
+				if (otherInfo) {
+					otherInfo.referencedBy.push(info);
+					info.remaining++;
+					remaining++;
+				}
 			}
 		}
 		/** @type {Chunk[]} */

node_modules/webpack/lib/ContextModule.js

@@ -119,6 +119,7 @@ const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {Record<ModuleId, FakeMapType>} FakeMap */
 /** @typedef {Record<string, ModuleId>} UserRequestMap */
+/** @typedef {Record<ModuleId, ModuleId[]>} UserRequestsMap */
 
 class ContextModule extends Module {
 	/**
@@ -711,7 +712,7 @@ class ContextModule extends Module {
 	/**
 	 * @param {Dependency[]} dependencies all dependencies
 	 * @param {ChunkGraph} chunkGraph chunk graph
-	 * @returns {Map<string, ModuleId[] | undefined>} map with user requests
+	 * @returns {UserRequestsMap} map with user requests
 	 */
 	getModuleDeferredAsyncDepsMap(dependencies, chunkGraph) {
 		const moduleGraph = chunkGraph.moduleGraph;
@@ -726,6 +727,7 @@ class ContextModule extends Module {
 			)
 			.filter(Boolean)
 			.sort(comparator);
+		/** @type {UserRequestsMap} */
 		const map = Object.create(null);
 		for (const module of sortedModules) {
 			if (!(/** @type {BuildMeta} */ (module.buildMeta).async)) {
@@ -740,7 +742,7 @@ class ContextModule extends Module {
 	}
 
 	/**
-	 * @param {false | Map<string, ModuleId[] | undefined>} asyncDepsMap fake map
+	 * @param {false | UserRequestsMap} asyncDepsMap fake map
 	 * @returns {string} async deps map init statement
 	 */
 	getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap) {
@@ -1168,12 +1170,16 @@ function webpackAsyncContext(req) {
 	])});
 }`
 				: `function webpackAsyncContext(req) {
-	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-		return Promise.resolve().then(${runtimeTemplate.basicFunction("", [
-			'var e = new Error("Cannot find module \'" + req + "\'");',
-			"e.code = 'MODULE_NOT_FOUND';",
-			"throw e;"
-		])});
+	try {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			return Promise.resolve().then(${runtimeTemplate.basicFunction("", [
+				'var e = new Error("Cannot find module \'" + req + "\'");',
+				"e.code = 'MODULE_NOT_FOUND';",
+				"throw e;"
+			])});
+		}
+	} catch(err) {
+		return Promise.reject(err);
 	}
 
 	var ids = map[req], id = ids[0];

node_modules/webpack/lib/Dependency.js

@@ -227,7 +227,7 @@ class Dependency {
 	 */
 	getReference(moduleGraph) {
 		throw new Error(
-			"Dependency.getReference was removed in favor of Dependency.getReferencedExports, ModuleGraph.getModule and ModuleGraph.getConnection().active"
+			"Dependency.getReference was removed in favor of Dependency.getReferencedExports, ModuleGraph.getModule, ModuleGraph.getConnection(), and ModuleGraphConnection.getActiveState(runtime)"
 		);
 	}
 

node_modules/webpack/lib/EnvironmentNotSupportAsyncWarning.js

@@ -26,6 +26,7 @@ As a result, the code may not run as expected or may cause runtime errors.`;
 
 		/** @type {string} */
 		this.name = "EnvironmentNotSupportAsyncWarning";
+		/** @type {Module} */
 		this.module = module;
 	}
 

node_modules/webpack/lib/EvalDevToolModulePlugin.js

@@ -43,8 +43,11 @@ class EvalDevToolModulePlugin {
 	 * @param {EvalDevToolModulePluginOptions=} options options
 	 */
 	constructor(options = {}) {
+		/** @type {DevtoolNamespace} */
 		this.namespace = options.namespace || "";
+		/** @type {string} */
 		this.sourceUrlComment = options.sourceUrlComment || "\n//# sourceURL=[url]";
+		/** @type {DevtoolModuleFilenameTemplate} */
 		this.moduleFilenameTemplate =
 			options.moduleFilenameTemplate ||
 			"webpack://[namespace]/[resourcePath]?[loaders]";

node_modules/webpack/lib/EvalSourceMapDevToolPlugin.js

@@ -17,10 +17,13 @@ const { makePathsAbsolute } = require("./util/identifier");
 
 /** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").DevtoolNamespace} DevtoolNamespace */
+/** @typedef {import("../declarations/WebpackOptions").DevtoolModuleFilenameTemplate} DevtoolModuleFilenameTemplate */
 /** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
 /** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").Rules} Rules */
-/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
+/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 
 /** @type {WeakMap<Source, Source>} */
 const cache = new WeakMap();
@@ -51,14 +54,18 @@ class EvalSourceMapDevToolPlugin {
 		} else {
 			options = inputOptions;
 		}
+		/** @type {string} */
 		this.sourceMapComment =
 			options.append && typeof options.append !== "function"
 				? options.append
 				: "//# sourceURL=[module]\n//# sourceMappingURL=[url]";
+		/** @type {DevtoolModuleFilenameTemplate} */
 		this.moduleFilenameTemplate =
 			options.moduleFilenameTemplate ||
 			"webpack://[namespace]/[resource-path]?[hash]";
+		/** @type {DevtoolNamespace} */
 		this.namespace = options.namespace || "";
+		/** @type {SourceMapDevToolPluginOptions} */
 		this.options = options;
 	}
 

node_modules/webpack/lib/ExportsInfo.js

@@ -933,36 +933,6 @@ class ExportInfo {
 		this._maxTarget = undefined;
 	}
 
-	// TODO webpack 5 remove
-	/**
-	 * @private
-	 * @param {EXPECTED_ANY} v v
-	 */
-	set used(v) {
-		throw new Error("REMOVED");
-	}
-
-	// TODO webpack 5 remove
-	/** @private */
-	get used() {
-		throw new Error("REMOVED");
-	}
-
-	// TODO webpack 5 remove
-	/**
-	 * @private
-	 * @param {EXPECTED_ANY} v v
-	 */
-	set usedName(v) {
-		throw new Error("REMOVED");
-	}
-
-	// TODO webpack 5 remove
-	/** @private */
-	get usedName() {
-		throw new Error("REMOVED");
-	}
-
 	get canMangle() {
 		switch (this.canMangleProvide) {
 			case undefined:

node_modules/webpack/lib/ExternalModule.js

@@ -995,7 +995,7 @@ class ExternalModule extends Module {
 				);
 				/** @type {CodeGenerationResultData} */
 				const data = new Map();
-				data.set("url", { javascript: request });
+				data.set("url", { javascript: /** @type {string} */ (request) });
 				return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data };
 			}
 			case "css-url": {
@@ -1003,7 +1003,7 @@ class ExternalModule extends Module {
 				const sources = new Map();
 				/** @type {CodeGenerationResultData} */
 				const data = new Map();
-				data.set("url", { "css-url": request });
+				data.set("url", { "css-url": /** @type {string} */ (request) });
 				return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data };
 			}
 			case "css-import": {

node_modules/webpack/lib/Module.js

@@ -80,6 +80,8 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {KnownSourceType | string} SourceType */
 /** @typedef {ReadonlySet<SourceType>} SourceTypes */
 
+/** @typedef {ReadonlySet<typeof JAVASCRIPT_TYPE | string>} BasicSourceTypes */
+
 // TODO webpack 6: compilation will be required in CodeGenerationContext
 /**
  * @typedef {object} CodeGenerationContext
@@ -104,11 +106,36 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {Set<string>} RuntimeRequirements */
 /** @typedef {ReadonlySet<string>} ReadOnlyRuntimeRequirements */
 
-/** @typedef {Map<"topLevelDeclarations", Set<string>> & Map<"chunkInitFragments", InitFragment<EXPECTED_ANY>[]>} KnownCodeGenerationResultDataForJavascriptModules */
-/** @typedef {Map<"url", { ["css-url"]: string }>} KnownCodeGenerationResultDataForCssModules */
-/** @typedef {Map<"filename", string> & Map<"assetInfo", AssetInfo> & Map<"fullContentHash", string> & Map<"url", { javascript: string }>} KnownCodeGenerationResultDataForAssetModules */
-/** @typedef {Map<"share-init", [{ shareScope: string, initStage: number, init: string }]>} KnownCodeGenerationResultForSharing */
-/** @typedef {KnownCodeGenerationResultDataForJavascriptModules & KnownCodeGenerationResultDataForCssModules & KnownCodeGenerationResultDataForAssetModules & KnownCodeGenerationResultForSharing & Map<string, EXPECTED_ANY>} CodeGenerationResultData */
+/**
+ * @typedef {object} AllCodeGenerationSchemas
+ * @property {Set<string>} topLevelDeclarations top level declarations for javascript modules
+ * @property {InitFragment<EXPECTED_ANY>[]} chunkInitFragments chunk init fragments for javascript modules
+ * @property {{ javascript?: string, ["css-url"]?: string }} url url for css and javascript modules
+ * @property {string} filename a filename for asset modules
+ * @property {AssetInfo} assetInfo an asset info for asset modules
+ * @property {string} fullContentHash a full content hash for asset modules
+ * @property {[{ shareScope: string, initStage: number, init: string }]} share-init share-init for modules federation
+ */
+
+/* eslint-disable jsdoc/type-formatting */
+/**
+ * @template {string} K
+ * @typedef {K extends keyof AllCodeGenerationSchemas ? AllCodeGenerationSchemas[K] : EXPECTED_ANY} CodeGenValue
+ */
+/* eslint-enable jsdoc/type-formatting */
+
+/* eslint-disable jsdoc/require-template */
+/**
+ * @typedef {object} CodeGenMapOverloads
+ * @property {<K extends string>(key: K) => CodeGenValue<K> | undefined} get
+ * @property {<K extends string>(key: K, value: CodeGenValue<K>) => CodeGenerationResultData} set
+ * @property {<K extends string>(key: K) => boolean} has
+ * @property {<K extends string>(key: K) => boolean} delete
+ */
+
+/**
+ * @typedef {Omit<Map<string, EXPECTED_ANY>, "get" | "set" | "has" | "delete"> & CodeGenMapOverloads} CodeGenerationResultData
+ */
 
 /** @typedef {Map<SourceType, Source>} Sources */
 
@@ -941,6 +968,19 @@ class Module extends DependenciesBlock {
 		return JAVASCRIPT_TYPES;
 	}
 
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 *
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 * @returns {BasicSourceTypes} types available (do not mutate)
+	 */
+	getSourceBasicTypes() {
+		return this.getSourceTypes();
+	}
+
 	/**
 	 * @abstract
 	 * @deprecated Use codeGeneration() instead

node_modules/webpack/lib/ModuleGraphConnection.js

@@ -184,15 +184,6 @@ class ModuleGraphConnection {
 		this.conditional = false;
 		this._active = value;
 	}
-
-	// TODO webpack 5 remove
-	get active() {
-		throw new Error("Use getActiveState instead");
-	}
-
-	set active(value) {
-		throw new Error("Use setActive instead");
-	}
 }
 
 /** @typedef {typeof TRANSITIVE_ONLY} TRANSITIVE_ONLY */

node_modules/webpack/lib/MultiStats.js

@@ -8,6 +8,7 @@
 const identifierUtils = require("./util/identifier");
 
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../declarations/WebpackOptions").StatsValue} StatsValue */
 /** @typedef {import("./Compilation").CreateStatsOptionsContext} CreateStatsOptionsContext */
 /** @typedef {import("./Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
 /** @typedef {import("./Stats")} Stats */
@@ -25,8 +26,7 @@ const indent = (str, prefix) => {
 	return prefix + rem;
 };
 
-/** @typedef {undefined | string | boolean | StatsOptions} ChildrenStatsOptions */
-/** @typedef {Omit<StatsOptions, "children"> & { children?: ChildrenStatsOptions | ChildrenStatsOptions[] }} MultiStatsOptions */
+/** @typedef {StatsOptions} MultiStatsOptions */
 /** @typedef {{ version: boolean, hash: boolean, errorsCount: boolean, warningsCount: boolean, errors: boolean, warnings: boolean, children: NormalizedStatsOptions[] }} ChildOptions */
 
 class MultiStats {
@@ -56,7 +56,7 @@ class MultiStats {
 	}
 
 	/**
-	 * @param {undefined | string | boolean | MultiStatsOptions} options stats options
+	 * @param {undefined | StatsValue} options stats options
 	 * @param {CreateStatsOptionsContext} context context
 	 * @returns {ChildOptions} context context
 	 */
@@ -109,7 +109,7 @@ class MultiStats {
 	}
 
 	/**
-	 * @param {(string | boolean | MultiStatsOptions)=} options stats options
+	 * @param {StatsValue=} options stats options
 	 * @returns {StatsCompilation} json output
 	 */
 	toJson(options) {
@@ -184,7 +184,7 @@ class MultiStats {
 	}
 
 	/**
-	 * @param {(string | boolean | MultiStatsOptions)=} options stats options
+	 * @param {StatsValue=} options stats options
 	 * @returns {string} string output
 	 */
 	toString(options) {

node_modules/webpack/lib/RuntimeModule.js

@@ -8,7 +8,10 @@
 const { RawSource } = require("webpack-sources");
 const OriginalSource = require("webpack-sources").OriginalSource;
 const Module = require("./Module");
-const { RUNTIME_TYPES } = require("./ModuleSourceTypeConstants");
+const {
+	JAVASCRIPT_TYPES,
+	RUNTIME_TYPES
+} = require("./ModuleSourceTypeConstants");
 const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
 
 /** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
@@ -29,6 +32,7 @@ const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./Module").BasicSourceTypes} BasicSourceTypes */
 
 class RuntimeModule extends Module {
 	/**
@@ -138,6 +142,19 @@ class RuntimeModule extends Module {
 		return RUNTIME_TYPES;
 	}
 
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 *
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 * @returns {BasicSourceTypes} types available (do not mutate)
+	 */
+	getSourceBasicTypes() {
+		return JAVASCRIPT_TYPES;
+	}
+
 	/**
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result

node_modules/webpack/lib/SourceMapDevToolModuleOptionsPlugin.js

@@ -17,6 +17,7 @@ class SourceMapDevToolModuleOptionsPlugin {
 	 * @param {SourceMapDevToolPluginOptions=} options options
 	 */
 	constructor(options = {}) {
+		/** @type {SourceMapDevToolPluginOptions} */
 		this.options = options;
 	}
 

node_modules/webpack/lib/SourceMapDevToolPlugin.js

@@ -19,6 +19,9 @@ const { makePathsAbsolute } = require("./util/identifier");
 
 /** @typedef {import("webpack-sources").MapOptions} MapOptions */
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").DevtoolNamespace} DevtoolNamespace */
+/** @typedef {import("../declarations/WebpackOptions").DevtoolModuleFilenameTemplate} DevtoolModuleFilenameTemplate */
+/** @typedef {import("../declarations/WebpackOptions").DevtoolFallbackModuleFilenameTemplate} DevtoolFallbackModuleFilenameTemplate */
 /** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
 /** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").Rules} Rules */
 /** @typedef {import("./CacheFacade").ItemCacheFacade} ItemCacheFacade */
@@ -140,19 +143,24 @@ class SourceMapDevToolPlugin {
 	constructor(options = {}) {
 		validate(options);
 
-		this.sourceMapFilename = /** @type {string | false} */ (options.filename);
-		/** @type {false | TemplatePath}} */
+		/** @type {undefined | null | false | string} */
+		this.sourceMapFilename = options.filename;
+		/** @type {false | TemplatePath} */
 		this.sourceMappingURLComment =
 			options.append === false
 				? false
 				: // eslint-disable-next-line no-useless-concat
 					options.append || "\n//# source" + "MappingURL=[url]";
+		/** @type {DevtoolModuleFilenameTemplate} */
 		this.moduleFilenameTemplate =
 			options.moduleFilenameTemplate || "webpack://[namespace]/[resourcePath]";
+		/** @type {DevtoolFallbackModuleFilenameTemplate} */
 		this.fallbackModuleFilenameTemplate =
 			options.fallbackModuleFilenameTemplate ||
 			"webpack://[namespace]/[resourcePath]?[hash]";
+		/** @type {DevtoolNamespace} */
 		this.namespace = options.namespace || "";
+		/** @type {SourceMapDevToolPluginOptions} */
 		this.options = options;
 	}
 

node_modules/webpack/lib/Stats.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../declarations/WebpackOptions").StatsValue} StatsValue */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
 
@@ -50,7 +51,7 @@ class Stats {
 	}
 
 	/**
-	 * @param {(string | boolean | StatsOptions)=} options stats options
+	 * @param {StatsValue=} options stats options
 	 * @returns {StatsCompilation} json output
 	 */
 	toJson(options) {
@@ -66,7 +67,7 @@ class Stats {
 	}
 
 	/**
-	 * @param {(string | boolean | StatsOptions)=} options stats options
+	 * @param {StatsValue=} options stats options
 	 * @returns {string} string output
 	 */
 	toString(options) {

node_modules/webpack/lib/WebpackOptionsApply.js

@@ -60,6 +60,7 @@ const URLPlugin = require("./dependencies/URLPlugin");
 const WorkerPlugin = require("./dependencies/WorkerPlugin");
 
 const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
+const JavascriptParser = require("./javascript/JavascriptParser");
 
 const JsonModulesPlugin = require("./json/JsonModulesPlugin");
 
@@ -371,7 +372,9 @@ class WebpackOptionsApply extends OptionsApply {
 
 		new JavascriptModulesPlugin().apply(compiler);
 		new JsonModulesPlugin().apply(compiler);
-		new AssetModulesPlugin().apply(compiler);
+		new AssetModulesPlugin({
+			sideEffectFree: options.experiments.futureDefaults
+		}).apply(compiler);
 
 		if (!options.experiments.outputModule) {
 			if (options.output.module) {
@@ -483,11 +486,18 @@ class WebpackOptionsApply extends OptionsApply {
 			new HttpUriPlugin(httpOptions).apply(compiler);
 		}
 
-		if (options.experiments.deferImport) {
-			const JavascriptParser = require("./javascript/JavascriptParser");
+		if (
+			options.experiments.deferImport &&
+			!(
+				/** @type {typeof JavascriptParser & { __importPhasesExtended?: true }} */
+				(JavascriptParser).__importPhasesExtended
+			)
+		) {
 			const importPhases = require("acorn-import-phases");
 
 			JavascriptParser.extend(importPhases({ source: false }));
+			/** @type {typeof JavascriptParser & { __importPhasesExtended?: true }} */
+			(JavascriptParser).__importPhasesExtended = true;
 		}
 
 		new EntryOptionPlugin().apply(compiler);

node_modules/webpack/lib/asset/AssetModulesPlugin.js

@@ -86,7 +86,19 @@ const getNormalModule = memoize(() => require("../NormalModule"));
 const type = ASSET_MODULE_TYPE;
 const PLUGIN_NAME = "AssetModulesPlugin";
 
+/**
+ * @typedef {object} AssetModulesPluginOptions
+ * @property {boolean=} sideEffectFree
+ */
+
 class AssetModulesPlugin {
+	/**
+	 * @param {AssetModulesPluginOptions} options options
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -112,7 +124,10 @@ class AssetModulesPlugin {
 								/** @type {NormalModuleCreateData} */
 								(createData)
 							);
-							module.factoryMeta = { sideEffectFree: true };
+							if (this.options.sideEffectFree) {
+								module.factoryMeta = { sideEffectFree: true };
+							}
+
 							return module;
 						});
 				}

node_modules/webpack/lib/asset/RawDataUrlModule.js

@@ -42,9 +42,13 @@ class RawDataUrlModule extends Module {
 	 */
 	constructor(url, identifier, readableIdentifier) {
 		super(ASSET_MODULE_TYPE_RAW_DATA_URL, null);
+		/** @type {string} */
 		this.url = url;
+		/** @type {Buffer | undefined} */
 		this.urlBuffer = url ? Buffer.from(url) : undefined;
-		this.identifierStr = identifier || this.url;
+		/** @type {string} */
+		this.identifierStr = identifier;
+		/** @type {string} */
 		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
 	}
 

node_modules/webpack/lib/container/RemoteModule.js

@@ -7,7 +7,10 @@
 
 const { RawSource } = require("webpack-sources");
 const Module = require("../Module");
-const { REMOTE_AND_SHARE_INIT_TYPES } = require("../ModuleSourceTypeConstants");
+const {
+	JAVASCRIPT_TYPES,
+	REMOTE_AND_SHARE_INIT_TYPES
+} = require("../ModuleSourceTypeConstants");
 const { WEBPACK_MODULE_TYPE_REMOTE } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
@@ -34,6 +37,7 @@ const RemoteToExternalDependency = require("./RemoteToExternalDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../Module").BasicSourceTypes} BasicSourceTypes */
 
 const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
 
@@ -137,6 +141,19 @@ class RemoteModule extends Module {
 		return REMOTE_AND_SHARE_INIT_TYPES;
 	}
 
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 *
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 * @returns {BasicSourceTypes} types available (do not mutate)
+	 */
+	getSourceBasicTypes() {
+		return JAVASCRIPT_TYPES;
+	}
+
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {boolean | undefined} strict the importing module is strict

node_modules/webpack/lib/css/CssGenerator.js

@@ -19,7 +19,7 @@ const {
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const CssImportDependency = require("../dependencies/CssImportDependency");
-const EntryDependency = require("../dependencies/EntryDependency");
+const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
 const { getUndoPath } = require("../util/identifier");
 const memoize = require("../util/memoize");
 
@@ -470,22 +470,27 @@ class CssGenerator extends Generator {
 	getTypes(module) {
 		const exportType = /** @type {BuildMeta} */ (module.buildMeta).exportType;
 		const sourceTypes = new Set();
+
 		const connections = this._moduleGraph.getIncomingConnections(module);
 
-		let isEntryModule = false;
 		for (const connection of connections) {
-			if (connection.dependency instanceof EntryDependency) {
-				isEntryModule = true;
-			}
 			if (
 				exportType === "link" &&
 				connection.dependency instanceof CssImportDependency
 			) {
 				continue;
 			}
+
+			// when no hmr required, css module js output contains no sideEffects at all
+			// js sideeffect connection doesn't require js type output
+			if (connection.dependency instanceof HarmonyImportSideEffectDependency) {
+				continue;
+			}
+
 			if (!connection.originModule) {
 				continue;
 			}
+
 			if (connection.originModule.type.split("/")[0] !== CSS_TYPE) {
 				sourceTypes.add(JAVASCRIPT_TYPE);
 			} else {
@@ -503,7 +508,7 @@ class CssGenerator extends Generator {
 			}
 		}
 		if (this._generatesJsOnly(module)) {
-			if (sourceTypes.has(JAVASCRIPT_TYPE) || isEntryModule) {
+			if (sourceTypes.has(JAVASCRIPT_TYPE)) {
 				return JAVASCRIPT_TYPES;
 			}
 			return new Set();
@@ -578,3 +583,5 @@ class CssGenerator extends Generator {
 }
 
 module.exports = CssGenerator;
+
+module.exports = CssGenerator;

node_modules/webpack/lib/css/CssModulesPlugin.js

@@ -386,6 +386,13 @@ class CssModulesPlugin {
 					compilation
 				).renderModuleContent.tap(PLUGIN_NAME, (source, module) => {
 					if (module instanceof CssModule && module.hot) {
+						const exportType = /** @type {BuildMeta} */ (module.buildMeta)
+							.exportType;
+						// When exportType !== "link", modules behave like JavaScript modules
+						if (exportType && exportType !== "link") {
+							return source;
+						}
+						// For exportType === "link", we can optimize with self-acceptance
 						const cssData = /** @type {BuildInfo} */ (module.buildInfo).cssData;
 						if (!cssData) {
 							return source;

node_modules/webpack/lib/dependencies/CommonJsExportRequireDependency.js

@@ -65,6 +65,10 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 		return "cjs export require";
 	}
 
+	get category() {
+		return "commonjs";
+	}
+
 	/**
 	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
 	 */

node_modules/webpack/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -5,13 +5,9 @@
 
 "use strict";
 
-const { fileURLToPath } = require("url");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
-const WebpackError = require("../WebpackError");
-const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
-const { VariableInfo } = require("../javascript/JavascriptParser");
 const {
 	evaluateToIdentifier,
 	evaluateToString,
@@ -36,6 +32,7 @@ const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser").ImportSource} ImportSource */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../javascript/JavascriptParser").Members} Members */
@@ -48,11 +45,300 @@ const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency
  * @property {string} context
  */
 
-const createRequireSpecifierTag = Symbol("createRequire");
-const createdRequireIdentifierTag = Symbol("createRequire()");
-
 const PLUGIN_NAME = "CommonJsImportsParserPlugin";
 
+/**
+ * @param {JavascriptParser} parser parser
+ * @returns {(expr: Expression) => boolean} handler
+ */
+const createRequireCacheDependency = (parser) =>
+	toConstantDependency(parser, RuntimeGlobals.moduleCache, [
+		RuntimeGlobals.moduleCache,
+		RuntimeGlobals.moduleId,
+		RuntimeGlobals.moduleLoaded
+	]);
+
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {JavascriptParserOptions} options options
+ * @param {() => undefined | string} getContext context accessor
+ * @returns {(expr: Expression) => boolean} handler
+ */
+const createRequireAsExpressionHandler =
+	(parser, options, getContext) => (expr) => {
+		const dep = new CommonJsRequireContextDependency(
+			{
+				request: /** @type {string} */ (options.unknownContextRequest),
+				recursive: /** @type {boolean} */ (options.unknownContextRecursive),
+				regExp: /** @type {RegExp} */ (options.unknownContextRegExp),
+				mode: "sync"
+			},
+			/** @type {Range} */ (expr.range),
+			undefined,
+			parser.scope.inShorthand,
+			getContext()
+		);
+		dep.critical =
+			options.unknownContextCritical &&
+			"require function is used in a way in which dependencies cannot be statically extracted";
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		dep.optional = Boolean(parser.scope.inTry);
+		parser.state.current.addDependency(dep);
+		return true;
+	};
+
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {JavascriptParserOptions} options options
+ * @param {() => undefined | string} getContext context accessor
+ * @returns {(callNew: boolean) => (expr: CallExpression | NewExpression) => (boolean | void)} handler factory
+ */
+const createRequireCallHandler = (parser, options, getContext) => {
+	/**
+	 * @param {CallExpression | NewExpression} expr expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | void} true when handled
+	 */
+	const processRequireItem = (expr, param) => {
+		if (param.isString()) {
+			const dep = new CommonJsRequireDependency(
+				/** @type {string} */ (param.string),
+				/** @type {Range} */ (param.range),
+				getContext()
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
+		}
+	};
+	/**
+	 * @param {CallExpression | NewExpression} expr expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | void} true when handled
+	 */
+	const processRequireContext = (expr, param) => {
+		const dep = ContextDependencyHelpers.create(
+			CommonJsRequireContextDependency,
+			/** @type {Range} */ (expr.range),
+			param,
+			expr,
+			options,
+			{
+				category: "commonjs"
+			},
+			parser,
+			undefined,
+			getContext()
+		);
+		if (!dep) return;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		dep.optional = Boolean(parser.scope.inTry);
+		parser.state.current.addDependency(dep);
+		return true;
+	};
+
+	return (callNew) => (expr) => {
+		if (options.commonjsMagicComments) {
+			const { options: requireOptions, errors: commentErrors } =
+				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+			if (commentErrors) {
+				for (const e of commentErrors) {
+					const { comment } = e;
+					parser.state.module.addWarning(
+						new CommentCompilationWarning(
+							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+							/** @type {DependencyLocation} */ (comment.loc)
+						)
+					);
+				}
+			}
+			if (requireOptions && requireOptions.webpackIgnore !== undefined) {
+				if (typeof requireOptions.webpackIgnore !== "boolean") {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+				} else if (requireOptions.webpackIgnore) {
+					// Do not instrument `require()` if `webpackIgnore` is `true`
+					return true;
+				}
+			}
+		}
+
+		if (expr.arguments.length !== 1) return;
+		/** @type {null | LocalModule} */
+		let localModule;
+		const param = parser.evaluateExpression(expr.arguments[0]);
+		if (param.isConditional()) {
+			let isExpression = false;
+			for (const p of /** @type {BasicEvaluatedExpression[]} */ (
+				param.options
+			)) {
+				const result = processRequireItem(expr, p);
+				if (result === undefined) {
+					isExpression = true;
+				}
+			}
+			if (!isExpression) {
+				const dep = new RequireHeaderDependency(
+					/** @type {Range} */ (expr.callee.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		}
+		if (
+			param.isString() &&
+			(localModule = getLocalModule(
+				parser.state,
+				/** @type {string} */ (param.string)
+			))
+		) {
+			localModule.flagUsed();
+			const dep = new LocalModuleDependency(
+				localModule,
+				/** @type {Range} */ (expr.range),
+				callNew
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+		} else {
+			const result = processRequireItem(expr, param);
+			if (result === undefined) {
+				processRequireContext(expr, param);
+			} else {
+				const dep = new RequireHeaderDependency(
+					/** @type {Range} */ (expr.callee.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(dep);
+			}
+		}
+		return true;
+	};
+};
+
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {JavascriptParserOptions} options options
+ * @param {() => undefined | string} getContext context accessor
+ * @returns {(expr: CallExpression, weak: boolean) => (boolean | void)} resolver
+ */
+const createProcessResolveHandler = (parser, options, getContext) => {
+	/**
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @param {boolean} weak weak
+	 * @returns {boolean | void} true when handled
+	 */
+	const processResolveItem = (expr, param, weak) => {
+		if (param.isString()) {
+			const dep = new RequireResolveDependency(
+				/** @type {string} */ (param.string),
+				/** @type {Range} */ (param.range),
+				getContext()
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			dep.weak = weak;
+			parser.state.current.addDependency(dep);
+			return true;
+		}
+	};
+	/**
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @param {boolean} weak weak
+	 * @returns {boolean | void} true when handled
+	 */
+	const processResolveContext = (expr, param, weak) => {
+		const dep = ContextDependencyHelpers.create(
+			RequireResolveContextDependency,
+			/** @type {Range} */ (param.range),
+			param,
+			expr,
+			options,
+			{
+				category: "commonjs",
+				mode: weak ? "weak" : "sync"
+			},
+			parser,
+			getContext()
+		);
+		if (!dep) return;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		dep.optional = Boolean(parser.scope.inTry);
+		parser.state.current.addDependency(dep);
+		return true;
+	};
+
+	return (expr, weak) => {
+		if (!weak && options.commonjsMagicComments) {
+			const { options: requireOptions, errors: commentErrors } =
+				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+			if (commentErrors) {
+				for (const e of commentErrors) {
+					const { comment } = e;
+					parser.state.module.addWarning(
+						new CommentCompilationWarning(
+							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+							/** @type {DependencyLocation} */ (comment.loc)
+						)
+					);
+				}
+			}
+			if (requireOptions && requireOptions.webpackIgnore !== undefined) {
+				if (typeof requireOptions.webpackIgnore !== "boolean") {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+				} else if (requireOptions.webpackIgnore) {
+					// Do not instrument `require()` if `webpackIgnore` is `true`
+					return true;
+				}
+			}
+		}
+
+		if (expr.arguments.length !== 1) return;
+		const param = parser.evaluateExpression(expr.arguments[0]);
+		if (param.isConditional()) {
+			for (const option of /** @type {BasicEvaluatedExpression[]} */ (
+				param.options
+			)) {
+				const result = processResolveItem(expr, option, weak);
+				if (result === undefined) {
+					processResolveContext(expr, option, weak);
+				}
+			}
+			const dep = new RequireResolveHeaderDependency(
+				/** @type {Range} */ (expr.callee.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+		const result = processResolveItem(expr, param, weak);
+		if (result === undefined) {
+			processResolveContext(expr, param, weak);
+		}
+		const dep = new RequireResolveHeaderDependency(
+			/** @type {Range} */ (expr.callee.range)
+		);
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		parser.state.module.addPresentationalDependency(dep);
+		return true;
+	};
+};
+
 class CommonJsImportsParserPlugin {
 	/**
 	 * @param {JavascriptParserOptions} options parser options
@@ -98,20 +384,6 @@ class CommonJsImportsParserPlugin {
 					evaluateToIdentifier(expression, "require", getMembers, true)
 				);
 		};
-		/**
-		 * @param {string | symbol} tag tag
-		 */
-		const tapRequireExpressionTag = (tag) => {
-			parser.hooks.typeof
-				.for(tag)
-				.tap(
-					PLUGIN_NAME,
-					toConstantDependency(parser, JSON.stringify("function"))
-				);
-			parser.hooks.evaluateTypeof
-				.for(tag)
-				.tap(PLUGIN_NAME, evaluateToString("function"));
-		};
 		tapRequireExpression("require", () => []);
 		tapRequireExpression("require.resolve", () => ["resolve"]);
 		tapRequireExpression("require.resolveWeak", () => ["resolveWeak"]);
@@ -176,15 +448,7 @@ class CommonJsImportsParserPlugin {
 		// #endregion
 
 		// #region Inspection
-		const requireCache = toConstantDependency(
-			parser,
-			RuntimeGlobals.moduleCache,
-			[
-				RuntimeGlobals.moduleCache,
-				RuntimeGlobals.moduleId,
-				RuntimeGlobals.moduleLoaded
-			]
-		);
+		const requireCache = createRequireCacheDependency(parser);
 
 		parser.hooks.expression.for("require.cache").tap(PLUGIN_NAME, requireCache);
 		// #endregion
@@ -194,163 +458,26 @@ class CommonJsImportsParserPlugin {
 		 * @param {Expression} expr expression
 		 * @returns {boolean} true when handled
 		 */
-		const requireAsExpressionHandler = (expr) => {
-			const dep = new CommonJsRequireContextDependency(
-				{
-					request: /** @type {string} */ (options.unknownContextRequest),
-					recursive: /** @type {boolean} */ (options.unknownContextRecursive),
-					regExp: /** @type {RegExp} */ (options.unknownContextRegExp),
-					mode: "sync"
-				},
-				/** @type {Range} */ (expr.range),
-				undefined,
-				parser.scope.inShorthand,
-				getContext()
-			);
-			dep.critical =
-				options.unknownContextCritical &&
-				"require function is used in a way in which dependencies cannot be statically extracted";
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-			dep.optional = Boolean(parser.scope.inTry);
-			parser.state.current.addDependency(dep);
-			return true;
-		};
+		const requireAsExpressionHandler = createRequireAsExpressionHandler(
+			parser,
+			options,
+			getContext
+		);
 		parser.hooks.expression
 			.for("require")
 			.tap(PLUGIN_NAME, requireAsExpressionHandler);
 		// #endregion
 
 		// #region Require
-		/**
-		 * @param {CallExpression | NewExpression} expr expression
-		 * @param {BasicEvaluatedExpression} param param
-		 * @returns {boolean | void} true when handled
-		 */
-		const processRequireItem = (expr, param) => {
-			if (param.isString()) {
-				const dep = new CommonJsRequireDependency(
-					/** @type {string} */ (param.string),
-					/** @type {Range} */ (param.range),
-					getContext()
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				dep.optional = Boolean(parser.scope.inTry);
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		};
-		/**
-		 * @param {CallExpression | NewExpression} expr expression
-		 * @param {BasicEvaluatedExpression} param param
-		 * @returns {boolean | void} true when handled
-		 */
-		const processRequireContext = (expr, param) => {
-			const dep = ContextDependencyHelpers.create(
-				CommonJsRequireContextDependency,
-				/** @type {Range} */ (expr.range),
-				param,
-				expr,
-				options,
-				{
-					category: "commonjs"
-				},
-				parser,
-				undefined,
-				getContext()
-			);
-			if (!dep) return;
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-			dep.optional = Boolean(parser.scope.inTry);
-			parser.state.current.addDependency(dep);
-			return true;
-		};
 		/**
 		 * @param {boolean} callNew true, when require is called with new
 		 * @returns {(expr: CallExpression | NewExpression) => (boolean | void)} handler
 		 */
-		const createRequireHandler = (callNew) => (expr) => {
-			if (options.commonjsMagicComments) {
-				const { options: requireOptions, errors: commentErrors } =
-					parser.parseCommentOptions(/** @type {Range} */ (expr.range));
-
-				if (commentErrors) {
-					for (const e of commentErrors) {
-						const { comment } = e;
-						parser.state.module.addWarning(
-							new CommentCompilationWarning(
-								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-								/** @type {DependencyLocation} */ (comment.loc)
-							)
-						);
-					}
-				}
-				if (requireOptions && requireOptions.webpackIgnore !== undefined) {
-					if (typeof requireOptions.webpackIgnore !== "boolean") {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
-							)
-						);
-					} else if (requireOptions.webpackIgnore) {
-						// Do not instrument `require()` if `webpackIgnore` is `true`
-						return true;
-					}
-				}
-			}
-
-			if (expr.arguments.length !== 1) return;
-			/** @type {null | LocalModule} */
-			let localModule;
-			const param = parser.evaluateExpression(expr.arguments[0]);
-			if (param.isConditional()) {
-				let isExpression = false;
-				for (const p of /** @type {BasicEvaluatedExpression[]} */ (
-					param.options
-				)) {
-					const result = processRequireItem(expr, p);
-					if (result === undefined) {
-						isExpression = true;
-					}
-				}
-				if (!isExpression) {
-					const dep = new RequireHeaderDependency(
-						/** @type {Range} */ (expr.callee.range)
-					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addPresentationalDependency(dep);
-					return true;
-				}
-			}
-			if (
-				param.isString() &&
-				(localModule = getLocalModule(
-					parser.state,
-					/** @type {string} */ (param.string)
-				))
-			) {
-				localModule.flagUsed();
-				const dep = new LocalModuleDependency(
-					localModule,
-					/** @type {Range} */ (expr.range),
-					callNew
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				parser.state.module.addPresentationalDependency(dep);
-			} else {
-				const result = processRequireItem(expr, param);
-				if (result === undefined) {
-					processRequireContext(expr, param);
-				} else {
-					const dep = new RequireHeaderDependency(
-						/** @type {Range} */ (expr.callee.range)
-					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addPresentationalDependency(dep);
-				}
-			}
-			return true;
-		};
+		const createRequireHandler = createRequireCallHandler(
+			parser,
+			options,
+			getContext
+		);
 		parser.hooks.call
 			.for("require")
 			.tap(PLUGIN_NAME, createRequireHandler(false));
@@ -460,112 +587,11 @@ class CommonJsImportsParserPlugin {
 		 * @param {boolean} weak weak
 		 * @returns {boolean | void} true when handled
 		 */
-		const processResolve = (expr, weak) => {
-			if (!weak && options.commonjsMagicComments) {
-				const { options: requireOptions, errors: commentErrors } =
-					parser.parseCommentOptions(/** @type {Range} */ (expr.range));
-
-				if (commentErrors) {
-					for (const e of commentErrors) {
-						const { comment } = e;
-						parser.state.module.addWarning(
-							new CommentCompilationWarning(
-								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-								/** @type {DependencyLocation} */ (comment.loc)
-							)
-						);
-					}
-				}
-				if (requireOptions && requireOptions.webpackIgnore !== undefined) {
-					if (typeof requireOptions.webpackIgnore !== "boolean") {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
-							)
-						);
-					} else if (requireOptions.webpackIgnore) {
-						// Do not instrument `require()` if `webpackIgnore` is `true`
-						return true;
-					}
-				}
-			}
-
-			if (expr.arguments.length !== 1) return;
-			const param = parser.evaluateExpression(expr.arguments[0]);
-			if (param.isConditional()) {
-				for (const option of /** @type {BasicEvaluatedExpression[]} */ (
-					param.options
-				)) {
-					const result = processResolveItem(expr, option, weak);
-					if (result === undefined) {
-						processResolveContext(expr, option, weak);
-					}
-				}
-				const dep = new RequireResolveHeaderDependency(
-					/** @type {Range} */ (expr.callee.range)
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				parser.state.module.addPresentationalDependency(dep);
-				return true;
-			}
-			const result = processResolveItem(expr, param, weak);
-			if (result === undefined) {
-				processResolveContext(expr, param, weak);
-			}
-			const dep = new RequireResolveHeaderDependency(
-				/** @type {Range} */ (expr.callee.range)
-			);
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
-		};
-		/**
-		 * @param {CallExpression} expr call expression
-		 * @param {BasicEvaluatedExpression} param param
-		 * @param {boolean} weak weak
-		 * @returns {boolean | void} true when handled
-		 */
-		const processResolveItem = (expr, param, weak) => {
-			if (param.isString()) {
-				const dep = new RequireResolveDependency(
-					/** @type {string} */ (param.string),
-					/** @type {Range} */ (param.range),
-					getContext()
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				dep.optional = Boolean(parser.scope.inTry);
-				dep.weak = weak;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		};
-		/**
-		 * @param {CallExpression} expr call expression
-		 * @param {BasicEvaluatedExpression} param param
-		 * @param {boolean} weak weak
-		 * @returns {boolean | void} true when handled
-		 */
-		const processResolveContext = (expr, param, weak) => {
-			const dep = ContextDependencyHelpers.create(
-				RequireResolveContextDependency,
-				/** @type {Range} */ (param.range),
-				param,
-				expr,
-				options,
-				{
-					category: "commonjs",
-					mode: weak ? "weak" : "sync"
-				},
-				parser,
-				getContext()
-			);
-			if (!dep) return;
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-			dep.optional = Boolean(parser.scope.inTry);
-			parser.state.current.addDependency(dep);
-			return true;
-		};
+		const processResolve = createProcessResolveHandler(
+			parser,
+			options,
+			getContext
+		);
 
 		parser.hooks.call
 			.for("require.resolve")
@@ -574,232 +600,12 @@ class CommonJsImportsParserPlugin {
 			.for("require.resolveWeak")
 			.tap(PLUGIN_NAME, (expr) => processResolve(expr, true));
 		// #endregion
-
-		// #region Create require
-
-		if (!options.createRequire) return;
-
-		/** @type {ImportSource[]} */
-		let moduleName = [];
-		/** @type {string | undefined} */
-		let specifierName;
-
-		if (options.createRequire === true) {
-			moduleName = ["module", "node:module"];
-			specifierName = "createRequire";
-		} else {
-			/** @type {undefined | string} */
-			let moduleName;
-			const match = /^(.*) from (.*)$/.exec(options.createRequire);
-			if (match) {
-				[, specifierName, moduleName] = match;
-			}
-			if (!specifierName || !moduleName) {
-				const err = new WebpackError(
-					`Parsing javascript parser option "createRequire" failed, got ${JSON.stringify(
-						options.createRequire
-					)}`
-				);
-				err.details =
-					'Expected string in format "createRequire from module", where "createRequire" is specifier name and "module" name of the module';
-				throw err;
-			}
-		}
-
-		tapRequireExpressionTag(createdRequireIdentifierTag);
-		tapRequireExpressionTag(createRequireSpecifierTag);
-		parser.hooks.evaluateCallExpression
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, (expr) => {
-				const context = parseCreateRequireArguments(expr);
-				if (context === undefined) return;
-				const ident = parser.evaluatedVariable({
-					tag: createdRequireIdentifierTag,
-					data: { context },
-					next: undefined
-				});
-
-				return new BasicEvaluatedExpression()
-					.setIdentifier(ident, ident, () => [])
-					.setSideEffects(false)
-					.setRange(/** @type {Range} */ (expr.range));
-			});
-		parser.hooks.unhandledExpressionMemberChain
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, (expr, members) =>
-				expressionIsUnsupported(
-					parser,
-					`createRequire().${members.join(".")} is not supported by webpack.`
-				)(expr)
-			);
-		parser.hooks.canRename
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, () => true);
-		parser.hooks.canRename
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, () => true);
-		parser.hooks.rename
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, defineUndefined);
-		parser.hooks.expression
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, requireAsExpressionHandler);
-		parser.hooks.call
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, createRequireHandler(false));
-		/**
-		 * @param {CallExpression} expr call expression
-		 * @returns {string | void} context
-		 */
-		const parseCreateRequireArguments = (expr) => {
-			const args = expr.arguments;
-			if (args.length !== 1) {
-				const err = new WebpackError(
-					"module.createRequire supports only one argument."
-				);
-				err.loc = /** @type {DependencyLocation} */ (expr.loc);
-				parser.state.module.addWarning(err);
-				return;
-			}
-			const arg = args[0];
-			const evaluated = parser.evaluateExpression(arg);
-			if (!evaluated.isString()) {
-				const err = new WebpackError(
-					"module.createRequire failed parsing argument."
-				);
-				err.loc = /** @type {DependencyLocation} */ (arg.loc);
-				parser.state.module.addWarning(err);
-				return;
-			}
-			const ctx = /** @type {string} */ (evaluated.string).startsWith("file://")
-				? fileURLToPath(/** @type {string} */ (evaluated.string))
-				: /** @type {string} */ (evaluated.string);
-			// argument always should be a filename
-			return ctx.slice(0, ctx.lastIndexOf(ctx.startsWith("/") ? "/" : "\\"));
-		};
-
-		parser.hooks.import.tap(
-			{
-				name: PLUGIN_NAME,
-				stage: -10
-			},
-			(statement, source) => {
-				if (
-					!moduleName.includes(source) ||
-					statement.specifiers.length !== 1 ||
-					statement.specifiers[0].type !== "ImportSpecifier" ||
-					statement.specifiers[0].imported.type !== "Identifier" ||
-					statement.specifiers[0].imported.name !== specifierName
-				) {
-					return;
-				}
-				// clear for 'import { createRequire as x } from "module"'
-				// if any other specifier was used import module
-				const clearDep = new ConstDependency(
-					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
-						? ";"
-						: "",
-					/** @type {Range} */ (statement.range)
-				);
-				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
-				parser.state.module.addPresentationalDependency(clearDep);
-				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
-				return true;
-			}
-		);
-		parser.hooks.importSpecifier.tap(
-			{
-				name: PLUGIN_NAME,
-				stage: -10
-			},
-			(statement, source, id, name) => {
-				if (!moduleName.includes(source) || id !== specifierName) return;
-				parser.tagVariable(name, createRequireSpecifierTag);
-				return true;
-			}
-		);
-		parser.hooks.preDeclarator.tap(PLUGIN_NAME, (declarator) => {
-			if (
-				declarator.id.type !== "Identifier" ||
-				!declarator.init ||
-				declarator.init.type !== "CallExpression" ||
-				declarator.init.callee.type !== "Identifier"
-			) {
-				return;
-			}
-			const variableInfo = parser.getVariableInfo(declarator.init.callee.name);
-			if (
-				variableInfo instanceof VariableInfo &&
-				variableInfo.tagInfo &&
-				variableInfo.tagInfo.tag === createRequireSpecifierTag
-			) {
-				const context = parseCreateRequireArguments(declarator.init);
-				if (context === undefined) return;
-				parser.tagVariable(declarator.id.name, createdRequireIdentifierTag, {
-					name: declarator.id.name,
-					context
-				});
-				return true;
-			}
-		});
-
-		parser.hooks.memberChainOfCallMemberChain
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, (expr, calleeMembers, callExpr, members) => {
-				if (
-					calleeMembers.length !== 0 ||
-					members.length !== 1 ||
-					members[0] !== "cache"
-				) {
-					return;
-				}
-				// createRequire().cache
-				const context = parseCreateRequireArguments(callExpr);
-				if (context === undefined) return;
-				return requireCache(expr);
-			});
-		parser.hooks.callMemberChainOfCallMemberChain
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, (expr, calleeMembers, innerCallExpression, members) => {
-				if (
-					calleeMembers.length !== 0 ||
-					members.length !== 1 ||
-					members[0] !== "resolve"
-				) {
-					return;
-				}
-				// createRequire().resolve()
-				return processResolve(expr, false);
-			});
-		parser.hooks.expressionMemberChain
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, (expr, members) => {
-				// require.cache
-				if (members.length === 1 && members[0] === "cache") {
-					return requireCache(expr);
-				}
-			});
-		parser.hooks.callMemberChain
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, (expr, members) => {
-				// require.resolve()
-				if (members.length === 1 && members[0] === "resolve") {
-					return processResolve(expr, false);
-				}
-			});
-		parser.hooks.call
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, (expr) => {
-				const clearDep = new ConstDependency(
-					"/* createRequire() */ undefined",
-					/** @type {Range} */ (expr.range)
-				);
-				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				parser.state.module.addPresentationalDependency(clearDep);
-				return true;
-			});
-		// #endregion
 	}
 }
 
 module.exports = CommonJsImportsParserPlugin;
+module.exports.createProcessResolveHandler = createProcessResolveHandler;
+module.exports.createRequireAsExpressionHandler =
+	createRequireAsExpressionHandler;
+module.exports.createRequireCacheDependency = createRequireCacheDependency;
+module.exports.createRequireHandler = createRequireCallHandler;

node_modules/webpack/lib/dependencies/CreateRequireParserPlugin.js

@@ -0,0 +1,356 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { fileURLToPath } = require("url");
+const WebpackError = require("../WebpackError");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const { VariableInfo } = require("../javascript/JavascriptParser");
+const {
+	evaluateToString,
+	expressionIsUnsupported,
+	toConstantDependency
+} = require("../javascript/JavascriptParserHelpers");
+const CommonJsImportsParserPlugin = require("./CommonJsImportsParserPlugin");
+const ConstDependency = require("./ConstDependency");
+
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ImportSource} ImportSource */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+/**
+ * @typedef {object} CommonJsImportSettings
+ * @property {string=} name
+ * @property {string} context
+ */
+
+const createRequireSpecifierTag = Symbol("createRequire");
+const createdRequireIdentifierTag = Symbol("createRequire()");
+
+const PLUGIN_NAME = "CreateRequireParserPlugin";
+
+const {
+	createProcessResolveHandler,
+	createRequireAsExpressionHandler,
+	createRequireCacheDependency,
+	createRequireHandler
+} = CommonJsImportsParserPlugin;
+
+class CreateRequireParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options parser options
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		const options = this.options;
+		if (!options.createRequire) return;
+
+		const getContext = () => {
+			if (parser.currentTagData) {
+				const { context } =
+					/** @type {CommonJsImportSettings} */
+					(parser.currentTagData);
+				return context;
+			}
+		};
+
+		/**
+		 * @param {string | symbol} tag tag
+		 */
+		const tapRequireExpressionTag = (tag) => {
+			parser.hooks.typeof
+				.for(tag)
+				.tap(
+					PLUGIN_NAME,
+					toConstantDependency(parser, JSON.stringify("function"))
+				);
+			parser.hooks.evaluateTypeof
+				.for(tag)
+				.tap(PLUGIN_NAME, evaluateToString("function"));
+		};
+
+		/**
+		 * @param {Expression} expr expression
+		 * @returns {boolean} true when set undefined
+		 */
+		const defineUndefined = (expr) => {
+			const dep = new ConstDependency(
+				"undefined",
+				/** @type {Range} */ (expr.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+			return false;
+		};
+
+		const requireCache = createRequireCacheDependency(parser);
+		const requireAsExpressionHandler = createRequireAsExpressionHandler(
+			parser,
+			options,
+			getContext
+		);
+		const createRequireCallHandler = createRequireHandler(
+			parser,
+			options,
+			getContext
+		);
+		const processResolve = createProcessResolveHandler(
+			parser,
+			options,
+			getContext
+		);
+
+		/** @type {ImportSource[]} */
+		let moduleNames = [];
+		/** @type {string | undefined} */
+		let specifierName;
+
+		if (options.createRequire === true) {
+			moduleNames = ["module", "node:module"];
+			specifierName = "createRequire";
+		} else if (typeof options.createRequire === "string") {
+			/** @type {undefined | string} */
+			let parsedModuleName;
+			const match = /^(.*) from (.*)$/.exec(options.createRequire);
+			if (match) {
+				[, specifierName, parsedModuleName] = match;
+			}
+			if (!specifierName || !parsedModuleName) {
+				const err = new WebpackError(
+					`Parsing javascript parser option "createRequire" failed, got ${JSON.stringify(
+						options.createRequire
+					)}`
+				);
+				err.details =
+					'Expected string in format "createRequire from module", where "createRequire" is specifier name and "module" name of the module';
+				throw err;
+			}
+			moduleNames = [parsedModuleName];
+		} else {
+			return;
+		}
+
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @returns {string | void} context
+		 */
+		const parseCreateRequireArguments = (expr) => {
+			const args = expr.arguments;
+			if (args.length !== 1) {
+				const err = new WebpackError(
+					"module.createRequire supports only one argument."
+				);
+				err.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addWarning(err);
+				return;
+			}
+			const arg = args[0];
+			const evaluated = parser.evaluateExpression(arg);
+			if (!evaluated.isString()) {
+				const err = new WebpackError(
+					"module.createRequire failed parsing argument."
+				);
+				err.loc = /** @type {DependencyLocation} */ (arg.loc);
+				parser.state.module.addWarning(err);
+				return;
+			}
+			const ctx = /** @type {string} */ (evaluated.string).startsWith("file://")
+				? fileURLToPath(/** @type {string} */ (evaluated.string))
+				: /** @type {string} */ (evaluated.string);
+			// argument always should be a filename
+			return ctx.slice(0, ctx.lastIndexOf(ctx.startsWith("/") ? "/" : "\\"));
+		};
+
+		tapRequireExpressionTag(createdRequireIdentifierTag);
+		tapRequireExpressionTag(createRequireSpecifierTag);
+
+		parser.hooks.evaluateCallExpression
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr) => {
+				const context = parseCreateRequireArguments(expr);
+				if (context === undefined) return;
+				const ident = parser.evaluatedVariable({
+					tag: createdRequireIdentifierTag,
+					data: { context },
+					next: undefined
+				});
+
+				return new BasicEvaluatedExpression()
+					.setIdentifier(ident, ident, () => [])
+					.setSideEffects(false)
+					.setRange(/** @type {Range} */ (expr.range));
+			});
+
+		parser.hooks.unhandledExpressionMemberChain
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, (expr, members) =>
+				expressionIsUnsupported(
+					parser,
+					`createRequire().${members.join(".")} is not supported by webpack.`
+				)(expr)
+			);
+		parser.hooks.canRename
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, () => true);
+		parser.hooks.canRename
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, () => true);
+		parser.hooks.rename
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, defineUndefined);
+		parser.hooks.expression
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, requireAsExpressionHandler);
+		parser.hooks.call
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, createRequireCallHandler(false));
+
+		parser.hooks.import.tap(
+			{
+				name: PLUGIN_NAME,
+				stage: -10
+			},
+			(statement, source) => {
+				if (
+					!moduleNames.includes(source) ||
+					statement.specifiers.length !== 1 ||
+					statement.specifiers[0].type !== "ImportSpecifier" ||
+					statement.specifiers[0].imported.type !== "Identifier" ||
+					statement.specifiers[0].imported.name !== specifierName
+				) {
+					return;
+				}
+				// clear for 'import { createRequire as x } from "module"'
+				// if any other specifier was used import module
+				const clearDep = new ConstDependency(
+					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
+						? ";"
+						: "",
+					/** @type {Range} */ (statement.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+				parser.state.module.addPresentationalDependency(clearDep);
+				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
+				return true;
+			}
+		);
+		parser.hooks.importSpecifier.tap(
+			{
+				name: PLUGIN_NAME,
+				stage: -10
+			},
+			(statement, source, id, name) => {
+				if (!moduleNames.includes(source) || id !== specifierName) return;
+				parser.tagVariable(name, createRequireSpecifierTag);
+				return true;
+			}
+		);
+		parser.hooks.preDeclarator.tap(PLUGIN_NAME, (declarator) => {
+			if (
+				declarator.id.type !== "Identifier" ||
+				!declarator.init ||
+				declarator.init.type !== "CallExpression" ||
+				declarator.init.callee.type !== "Identifier"
+			) {
+				return;
+			}
+			const variableInfo = parser.getVariableInfo(declarator.init.callee.name);
+			if (
+				variableInfo instanceof VariableInfo &&
+				variableInfo.tagInfo &&
+				variableInfo.tagInfo.tag === createRequireSpecifierTag
+			) {
+				const context = parseCreateRequireArguments(declarator.init);
+				if (context === undefined) return;
+				parser.tagVariable(declarator.id.name, createdRequireIdentifierTag, {
+					name: declarator.id.name,
+					context
+				});
+				return true;
+			}
+		});
+
+		parser.hooks.memberChainOfCallMemberChain
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr, calleeMembers, callExpr, members) => {
+				if (
+					calleeMembers.length !== 0 ||
+					members.length !== 1 ||
+					members[0] !== "cache"
+				) {
+					return;
+				}
+				// createRequire().cache
+				const context = parseCreateRequireArguments(callExpr);
+				if (context === undefined) return;
+				return requireCache(expr);
+			});
+		parser.hooks.callMemberChainOfCallMemberChain
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr, calleeMembers, innerCallExpression, members) => {
+				if (
+					calleeMembers.length !== 0 ||
+					members.length !== 1 ||
+					members[0] !== "resolve"
+				) {
+					return;
+				}
+				// createRequire().resolve()
+				return processResolve(expr, false);
+			});
+		parser.hooks.expressionMemberChain
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, (expr, members) => {
+				// require.cache
+				if (members.length === 1 && members[0] === "cache") {
+					return requireCache(expr);
+				}
+			});
+		parser.hooks.callMemberChain
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, (expr, members) => {
+				// require.resolve()
+				if (members.length === 1 && members[0] === "resolve") {
+					return processResolve(expr, false);
+				}
+			});
+		parser.hooks.expression
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr) => {
+				const clearDep = new ConstDependency(
+					"/* createRequire */ undefined",
+					/** @type {Range} */ (expr.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(clearDep);
+				return true;
+			});
+		parser.hooks.call
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr) => {
+				const clearDep = new ConstDependency(
+					"/* createRequire() */ undefined",
+					/** @type {Range} */ (expr.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(clearDep);
+				return true;
+			});
+	}
+}
+
+module.exports = CreateRequireParserPlugin;

node_modules/webpack/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -39,14 +39,10 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 	 */
 	constructor(options) {
 		this.options = options;
-		this.exportPresenceMode =
-			options.reexportExportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
-				: options.exportsPresence !== undefined
-					? ExportPresenceModes.fromUserOption(options.exportsPresence)
-					: options.strictExportPresence
-						? ExportPresenceModes.ERROR
-						: ExportPresenceModes.AUTO;
+		this.exportPresenceMode = ExportPresenceModes.resolveFromOptions(
+			options.reexportExportsPresence,
+			options
+		);
 	}
 
 	/**

node_modules/webpack/lib/dependencies/HarmonyImportDependency.js

@@ -53,9 +53,38 @@ const ExportPresenceModes = {
 			default:
 				throw new Error(`Invalid export presence value ${str}`);
 		}
+	},
+	/**
+	 * Resolve export presence mode from parser options with a specific key and shared fallbacks.
+	 * @param {string | false | undefined} specificValue the type-specific option value (e.g. importExportsPresence or reexportExportsPresence)
+	 * @param {import("../../declarations/WebpackOptions").JavascriptParserOptions} options parser options
+	 * @returns {ExportPresenceMode} resolved mode
+	 */
+	resolveFromOptions(specificValue, options) {
+		if (specificValue !== undefined) {
+			return ExportPresenceModes.fromUserOption(specificValue);
+		}
+		if (options.exportsPresence !== undefined) {
+			return ExportPresenceModes.fromUserOption(options.exportsPresence);
+		}
+		return options.strictExportPresence
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.AUTO;
 	}
 };
 
+/**
+ * Get the non-optional leading part of a member chain.
+ * @param {string[]} members members
+ * @param {boolean[]} membersOptionals optionality for each member
+ * @returns {string[]} the non-optional prefix
+ */
+const getNonOptionalPart = (members, membersOptionals) => {
+	let i = 0;
+	while (i < members.length && membersOptionals[i] === false) i++;
+	return i !== members.length ? members.slice(0, i) : members;
+};
+
 /** @typedef {string[]} Ids */
 
 class HarmonyImportDependency extends ModuleDependency {
@@ -427,3 +456,4 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 };
 
 module.exports.ExportPresenceModes = ExportPresenceModes;
+module.exports.getNonOptionalPart = getNonOptionalPart;

node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -18,12 +18,16 @@ const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
 const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
 const HarmonyExports = require("./HarmonyExports");
-const { ExportPresenceModes } = require("./HarmonyImportDependency");
+const {
+	ExportPresenceModes,
+	getNonOptionalPart
+} = require("./HarmonyImportDependency");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifier */
 /** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
@@ -63,17 +67,44 @@ const harmonySpecifierGuardTag = Symbol("harmony import guard");
 
 const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
 
-/** @type {(members: Members) => string} */
-const getMembersKey = (members) => members.join(".");
-
 /**
- * Strip the root binding name if needed
- * @param {HarmonySettings} settings settings
- * @param {Ids} ids ids
- * @returns {Ids} ids for presence check
+ * @param {JavascriptParser} parser the parser
+ * @param {PrivateIdentifier | Expression} left left expression
+ * @param {Expression} right right expression
+ * @returns {{ leftPart: string, members: Members, settings: HarmonySettings } | undefined} info
  */
-const getIdsForPresence = (settings, ids) =>
-	settings.ids.length ? ids.slice(1) : ids;
+const getInOperatorHarmonyImportInfo = (parser, left, right) => {
+	const leftPartEvaluated = parser.evaluateExpression(left);
+	if (leftPartEvaluated.couldHaveSideEffects()) return;
+	/** @type {string | undefined} */
+	const leftPart = leftPartEvaluated.asString();
+	if (!leftPart) return;
+
+	const rightPart = parser.evaluateExpression(right);
+	if (!rightPart.isIdentifier()) return;
+
+	const rootInfo = rightPart.rootInfo;
+	const root =
+		typeof rootInfo === "string"
+			? rootInfo
+			: rootInfo instanceof VariableInfo
+				? rootInfo.name
+				: undefined;
+	if (!root) return;
+
+	const settings = /** @type {HarmonySettings | undefined} */ (
+		parser.getTagData(root, harmonySpecifierTag)
+	);
+	if (!settings) {
+		return;
+	}
+
+	return {
+		leftPart,
+		members: /** @type {(() => Members)} */ (rightPart.getMembers)(),
+		settings
+	};
+};
 
 module.exports = class HarmonyImportDependencyParserPlugin {
 	/**
@@ -82,23 +113,23 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 	constructor(options) {
 		this.options = options;
 		/** @type {ExportPresenceMode} */
-		this.exportPresenceMode =
-			options.importExportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
-				: options.exportsPresence !== undefined
-					? ExportPresenceModes.fromUserOption(options.exportsPresence)
-					: options.strictExportPresence
-						? ExportPresenceModes.ERROR
-						: ExportPresenceModes.AUTO;
+		this.exportPresenceMode = ExportPresenceModes.resolveFromOptions(
+			options.importExportsPresence,
+			options
+		);
 		this.strictThisContextOnImports = options.strictThisContextOnImports;
 	}
 
 	/**
 	 * @param {JavascriptParser} parser the parser
+	 * @param {HarmonySettings} settings settings
 	 * @param {Ids} ids ids
 	 * @returns {ExportPresenceMode} exportPresenceMode
 	 */
-	getExportPresenceMode(parser, ids) {
+	getExportPresenceMode(parser, settings, ids) {
+		// Guards only apply to namespace imports
+		if (settings.ids.length) return this.exportPresenceMode;
+
 		const harmonySettings = /** @type {HarmonySettings=} */ (
 			parser.currentTagData
 		);
@@ -107,9 +138,12 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		const data = /** @type {HarmonySpecifierGuards=} */ (
 			parser.getTagData(harmonySettings.name, harmonySpecifierGuardTag)
 		);
-		return data && data.guards && data.guards.has(getMembersKey(ids))
-			? ExportPresenceModes.NONE
-			: this.exportPresenceMode;
+
+		if (data && data.guards && data.guards.has(ids[0])) {
+			return ExportPresenceModes.NONE;
+		}
+
+		return this.exportPresenceMode;
 	}
 
 	/**
@@ -119,17 +153,6 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 	apply(parser) {
 		const getImportPhase = createGetImportPhase(this.options.deferImport);
 
-		/**
-		 * @param {Members} members members
-		 * @param {MembersOptionals} membersOptionals members Optionals
-		 * @returns {Ids} a non optional part
-		 */
-		function getNonOptionalPart(members, membersOptionals) {
-			let i = 0;
-			while (i < members.length && membersOptionals[i] === false) i++;
-			return i !== members.length ? members.slice(0, i) : members;
-		}
-
 		/**
 		 * @param {MemberExpression} node member expression
 		 * @param {number} count count
@@ -207,31 +230,14 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		);
 		parser.hooks.binaryExpression.tap(PLUGIN_NAME, (expression) => {
 			if (expression.operator !== "in") return;
+			const info = getInOperatorHarmonyImportInfo(
+				parser,
+				expression.left,
+				expression.right
+			);
+			if (!info) return;
 
-			const leftPartEvaluated = parser.evaluateExpression(expression.left);
-			if (leftPartEvaluated.couldHaveSideEffects()) return;
-			/** @type {string | undefined} */
-			const leftPart = leftPartEvaluated.asString();
-			if (!leftPart) return;
-
-			const rightPart = parser.evaluateExpression(expression.right);
-			if (!rightPart.isIdentifier()) return;
-
-			const rootInfo = rightPart.rootInfo;
-			if (
-				typeof rootInfo === "string" ||
-				!rootInfo ||
-				!rootInfo.tagInfo ||
-				rootInfo.tagInfo.tag !== harmonySpecifierTag
-			) {
-				return;
-			}
-			const settings =
-				/** @type {HarmonySettings} */
-				(rootInfo.tagInfo.data);
-			const members =
-				/** @type {(() => Members)} */
-				(rightPart.getMembers)();
+			const { leftPart, members, settings } = info;
 			const dep = new HarmonyEvaluatedImportSpecifierDependency(
 				settings.source,
 				settings.sourceOrder,
@@ -276,10 +282,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					settings.name,
 					/** @type {Range} */
 					(expr.range),
-					this.getExportPresenceMode(
-						parser,
-						getIdsForPresence(settings, settings.ids)
-					),
+					this.exportPresenceMode,
 					settings.phase,
 					settings.attributes,
 					[]
@@ -329,10 +332,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						settings.name,
 						/** @type {Range} */
 						(expr.range),
-						this.getExportPresenceMode(
-							parser,
-							getIdsForPresence(settings, ids)
-						),
+						this.getExportPresenceMode(parser, settings, ids),
 						settings.phase,
 						settings.attributes,
 						ranges
@@ -382,10 +382,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						ids,
 						settings.name,
 						/** @type {Range} */ (expr.range),
-						this.getExportPresenceMode(
-							parser,
-							getIdsForPresence(settings, ids)
-						),
+						this.getExportPresenceMode(parser, settings, ids),
 						settings.phase,
 						settings.attributes,
 						ranges
@@ -453,160 +450,6 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			}
 		});
 
-		/**
-		 * @param {Expression} expression expression
-		 * @returns {{ root: string, members: Members } | undefined} info
-		 */
-		const getHarmonyImportInfo = (expression) => {
-			const nameInfo = parser.getNameForExpression(expression);
-			if (!nameInfo) return;
-
-			const rootInfo = nameInfo.rootInfo;
-			const root =
-				typeof rootInfo === "string"
-					? rootInfo
-					: rootInfo instanceof VariableInfo
-						? rootInfo.name
-						: undefined;
-			if (!root) return;
-			if (!parser.getTagData(root, harmonySpecifierTag)) return;
-			return { root, members: nameInfo.getMembers() };
-		};
-
-		/**
-		 * @param {Guards} guards guards
-		 * @param {string} root root name
-		 * @param {Members} members members
-		 */
-		const addToGuards = (guards, root, members) => {
-			const membersKey = getMembersKey(members);
-			const guardedMembers = guards.get(root);
-			if (guardedMembers) {
-				guardedMembers.add(membersKey);
-				return;
-			}
-
-			guards.set(
-				root,
-				// Adding `foo.bar` implies guarding `foo` as well
-				membersKey === "" ? new Set([""]) : new Set([membersKey, ""])
-			);
-		};
-
-		/**
-		 * @param {Expression} expression expression
-		 * @param {Guards} guards guards
-		 * @param {boolean} needTruthy need to be truthy
-		 */
-		const collect = (expression, guards, needTruthy) => {
-			// !foo
-			if (
-				expression.type === "UnaryExpression" &&
-				expression.operator === "!"
-			) {
-				collect(expression.argument, guards, !needTruthy);
-				return;
-			} else if (expression.type === "LogicalExpression" && needTruthy) {
-				// foo && bar
-				if (expression.operator === "&&") {
-					collect(expression.left, guards, true);
-					collect(expression.right, guards, true);
-				}
-				// falsy || foo
-				else if (expression.operator === "||") {
-					const leftEvaluation = parser.evaluateExpression(expression.left);
-					const leftBool = leftEvaluation.asBool();
-					if (leftBool === false) {
-						collect(expression.right, guards, true);
-					}
-				}
-				// nullish ?? foo
-				else if (expression.operator === "??") {
-					const leftEvaluation = parser.evaluateExpression(expression.left);
-					const leftNullish = leftEvaluation.asNullish();
-					if (leftNullish === true) {
-						collect(expression.right, guards, true);
-					}
-				}
-				return;
-			}
-			if (!needTruthy) return;
-
-			/**
-			 * @param {Expression} targetExpression expression
-			 * @returns {boolean} is added
-			 */
-			const addGuardForExpression = (targetExpression) => {
-				const info = getHarmonyImportInfo(targetExpression);
-				if (!info) return false;
-				addToGuards(guards, info.root, info.members);
-				return true;
-			};
-
-			/**
-			 * @param {Expression} left left expression
-			 * @param {Expression} right right expression
-			 * @param {(evaluation: ReturnType<JavascriptParser["evaluateExpression"]>) => boolean} matcher matcher
-			 * @returns {boolean} is added
-			 */
-			const addGuardForNullishCompare = (left, right, matcher) => {
-				const leftEval = parser.evaluateExpression(left);
-				if (leftEval && matcher(leftEval)) {
-					return addGuardForExpression(right);
-				}
-				const rightEval = parser.evaluateExpression(right);
-				if (rightEval && matcher(rightEval)) {
-					return addGuardForExpression(/** @type {Expression} */ (left));
-				}
-				return false;
-			};
-
-			if (expression.type === "BinaryExpression") {
-				// "bar" in foo
-				if (expression.operator === "in") {
-					const leftEvaluation = parser.evaluateExpression(expression.left);
-					if (leftEvaluation.couldHaveSideEffects()) return;
-					const propertyName = leftEvaluation.asString();
-					if (!propertyName) return;
-					parser.evaluateExpression(expression.right);
-					const info = getHarmonyImportInfo(expression.right);
-					if (!info) return;
-
-					if (info.members.length) {
-						for (const member of info.members) {
-							addToGuards(guards, info.root, [member]);
-						}
-					}
-					addToGuards(guards, info.root, [...info.members, propertyName]);
-					return;
-				}
-				// foo !== undefined
-				else if (
-					expression.operator === "!==" &&
-					addGuardForNullishCompare(
-						/** @type {Expression} */ (expression.left),
-						expression.right,
-						(evaluation) => evaluation.isUndefined()
-					)
-				) {
-					return;
-				}
-				// foo != undefined
-				// foo != null
-				else if (
-					expression.operator === "!=" &&
-					addGuardForNullishCompare(
-						/** @type {Expression} */ (expression.left),
-						expression.right,
-						(evaluation) => Boolean(evaluation.asNullish())
-					)
-				) {
-					return;
-				}
-			}
-			addGuardForExpression(expression);
-		};
-
 		/**
 		 * @param {Guards} guards guards
 		 * @param {() => void} walk walk callback
@@ -657,7 +500,68 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				if (parser.scope.isAsmJs) return;
 				/** @type {Guards} */
 				const guards = new Map();
-				collect(expression, guards, true);
+
+				/**
+				 * @param {Expression} expression expression
+				 * @param {boolean} needTruthy need to be truthy
+				 */
+				const collect = (expression, needTruthy) => {
+					if (
+						expression.type === "UnaryExpression" &&
+						expression.operator === "!"
+					) {
+						collect(expression.argument, !needTruthy);
+						return;
+					} else if (expression.type === "LogicalExpression" && needTruthy) {
+						if (expression.operator === "&&") {
+							collect(expression.left, true);
+							collect(expression.right, true);
+						} else if (expression.operator === "||") {
+							const leftEvaluation = parser.evaluateExpression(expression.left);
+							const leftBool = leftEvaluation.asBool();
+							if (leftBool === false) {
+								collect(expression.right, true);
+							}
+						} else if (expression.operator === "??") {
+							const leftEvaluation = parser.evaluateExpression(expression.left);
+							const leftNullish = leftEvaluation.asNullish();
+							if (leftNullish === true) {
+								collect(expression.right, true);
+							}
+						}
+						return;
+					}
+					if (!needTruthy) return;
+
+					// Direct `"x" in ns` guards
+					if (
+						expression.type === "BinaryExpression" &&
+						expression.operator === "in"
+					) {
+						if (expression.right.type !== "Identifier") {
+							return;
+						}
+						const info = getInOperatorHarmonyImportInfo(
+							parser,
+							expression.left,
+							expression.right
+						);
+						if (!info) return;
+
+						const { settings, leftPart, members } = info;
+						// Only direct namespace guards
+						if (members.length > 0) return;
+						const guarded = guards.get(settings.name);
+						if (guarded) {
+							guarded.add(leftPart);
+							return;
+						}
+
+						guards.set(settings.name, new Set([leftPart]));
+					}
+				};
+
+				collect(expression, true);
 
 				if (guards.size === 0) return;
 				return (walk) => {

node_modules/webpack/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 
@@ -72,11 +73,16 @@ HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDepend
 	 */
 	apply(dependency, source, templateContext) {
 		const { moduleGraph, concatenationScope } = templateContext;
-		if (concatenationScope) {
-			const module = /** @type {Module} */ (moduleGraph.getModule(dependency));
-			if (concatenationScope.isModuleInScope(module)) {
-				return;
-			}
+
+		const module = /** @type {Module} */ (moduleGraph.getModule(dependency));
+
+		if (module && !module.getSourceBasicTypes().has(JAVASCRIPT_TYPE)) {
+			// no need to render import
+			return;
+		}
+
+		if (concatenationScope && concatenationScope.isModuleInScope(module)) {
+			return;
 		}
 		super.apply(dependency, source, templateContext);
 	}

node_modules/webpack/lib/dependencies/HarmonyModulesPlugin.js

@@ -9,6 +9,7 @@ const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
+const CreateRequireParserPlugin = require("./CreateRequireParserPlugin");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
 const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
@@ -138,6 +139,9 @@ class HarmonyModulesPlugin {
 					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
 					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);
 					new HarmonyTopLevelThisParserPlugin().apply(parser);
+					if (parserOptions.createRequire) {
+						new CreateRequireParserPlugin(parserOptions).apply(parser);
+					}
 				};
 
 				normalModuleFactory.hooks.parser

node_modules/webpack/lib/dependencies/ImportParserPlugin.js

@@ -14,6 +14,7 @@ const {
 } = require("../javascript/JavascriptParser");
 const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const { getNonOptionalPart } = require("./HarmonyImportDependency");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
@@ -178,17 +179,6 @@ class ImportParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
-		/**
-		 * @param {Members} members members
-		 * @param {MembersOptionals} membersOptionals members Optionals
-		 * @returns {string[]} a non optional part
-		 */
-		function getNonOptionalPart(members, membersOptionals) {
-			let i = 0;
-			while (i < members.length && membersOptionals[i] === false) i++;
-			return i !== members.length ? members.slice(0, i) : members;
-		}
-
 		parser.hooks.collectDestructuringAssignmentProperties.tap(
 			PLUGIN_NAME,
 			(expr) => {

node_modules/webpack/lib/dependencies/ImportPhase.js

@@ -27,12 +27,16 @@ const ImportPhase = Object.freeze({
 
 /**
  * @typedef {object} ImportPhaseUtils
+ * @property {(phase: ImportPhaseType) => boolean} isEvaluation true if phase is evaluation
  * @property {(phase: ImportPhaseType) => boolean} isDefer true if phase is defer
  * @property {(phase: ImportPhaseType) => boolean} isSource true if phase is source
  */
 
 /** @type {ImportPhaseUtils} */
 const ImportPhaseUtils = {
+	isEvaluation(phase) {
+		return phase === ImportPhase.Evaluation;
+	},
 	isDefer(phase) {
 		return phase === ImportPhase.Defer;
 	},

node_modules/webpack/lib/javascript/JavascriptModulesPlugin.js

@@ -56,6 +56,7 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGraph").EntryModuleWithChunkGroup} EntryModuleWithChunkGroup */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compilation").ExecuteModuleObject} ExecuteModuleObject */
@@ -75,37 +76,75 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("../util/concatenate").ScopeSet} ScopeSet */
 /** @typedef {import("../util/concatenate").UsedNamesInScopeInfo} UsedNamesInScopeInfo */
 
+/** @type {WeakMap<ChunkGraph, WeakMap<Chunk, boolean>>} */
+const chunkHasJsCache = new WeakMap();
+
 /**
  * @param {Chunk} chunk a chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {boolean} true, when a JS file is needed for this chunk
  */
-const chunkHasJs = (chunk, chunkGraph) => {
-	if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return true;
+const _chunkHasJs = (chunk, chunkGraph) => {
+	if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+		for (const module of chunkGraph.getChunkEntryModulesIterable(chunk)) {
+			if (chunkGraph.getModuleSourceTypes(module).has(JAVASCRIPT_TYPE)) {
+				return true;
+			}
+		}
+	}
 
 	return Boolean(
 		chunkGraph.getChunkModulesIterableBySourceType(chunk, JAVASCRIPT_TYPE)
 	);
 };
 
+/**
+ * @param {Chunk} chunk a chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {boolean} true, when a JS file is needed for this chunk
+ */
+const chunkHasJs = (chunk, chunkGraph) => {
+	let innerCache = chunkHasJsCache.get(chunkGraph);
+	if (innerCache === undefined) {
+		innerCache = new WeakMap();
+		chunkHasJsCache.set(chunkGraph, innerCache);
+	}
+
+	const cachedResult = innerCache.get(chunk);
+	if (cachedResult !== undefined) {
+		return cachedResult;
+	}
+
+	const result = _chunkHasJs(chunk, chunkGraph);
+	innerCache.set(chunk, result);
+	return result;
+};
+
 /**
  * @param {Chunk} chunk a chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {boolean} true, when a JS file is needed for this chunk
  */
 const chunkHasRuntimeOrJs = (chunk, chunkGraph) => {
+	if (chunkHasJs(chunk, chunkGraph)) {
+		return true;
+	}
+
 	if (
 		chunkGraph.getChunkModulesIterableBySourceType(
 			chunk,
 			WEBPACK_MODULE_TYPE_RUNTIME
 		)
 	) {
-		return true;
+		for (const chunkGroup of chunk.groupsIterable) {
+			for (const c of chunkGroup.chunks) {
+				if (chunkHasJs(c, chunkGraph)) return true;
+			}
+		}
+		return false;
 	}
 
-	return Boolean(
-		chunkGraph.getChunkModulesIterableBySourceType(chunk, JAVASCRIPT_TYPE)
-	);
+	return false;
 };
 
 /**
@@ -1312,17 +1351,22 @@ class JavascriptModulesPlugin {
 				const runtimeRequirements =
 					chunkGraph.getTreeRuntimeRequirements(chunk);
 				buf2.push("// Load entry module and return exports");
-				let i = chunkGraph.getNumberOfEntryModules(chunk);
+
+				/** @type {EntryModuleWithChunkGroup[]} */
+				const jsEntries = [];
 				for (const [
 					entryModule,
 					entrypoint
 				] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
 					if (
-						!chunkGraph.getModuleSourceTypes(entryModule).has(JAVASCRIPT_TYPE)
+						chunkGraph.getModuleSourceTypes(entryModule).has(JAVASCRIPT_TYPE)
 					) {
-						i--;
+						jsEntries.push([entryModule, entrypoint]);
 						continue;
 					}
+				}
+				let i = jsEntries.length;
+				for (const [entryModule, entrypoint] of jsEntries) {
 					const chunks =
 						/** @type {Entrypoint} */
 						(entrypoint).chunks.filter((c) => c !== chunk);
@@ -1546,20 +1590,42 @@ class JavascriptModulesPlugin {
 			runtimeTemplate: { outputOptions }
 		} = renderContext;
 		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+
+		/**
+		 * @param {string} condition guard expression
+		 * @returns {string[]} source
+		 */
+		const renderMissingModuleError = (condition) =>
+			outputOptions.pathinfo
+				? [
+						`if (${condition}) {`,
+						Template.indent([
+							"delete __webpack_module_cache__[moduleId];",
+							'var e = new Error("Cannot find module \'" + moduleId + "\'");',
+							"e.code = 'MODULE_NOT_FOUND';",
+							"throw e;"
+						]),
+						"}"
+					]
+				: [];
+
 		const moduleExecution = runtimeRequirements.has(
 			RuntimeGlobals.interceptModuleExecution
 		)
 			? Template.asString([
 					`var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: ${RuntimeGlobals.require} };`,
 					`${RuntimeGlobals.interceptModuleExecution}.forEach(function(handler) { handler(execOptions); });`,
+					...renderMissingModuleError("!execOptions.factory"),
 					"module = execOptions.module;",
 					"execOptions.factory.call(module.exports, module, module.exports, execOptions.require);"
 				])
 			: runtimeRequirements.has(RuntimeGlobals.thisAsExports)
 				? Template.asString([
+						...renderMissingModuleError("!(moduleId in __webpack_modules__)"),
 						`__webpack_modules__[moduleId].call(module.exports, module, module.exports, ${RuntimeGlobals.require});`
 					])
 				: Template.asString([
+						...renderMissingModuleError("!(moduleId in __webpack_modules__)"),
 						`__webpack_modules__[moduleId](module, module.exports, ${RuntimeGlobals.require});`
 					]);
 		const needModuleId = runtimeRequirements.has(RuntimeGlobals.moduleId);
@@ -1580,19 +1646,6 @@ class JavascriptModulesPlugin {
 					])
 				: Template.indent("return cachedModule.exports;"),
 			"}",
-			// Add helpful error message in development mode when module is not found
-			...(outputOptions.pathinfo
-				? [
-						"// Check if module exists (development only)",
-						"if (__webpack_modules__[moduleId] === undefined) {",
-						Template.indent([
-							'var e = new Error("Cannot find module \'" + moduleId + "\'");',
-							"e.code = 'MODULE_NOT_FOUND';",
-							"throw e;"
-						]),
-						"}"
-					]
-				: []),
 			"// Create a new module (and put it into the cache)",
 			"var module = __webpack_module_cache__[moduleId] = {",
 			Template.indent([

node_modules/webpack/lib/javascript/JavascriptParser.js

@@ -318,13 +318,13 @@ class VariableInfo {
 /** @typedef {Literal | string | null | undefined} ImportSource */
 
 /**
- * @typedef {Omit<ParseOptions, "sourceType"> & { sourceType: "module" | "script" | "auto" }} InternalParseOptions
+ * @typedef {Omit<ParseOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto" }} InternalParseOptions
  */
 
 /**
  * @typedef {object} ParseOptions
  * @property {"module" | "script"} sourceType
- * @property {EcmaVersion=} ecmaVersion
+ * @property {EcmaVersion} ecmaVersion
  * @property {boolean=} locations
  * @property {boolean=} comments
  * @property {boolean=} ranges

node_modules/webpack/lib/optimize/ConcatenatedModule.js

@@ -1004,6 +1004,9 @@ class ConcatenatedModule extends Module {
 					if (!(connection.dependency instanceof HarmonyImportDependency)) {
 						return false;
 					}
+					if (!connection.module.getSourceBasicTypes().has(JAVASCRIPT_TYPE)) {
+						return false;
+					}
 					return (
 						connection &&
 						connection.resolvedOriginModule === module &&

node_modules/webpack/lib/optimize/ModuleConcatenationPlugin.js

@@ -466,7 +466,10 @@ class ModuleConcatenationPlugin {
 												chunk,
 												m
 											);
-											if (sourceTypes.size === 1) {
+											if (
+												sourceTypes.size === 1 &&
+												sourceTypes.has(JAVASCRIPT_TYPE)
+											) {
 												chunkGraph.disconnectChunkAndModule(chunk, m);
 											} else {
 												const newSourceTypes = new Set(sourceTypes);

node_modules/webpack/lib/performance/AssetsOverSizeLimitWarning.js

@@ -28,6 +28,7 @@ Assets: ${assetLists}`);
 
 		/** @type {string} */
 		this.name = "AssetsOverSizeLimitWarning";
+		/** @type {AssetDetails[]} */
 		this.assets = assetsOverSizeLimit;
 	}
 }

node_modules/webpack/lib/performance/EntrypointsOverSizeLimitWarning.js

@@ -31,6 +31,7 @@ Entrypoints:${entrypointList}\n`);
 
 		/** @type {string} */
 		this.name = "EntrypointsOverSizeLimitWarning";
+		/** @type {EntrypointDetails[]} */
 		this.entrypoints = entrypoints;
 	}
 }

node_modules/webpack/lib/performance/SizeLimitsPlugin.js

@@ -46,6 +46,7 @@ module.exports = class SizeLimitsPlugin {
 	 * @param {PerformanceOptions} options the plugin options
 	 */
 	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
 		this.hints = options.hints;
 		/** @type {number | undefined} */
 		this.maxAssetSize = options.maxAssetSize;

node_modules/webpack/lib/runtime/ToBinaryRuntimeModule.js

@@ -29,30 +29,38 @@ class ToBinaryRuntimeModule extends RuntimeModule {
 		const isNodePlatform = compilation.compiler.platform.node;
 		const isWebPlatform = compilation.compiler.platform.web;
 		const isNeutralPlatform = runtimeTemplate.isNeutralPlatform();
+		const toImmutableBytes = runtimeTemplate.basicFunction("value", [
+			runtimeTemplate.destructureObject(["buffer"], "value"),
+			`${runtimeTemplate.renderConst()} throwErr = ${runtimeTemplate.basicFunction("", ["throw new TypeError('ArrayBuffer is immutable');"])};`,
+			"Object.defineProperties(buffer, { immutable: { value: true },  resize: { value: throwErr }, transfer: { value: throwErr }, transferToFixedLength: { value: throwErr } });",
+			"Object.freeze(buffer);",
+			"return value;"
+		]);
 
 		return Template.asString([
 			"// define to binary helper",
+			`${runtimeTemplate.renderConst()} toImmutableBytes = ${toImmutableBytes}`,
 			`${fn} = ${isNeutralPlatform ? "typeof Buffer !== 'undefined' ? " : ""}${
 				isNodePlatform || isNeutralPlatform
-					? `${runtimeTemplate.returningFunction("new Uint8Array(Buffer.from(base64, 'base64'))", "base64")}`
+					? `${runtimeTemplate.returningFunction("toImmutableBytes(new Uint8Array(Buffer.from(base64, 'base64')))", "base64")}`
 					: ""
 			} ${isNeutralPlatform ? ": " : ""}${
 				isWebPlatform || isNeutralPlatform
 					? `(${runtimeTemplate.basicFunction("", [
-							"var table = new Uint8Array(128);",
+							`${runtimeTemplate.renderConst()} table = new Uint8Array(128);`,
 							"for (var i = 0; i < 64; i++) table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i;",
 							`return ${runtimeTemplate.basicFunction("base64", [
-								"var n = base64.length, bytes = new Uint8Array((n - (base64[n - 1] == '=') - (base64[n - 2] == '=')) * 3 / 4 | 0);",
+								`${runtimeTemplate.renderConst()} n = base64.length, bytes = new Uint8Array((n - (base64[n - 1] == '=') - (base64[n - 2] == '=')) * 3 / 4 | 0);`,
 								"for (var i = 0, j = 0; i < n;) {",
 								Template.indent([
-									"var c0 = table[base64.charCodeAt(i++)], c1 = table[base64.charCodeAt(i++)];",
-									"var c2 = table[base64.charCodeAt(i++)], c3 = table[base64.charCodeAt(i++)];",
+									`${runtimeTemplate.renderConst()} c0 = table[base64.charCodeAt(i++)], c1 = table[base64.charCodeAt(i++)];`,
+									`${runtimeTemplate.renderConst()} c2 = table[base64.charCodeAt(i++)], c3 = table[base64.charCodeAt(i++)];`,
 									"bytes[j++] = (c0 << 2) | (c1 >> 4);",
 									"bytes[j++] = (c1 << 4) | (c2 >> 2);",
 									"bytes[j++] = (c2 << 6) | c3;"
 								]),
 								"}",
-								"return bytes"
+								"return toImmutableBytes(bytes)"
 							])}`
 						])})();`
 					: ""

node_modules/webpack/lib/sharing/ConsumeSharedModule.js

@@ -8,7 +8,10 @@
 const { RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
-const { CONSUME_SHARED_TYPES } = require("../ModuleSourceTypeConstants");
+const {
+	CONSUME_SHARED_TYPES,
+	JAVASCRIPT_TYPES
+} = require("../ModuleSourceTypeConstants");
 const {
 	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
 } = require("../ModuleTypeConstants");
@@ -41,6 +44,7 @@ const fallbackModuleCache = new WeakMap();
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/semver").SemVerRange} SemVerRange */
+/** @typedef {import("../Module").BasicSourceTypes} BasicSourceTypes */
 
 /**
  * @typedef {object} ConsumeOptions
@@ -159,6 +163,19 @@ class ConsumeSharedModule extends Module {
 		return CONSUME_SHARED_TYPES;
 	}
 
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 *
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 * @returns {BasicSourceTypes} types available (do not mutate)
+	 */
+	getSourceBasicTypes() {
+		return JAVASCRIPT_TYPES;
+	}
+
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {Module | null} fallback module

node_modules/webpack/lib/util/AppendOnlyStackedSet.js

@@ -43,7 +43,9 @@ class AppendOnlyStackedSet {
 
 	clear() {
 		this._sets = [];
-		if (this._current) this._current.clear();
+		if (this._current) {
+			this._current = undefined;
+		}
 	}
 
 	/**
@@ -52,6 +54,25 @@ class AppendOnlyStackedSet {
 	createChild() {
 		return new AppendOnlyStackedSet(this._sets.length ? [...this._sets] : []);
 	}
+
+	/**
+	 * @returns {Iterator<T>} iterable iterator
+	 */
+	[Symbol.iterator]() {
+		const iterators = this._sets.map((map) => map[Symbol.iterator]());
+		let current = iterators.pop();
+		return {
+			next() {
+				if (!current) return { done: true, value: undefined };
+				let result = current.next();
+				while (result.done && iterators.length > 0) {
+					current = /** @type {SetIterator<T>} */ (iterators.pop());
+					result = current.next();
+				}
+				return result;
+			}
+		};
+	}
 }
 
 module.exports = AppendOnlyStackedSet;

node_modules/webpack/lib/util/findGraphRoots.js

@@ -8,19 +8,13 @@
 const NO_MARKER = 0;
 const IN_PROGRESS_MARKER = 1;
 const DONE_MARKER = 2;
-const DONE_MAYBE_ROOT_CYCLE_MARKER = 3;
-const DONE_AND_ROOT_MARKER = 4;
+const CANDIDATE_MARKER = 3;
 
 /**
  * @template T
  * @typedef {Set<Node<T>>} Nodes
  */
 
-/**
- * @template T
- * @typedef {Set<Cycle<T>>} Cycles
- */
-
 /**
  * @template T
  */
@@ -32,20 +26,24 @@ class Node {
 		this.item = item;
 		/** @type {Nodes<T>} */
 		this.dependencies = new Set();
-		this.marker = NO_MARKER;
-		/** @type {Cycle<T> | undefined} */
-		this.cycle = undefined;
+		/** @type {SCC<T>} */
+		this.scc = new SCC();
+		// Each node starts as a single-node SCC
+		this.scc.nodes.add(this);
+		/** @type {number} */
 		this.incoming = 0;
 	}
 }
 
 /**
+ * SCC (strongly connected component)
  * @template T
  */
-class Cycle {
+class SCC {
 	constructor() {
 		/** @type {Nodes<T>} */
 		this.nodes = new Set();
+		this.marker = NO_MARKER;
 	}
 }
 
@@ -70,10 +68,10 @@ module.exports = (items, getDependencies) => {
 		itemToNode.set(item, node);
 	}
 
-	// early exit when there is only a single item
+	// Early exit when there is only one node
 	if (itemToNode.size <= 1) return items;
 
-	// grab all the dependencies
+	// Build graph edges
 	for (const node of itemToNode.values()) {
 		for (const dep of getDependencies(node.item)) {
 			const depNode = itemToNode.get(dep);
@@ -83,27 +81,16 @@ module.exports = (items, getDependencies) => {
 		}
 	}
 
-	// Set of current root modules
-	// items will be removed if a new reference to it has been found
-	/** @type {Nodes<T>} */
-	const roots = new Set();
+	// All candidate root SCCs, they will be removed once an incoming edge is found
+	/** @type {Set<SCC<T>>} */
+	const rootSCCs = new Set();
 
-	// Set of current cycles without references to it
-	// cycles will be removed if a new reference to it has been found
-	// that is not part of the cycle
-	/** @type {Cycles<T>} */
-	const rootCycles = new Set();
-
-	// For all non-marked nodes
 	for (const selectedNode of itemToNode.values()) {
-		if (selectedNode.marker === NO_MARKER) {
-			// deep-walk all referenced modules
-			// in a non-recursive way
+		// DFS walk only once per unseen SCC
+		if (selectedNode.scc.marker === NO_MARKER) {
+			selectedNode.scc.marker = IN_PROGRESS_MARKER;
 
-			// start by entering the selected node
-			selectedNode.marker = IN_PROGRESS_MARKER;
-
-			// keep a stack to avoid recursive walk
+			// Keep a stack to avoid recursive walk
 			/** @type {StackEntry<T>[]} */
 			const stack = [
 				{
@@ -112,130 +99,113 @@ module.exports = (items, getDependencies) => {
 				}
 			];
 
-			// process the top item until stack is empty
 			while (stack.length > 0) {
 				const topOfStack = stack[stack.length - 1];
 
-				// Are there still edges unprocessed in the current node?
+				// Process one unvisited outgoing edge if available
 				if (topOfStack.openEdges.length > 0) {
-					// Process one dependency
 					const dependency =
 						/** @type {Node<T>} */
 						(topOfStack.openEdges.pop());
-					switch (dependency.marker) {
+					const depSCC = dependency.scc;
+					switch (depSCC.marker) {
 						case NO_MARKER:
-							// dependency has not be visited yet
-							// mark it as in-progress and recurse
+							// First time we see this SCC: enter it
 							stack.push({
 								node: dependency,
 								openEdges: [...dependency.dependencies]
 							});
-							dependency.marker = IN_PROGRESS_MARKER;
+							depSCC.marker = IN_PROGRESS_MARKER;
 							break;
 						case IN_PROGRESS_MARKER: {
-							// It's a in-progress cycle
-							let cycle = dependency.cycle;
-							if (!cycle) {
-								cycle = new Cycle();
-								cycle.nodes.add(dependency);
-								dependency.cycle = cycle;
-							}
-							// set cycle property for each node in the cycle
-							// if nodes are already part of a cycle
-							// we merge the cycles to a shared cycle
+							// Back-edge to an SCC that is still on the stack
+							// Example:
+							//   A -> B -> C -> D
+							//        ^         |
+							//        |_________|
+							// If we are at `D` and traverse `D` -> `B`, then `B/C/D` must be in one SCC
+							/** @type {Set<SCC<T>>} */
+							const sccsToMerge = new Set();
 							for (
 								let i = stack.length - 1;
-								stack[i].node !== dependency;
+								stack[i].node.scc !== depSCC;
 								i--
 							) {
-								const node = stack[i].node;
-								if (node.cycle) {
-									if (node.cycle !== cycle) {
-										// merge cycles
-										for (const cycleNode of node.cycle.nodes) {
-											cycleNode.cycle = cycle;
-											cycle.nodes.add(cycleNode);
-										}
-									}
-								} else {
-									node.cycle = cycle;
-									cycle.nodes.add(node);
+								sccsToMerge.add(stack[i].node.scc);
+							}
+							for (const sccToMerge of sccsToMerge) {
+								for (const nodeInMergedSCC of sccToMerge.nodes) {
+									nodeInMergedSCC.scc = depSCC;
+									depSCC.nodes.add(nodeInMergedSCC);
 								}
 							}
-							// don't recurse into dependencies
-							// these are already on the stack
 							break;
 						}
-						case DONE_AND_ROOT_MARKER:
-							// This node has be visited yet and is currently a root node
-							// But as this is a new reference to the node
-							// it's not really a root
-							// so we have to convert it to a normal node
-							dependency.marker = DONE_MARKER;
-							roots.delete(dependency);
+						case CANDIDATE_MARKER:
+							// This finished SCC was previously considered as root SCC
+							// We just found a new incoming edge, so it is no longer a candidate
+							rootSCCs.delete(/** @type {SCC<T>} */ (depSCC));
+							depSCC.marker = DONE_MARKER;
 							break;
-						case DONE_MAYBE_ROOT_CYCLE_MARKER:
-							// This node has be visited yet and
-							// is maybe currently part of a completed root cycle
-							// we found a new reference to the cycle
-							// so it's not really a root cycle
-							// remove the cycle from the root cycles
-							// and convert it to a normal node
-							rootCycles.delete(/** @type {Cycle<T>} */ (dependency.cycle));
-							dependency.marker = DONE_MARKER;
+						case DONE_MARKER:
+							// Already finalized and not a candidate
 							break;
-						// DONE_MARKER: nothing to do, don't recurse into dependencies
 					}
 				} else {
-					// All dependencies of the current node has been visited
-					// we leave the node
+					// All dependencies of the current node have been processed
+					// So we leave the node
 					stack.pop();
-					topOfStack.node.marker = DONE_MARKER;
+					// Mark an SCC as DONE only when the popped node is the last
+					// node from that SCC remaining on the current stack.
+					//   A -> B -> C -> D
+					//        ^         |
+					//        |_________|
+					// If `B` is popped and the new stack top is `A`, they are in
+					// different SCCs, so B's SCC can be finalized.
+					if (
+						stack.length &&
+						topOfStack.node.scc !== stack[stack.length - 1].node.scc
+					) {
+						topOfStack.node.scc.marker = DONE_MARKER;
+					}
 				}
 			}
-			const cycle = selectedNode.cycle;
-			if (cycle) {
-				for (const node of cycle.nodes) {
-					node.marker = DONE_MAYBE_ROOT_CYCLE_MARKER;
-				}
-				rootCycles.add(cycle);
-			} else {
-				selectedNode.marker = DONE_AND_ROOT_MARKER;
-				roots.add(selectedNode);
-			}
+			const scc = selectedNode.scc;
+			// This SCC is complete and currently has no known incoming edge
+			scc.marker = CANDIDATE_MARKER;
+			rootSCCs.add(scc);
 		}
 	}
 
-	// Extract roots from root cycles
-	// We take the nodes with most incoming edges
-	// inside of the cycle
-	for (const cycle of rootCycles) {
+	/** @type {Set<T>} */
+	const rootNodes = new Set();
+
+	// For each root SCC, we select node with the most incoming edges
+	// from within the same SCC
+	for (const scc of rootSCCs) {
 		let max = 0;
 		/** @type {Nodes<T>} */
-		const cycleRoots = new Set();
-		const nodes = cycle.nodes;
-		for (const node of nodes) {
+		const nodes = new Set(scc.nodes);
+		for (const node of scc.nodes) {
 			for (const dep of node.dependencies) {
-				if (nodes.has(dep)) {
+				if (scc.nodes.has(dep)) {
 					dep.incoming++;
 					if (dep.incoming < max) continue;
 					if (dep.incoming > max) {
-						cycleRoots.clear();
+						nodes.clear();
 						max = dep.incoming;
 					}
-					cycleRoots.add(dep);
+					nodes.add(dep);
 				}
 			}
 		}
-		for (const cycleRoot of cycleRoots) {
-			roots.add(cycleRoot);
+		for (const node of nodes) {
+			rootNodes.add(node.item);
 		}
 	}
 
-	// When roots were found, return them
-	if (roots.size > 0) {
-		return Array.from(roots, (r) => r.item);
-	}
+	// When root nodes were found, return them
+	if (rootNodes.size > 0) return rootNodes;
 
 	throw new Error("Implementation of findGraphRoots is broken");
 };

node_modules/webpack/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.105.2",
+  "version": "5.105.4",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "homepage": "https://github.com/webpack/webpack",
   "bugs": "https://github.com/webpack/webpack/issues",
@@ -57,6 +57,7 @@
     "test:basic:deno": "yarn test:base:deno --testMatch \"<rootDir>/test/*.basictest.js\"",
     "test:unit": "yarn test:base --testMatch \"<rootDir>/test/*.unittest.js\"",
     "test:integration": "yarn test:base --testMatch \"<rootDir>/test/*.{basictest,longtest,test}.js\"",
+    "test:test262": "yarn test:base --testMatch \"<rootDir>/test/*.spectest.js\"",
     "test:base:deno": "deno --allow-read --allow-env --allow-sys --allow-ffi --allow-write --allow-run --v8-flags='--max-old-space-size=4096' ./node_modules/jest-cli/bin/jest.js --logHeapUsage",
     "test:update-snapshots": "yarn test:base -u",
     "report:cover": "nyc report --reporter=lcov  --reporter=text -t coverage",
@@ -71,7 +72,8 @@
     "cover:basic": "yarn cover:base --testMatch \"<rootDir>/test/*.basictest.js\" --coverage",
     "cover:integration": "yarn cover:base --testMatch \"<rootDir>/test/*.{basictest,longtest,test}.js\" --coverage",
     "cover:integration:a": "yarn cover:base --testMatch \"<rootDir>/test/*.{basictest,test}.js\" --coverage",
-    "cover:integration:b": "yarn cover:base --testMatch \"<rootDir>/test/*.longtest.js\" --coverage"
+    "cover:integration:b": "yarn cover:base --testMatch \"<rootDir>/test/*.longtest.js\" --coverage",
+    "cover:test262": "yarn cover:base --testMatch \"<rootDir>/test/*.spectest.js\" --coverage"
   },
   "lint-staged": {
     "*.{js,cjs,mjs}": [
@@ -89,11 +91,11 @@
     "@webassemblyjs/ast": "^1.14.1",
     "@webassemblyjs/wasm-edit": "^1.14.1",
     "@webassemblyjs/wasm-parser": "^1.14.1",
-    "acorn": "^8.15.0",
+    "acorn": "^8.16.0",
     "acorn-import-phases": "^1.0.3",
     "browserslist": "^4.28.1",
     "chrome-trace-event": "^1.0.2",
-    "enhanced-resolve": "^5.19.0",
+    "enhanced-resolve": "^5.20.0",
     "es-module-lexer": "^2.0.0",
     "eslint-scope": "5.1.1",
     "events": "^3.2.0",
@@ -105,16 +107,16 @@
     "neo-async": "^2.6.2",
     "schema-utils": "^4.3.3",
     "tapable": "^2.3.0",
-    "terser-webpack-plugin": "^5.3.16",
+    "terser-webpack-plugin": "^5.3.17",
     "watchpack": "^2.5.1",
-    "webpack-sources": "^3.3.3"
+    "webpack-sources": "^3.3.4"
   },
   "devDependencies": {
     "@babel/core": "^7.27.1",
     "@babel/preset-react": "^7.27.1",
     "@changesets/cli": "^2.29.8",
     "@changesets/get-github-info": "^0.7.0",
-    "@codspeed/core": "^5.1.0",
+    "@codspeed/core": "^5.2.0",
     "@types/glob-to-regexp": "^0.4.4",
     "@types/graceful-fs": "^4.1.9",
     "@types/jest": "^30.0.0",
@@ -134,7 +136,7 @@
     "es5-ext": "^0.10.53",
     "es6-promise-polyfill": "^1.2.0",
     "eslint": "^9.39.2",
-    "eslint-config-webpack": "^4.9.1",
+    "eslint-config-webpack": "^4.9.3",
     "file-loader": "^6.0.0",
     "fork-ts-checker-webpack-plugin": "^9.0.2",
     "globals": "^17.0.0",
@@ -160,8 +162,9 @@
     "mini-css-extract-plugin": "^2.9.0",
     "mini-svg-data-uri": "^1.2.3",
     "node-gyp": "^12.1.0",
-    "nyc": "^17.1.0",
+    "nyc": "^18.0.0",
     "open-cli": "^8.0.0",
+    "oxc-parser": "^0.115.0",
     "pkg-pr-new": "^0.0.63",
     "prettier": "^3.7.4",
     "prettier-2": "npm:prettier@^2",
@@ -183,10 +186,10 @@
     "strip-ansi": "^6.0.0",
     "style-loader": "^4.0.0",
     "terser": "^5.43.1",
-    "three": "^0.182.0",
+    "three": "^0.183.1",
     "tinybench": "^6.0.0",
     "toml": "^3.0.0",
-    "tooling": "webpack/tooling#v1.24.5",
+    "tooling": "webpack/tooling#v1.24.6",
     "ts-loader": "^9.5.4",
     "typescript": "^5.9.3",
     "unified": "^11.0.5",

node_modules/webpack/types.d.ts

@@ -266,6 +266,42 @@ type AliasOptionNewRequest = string | false | string[];
 declare interface AliasOptions {
 	[index: string]: AliasOptionNewRequest;
 }
+declare interface AllCodeGenerationSchemas {
+	/**
+	 * top level declarations for javascript modules
+	 */
+	topLevelDeclarations: Set<string>;
+
+	/**
+	 * chunk init fragments for javascript modules
+	 */
+	chunkInitFragments: InitFragment<any>[];
+
+	/**
+	 * url for css and javascript modules
+	 */
+	url: { javascript?: string; "css-url"?: string };
+
+	/**
+	 * a filename for asset modules
+	 */
+	filename: string;
+
+	/**
+	 * an asset info for asset modules
+	 */
+	assetInfo: AssetInfo;
+
+	/**
+	 * a full content hash for asset modules
+	 */
+	fullContentHash: string;
+
+	/**
+	 * share-init for modules federation
+	 */
+	"share-init": [{ shareScope: string; initStage: number; init: string }];
+}
 type AnyLoaderContext = NormalModuleLoaderContext<any> &
 	LoaderRunnerLoaderContext<any> &
 	LoaderPluginLoaderContext &
@@ -275,6 +311,7 @@ declare abstract class AppendOnlyStackedSet<T> {
 	has(el: T): boolean;
 	clear(): void;
 	createChild(): AppendOnlyStackedSet<T>;
+	[Symbol.iterator](): Iterator<T>;
 }
 declare interface Argument {
 	description?: string;
@@ -1249,7 +1286,6 @@ declare interface CallbackWebpackFunction_2<T, R = void> {
 	(err: null | Error, result?: T): R;
 }
 type Cell<T> = undefined | T;
-type ChildrenStatsOptions = undefined | string | boolean | StatsOptions;
 declare class Chunk {
 	constructor(name?: null | string, backCompat?: boolean);
 	id: null | string | number;
@@ -1629,6 +1665,10 @@ declare abstract class ChunkGroup {
 	getModuleIndex: (module: Module) => undefined | number;
 	getModuleIndex2: (module: Module) => undefined | number;
 }
+declare interface ChunkGroupInfoWithName {
+	name: string;
+	chunkGroup: ChunkGroup;
+}
 type ChunkGroupOptions = RawChunkGroupOptions & { name?: null | string };
 declare interface ChunkHashContext {
 	/**
@@ -1904,16 +1944,7 @@ declare interface CleanOptions {
 }
 declare class CleanPlugin {
 	constructor(options?: CleanOptions);
-	options: {
-		/**
-		 * Log the assets that should be removed instead of deleting them.
-		 */
-		dry: boolean;
-		/**
-		 * Keep these assets.
-		 */
-		keep?: string | RegExp | ((path: string) => undefined | boolean);
-	};
+	options: CleanOptions & { dry: boolean };
 
 	/**
 	 * Apply the plugin
@@ -1929,6 +1960,25 @@ declare interface CleanPluginCompilationHooks {
 	 */
 	keep: SyncBailHook<[string], boolean | void>;
 }
+declare interface CodeGenMapOverloads {
+	get: <K extends string>(key: K) => undefined | CodeGenValue<K>;
+	set: <K extends string>(
+		key: K,
+		value: CodeGenValue<K>
+	) => CodeGenerationResultData;
+	has: <K extends string>(key: K) => boolean;
+	delete: <K extends string>(key: K) => boolean;
+}
+type CodeGenValue<K extends string> = K extends
+	| "filename"
+	| "assetInfo"
+	| "share-init"
+	| "topLevelDeclarations"
+	| "chunkInitFragments"
+	| "url"
+	| "fullContentHash"
+	? AllCodeGenerationSchemas[K]
+	: any;
 declare interface CodeGenerationContext {
 	/**
 	 * the dependency templates
@@ -2007,15 +2057,11 @@ declare interface CodeGenerationResult {
 	 */
 	hash?: string;
 }
-type CodeGenerationResultData = Map<"topLevelDeclarations", Set<string>> &
-	Map<"chunkInitFragments", InitFragment<any>[]> &
-	Map<"url", { "css-url": string }> &
-	Map<"filename", string> &
-	Map<"assetInfo", AssetInfo> &
-	Map<"fullContentHash", string> &
-	Map<"url", { javascript: string }> &
-	Map<"share-init", [{ shareScope: string; initStage: number; init: string }]> &
-	Map<string, any>;
+type CodeGenerationResultData = Omit<
+	Map<string, any>,
+	"get" | "set" | "has" | "delete"
+> &
+	CodeGenMapOverloads;
 declare abstract class CodeGenerationResults {
 	map: Map<Module, RuntimeSpecMap<CodeGenerationResult, CodeGenerationResult>>;
 	get(module: Module, runtime: RuntimeSpec): CodeGenerationResult;
@@ -3616,7 +3662,11 @@ type CreateWriteStreamFSImplementation = FSImplementation & {
 	write: (...args: any[]) => any;
 	close?: (...args: any[]) => any;
 };
-declare interface CreatedObject<T, F> {}
+type CreatedObject<T, F> = T extends ChunkGroupInfoWithName[]
+	? Record<string, StatsChunkGroup>
+	: T extends (infer V)[]
+		? StatsObject<V, F>[]
+		: StatsObject<T, F>;
 declare interface CssData {
 	/**
 	 * whether export __esModule
@@ -4233,6 +4283,9 @@ declare interface DeterministicModuleIdsPluginOptions {
 	 */
 	failOnConflict?: boolean;
 }
+type DevtoolFallbackModuleFilenameTemplate =
+	| string
+	| ((context: ModuleFilenameTemplateContext) => string);
 type DevtoolModuleFilenameTemplate =
 	| string
 	| ((context: ModuleFilenameTemplateContext) => string);
@@ -5021,9 +5074,7 @@ declare interface EvalDevToolModulePluginOptions {
 declare class EvalSourceMapDevToolPlugin {
 	constructor(inputOptions?: string | SourceMapDevToolPluginOptions);
 	sourceMapComment: string;
-	moduleFilenameTemplate:
-		| string
-		| ((context: ModuleFilenameTemplateContext) => string);
+	moduleFilenameTemplate: DevtoolModuleFilenameTemplate;
 	namespace: string;
 	options: SourceMapDevToolPluginOptions;
 
@@ -6475,7 +6526,18 @@ declare class HarmonyImportDependency extends ModuleDependency {
 		AUTO: ExportPresenceMode;
 		ERROR: ExportPresenceMode;
 		fromUserOption(str: string | false): ExportPresenceMode;
+		/**
+		 * Resolve export presence mode from parser options with a specific key and shared fallbacks.
+		 */
+		resolveFromOptions(
+			specificValue: undefined | string | false,
+			options: JavascriptParserOptions
+		): ExportPresenceMode;
 	};
+	static getNonOptionalPart: (
+		members: string[],
+		membersOptionals: boolean[]
+	) => string[];
 	static NO_EXPORTS_REFERENCED: string[][];
 	static EXPORTS_OBJECT_REFERENCED: string[][];
 	static isLowPriorityDependency(dependency: Dependency): boolean;
@@ -10069,6 +10131,7 @@ declare interface LogEntry {
 		| "info"
 		| "log"
 		| "debug"
+		| "clear"
 		| "profile"
 		| "trace"
 		| "group"
@@ -10076,7 +10139,6 @@ declare interface LogEntry {
 		| "groupEnd"
 		| "profileEnd"
 		| "time"
-		| "clear"
 		| "status";
 	args?: any[];
 	time: number;
@@ -10088,6 +10150,7 @@ type LogTypeEnum =
 	| "info"
 	| "log"
 	| "debug"
+	| "clear"
 	| "profile"
 	| "trace"
 	| "group"
@@ -10095,7 +10158,6 @@ type LogTypeEnum =
 	| "groupEnd"
 	| "profileEnd"
 	| "time"
-	| "clear"
 	| "status";
 declare const MEASURE_END_OPERATION: unique symbol;
 declare const MEASURE_START_OPERATION: unique symbol;
@@ -10585,6 +10647,15 @@ declare class Module extends DependenciesBlock {
 		callback: (err?: WebpackError) => void
 	): void;
 	getSourceTypes(): ReadonlySet<string>;
+
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 */
+	getSourceBasicTypes(): ReadonlySet<string>;
 	source(
 		dependencyTemplates: DependencyTemplates,
 		runtimeTemplate: RuntimeTemplate,
@@ -11064,7 +11135,6 @@ declare class ModuleGraphConnection {
 	isTargetActive(runtime: RuntimeSpec): boolean;
 	getActiveState(runtime: RuntimeSpec): ConnectionState;
 	setActive(value: boolean): void;
-	active: void;
 	static CIRCULAR_CONNECTION: typeof CIRCULAR_CONNECTION;
 	static TRANSITIVE_ONLY: typeof TRANSITIVE_ONLY;
 	static addConnectionStates: (
@@ -11461,6 +11531,10 @@ declare abstract class ModuleTemplate {
 declare interface ModuleTemplates {
 	javascript: ModuleTemplate;
 }
+declare interface ModuleTrace {
+	origin: Module;
+	module: Module;
+}
 declare class MultiCompiler {
 	constructor(
 		compilers: Compiler[] | Record<string, Compiler>,
@@ -11518,12 +11592,33 @@ declare abstract class MultiStats {
 	get hash(): string;
 	hasErrors(): boolean;
 	hasWarnings(): boolean;
-	toJson(options?: string | boolean | MultiStatsOptions): StatsCompilation;
-	toString(options?: string | boolean | MultiStatsOptions): string;
+	toJson(
+		options?:
+			| boolean
+			| StatsOptions
+			| "none"
+			| "summary"
+			| "errors-only"
+			| "errors-warnings"
+			| "minimal"
+			| "normal"
+			| "detailed"
+			| "verbose"
+	): StatsCompilation;
+	toString(
+		options?:
+			| boolean
+			| StatsOptions
+			| "none"
+			| "summary"
+			| "errors-only"
+			| "errors-warnings"
+			| "minimal"
+			| "normal"
+			| "detailed"
+			| "verbose"
+	): string;
 }
-type MultiStatsOptions = Omit<StatsOptions, "children"> & {
-	children?: string | boolean | StatsOptions | ChildrenStatsOptions[];
-};
 declare abstract class MultiWatching {
 	watchings: Watching[];
 	compiler: MultiCompiler;
@@ -12209,43 +12304,43 @@ declare interface NormalizedModules {
 type NormalizedStatsOptions = KnownNormalizedStatsOptions &
 	Omit<
 		StatsOptions,
+		| "context"
+		| "chunkGroups"
+		| "requestShortener"
+		| "chunksSort"
+		| "modulesSort"
+		| "chunkModulesSort"
+		| "nestedModulesSort"
 		| "assetsSort"
-		| "assetsSpace"
+		| "ids"
 		| "cachedAssets"
+		| "groupAssetsByEmitStatus"
+		| "groupAssetsByPath"
+		| "groupAssetsByExtension"
+		| "assetsSpace"
+		| "excludeAssets"
+		| "excludeModules"
+		| "warningsFilter"
 		| "cachedModules"
+		| "orphanModules"
+		| "dependentModules"
+		| "runtimeModules"
+		| "groupModulesByCacheStatus"
+		| "groupModulesByLayer"
+		| "groupModulesByAttributes"
+		| "groupModulesByPath"
+		| "groupModulesByExtension"
+		| "groupModulesByType"
+		| "entrypoints"
 		| "chunkGroupAuxiliary"
 		| "chunkGroupChildren"
 		| "chunkGroupMaxAssets"
-		| "chunkGroups"
+		| "modulesSpace"
 		| "chunkModulesSpace"
-		| "chunksSort"
-		| "context"
-		| "dependentModules"
-		| "entrypoints"
-		| "excludeAssets"
-		| "excludeModules"
-		| "groupAssetsByEmitStatus"
-		| "groupAssetsByExtension"
-		| "groupAssetsByPath"
-		| "groupModulesByAttributes"
-		| "groupModulesByCacheStatus"
-		| "groupModulesByExtension"
-		| "groupModulesByLayer"
-		| "groupModulesByPath"
-		| "groupModulesByType"
-		| "ids"
+		| "nestedModulesSpace"
 		| "logging"
 		| "loggingDebug"
 		| "loggingTrace"
-		| "modulesSort"
-		| "modulesSpace"
-		| "nestedModulesSpace"
-		| "orphanModules"
-		| "runtimeModules"
-		| "warningsFilter"
-		| "requestShortener"
-		| "chunkModulesSort"
-		| "nestedModulesSort"
 		| "_env"
 	> &
 	Record<string, any>;
@@ -13706,34 +13801,7 @@ declare interface ParameterizedComparator<TArg extends object, T> {
 }
 declare interface ParseOptions {
 	sourceType: "module" | "script";
-	ecmaVersion?:
-		| 3
-		| 5
-		| 6
-		| 7
-		| 8
-		| 9
-		| 10
-		| 11
-		| 12
-		| 13
-		| 14
-		| 15
-		| 16
-		| 17
-		| 2015
-		| 2016
-		| 2017
-		| 2018
-		| 2019
-		| 2020
-		| 2021
-		| 2022
-		| 2023
-		| 2024
-		| 2025
-		| 2026
-		| "latest";
+	ecmaVersion: ecmaVersion;
 	locations?: boolean;
 	comments?: boolean;
 	ranges?: boolean;
@@ -14107,7 +14175,7 @@ declare class ProgressPlugin {
 	showModules?: boolean;
 	showDependencies?: boolean;
 	showActiveModules?: boolean;
-	percentBy?: null | "modules" | "entries" | "dependencies";
+	percentBy?: null | "entries" | "modules" | "dependencies";
 	apply(compiler: MultiCompiler | Compiler): void;
 	static getReporter(
 		compiler: Compiler
@@ -14172,7 +14240,7 @@ declare interface ProgressPluginOptions {
 	/**
 	 * Collect percent algorithm. By default it calculates by a median from modules, entries and dependencies percent.
 	 */
-	percentBy?: null | "modules" | "entries" | "dependencies";
+	percentBy?: null | "entries" | "modules" | "dependencies";
 
 	/**
 	 * Collect profile data for progress steps. Default: false.
@@ -17321,17 +17389,13 @@ declare interface SourceLike {
 }
 declare class SourceMapDevToolPlugin {
 	constructor(options?: SourceMapDevToolPluginOptions);
-	sourceMapFilename: string | false;
+	sourceMapFilename?: null | string | false;
 	sourceMappingURLComment:
 		| string
 		| false
 		| ((pathData: PathData, assetInfo?: AssetInfo) => string);
-	moduleFilenameTemplate:
-		| string
-		| ((context: ModuleFilenameTemplateContext) => string);
-	fallbackModuleFilenameTemplate:
-		| string
-		| ((context: ModuleFilenameTemplateContext) => string);
+	moduleFilenameTemplate: DevtoolModuleFilenameTemplate;
+	fallbackModuleFilenameTemplate: DevtoolFallbackModuleFilenameTemplate;
 	namespace: string;
 	options: SourceMapDevToolPluginOptions;
 
@@ -17435,7 +17499,7 @@ declare class SourceMapSource extends Source {
 		name: string,
 		sourceMap?: string | Buffer | RawSourceMap,
 		originalSource?: string | Buffer,
-		innerSourceMap?: string | Buffer | RawSourceMap,
+		innerSourceMap?: null | string | Buffer | RawSourceMap,
 		removeOriginalSource?: boolean
 	);
 	getArgsAsBuffers(): [
@@ -17734,8 +17798,32 @@ declare class Stats {
 	get endTime(): number;
 	hasWarnings(): boolean;
 	hasErrors(): boolean;
-	toJson(options?: string | boolean | StatsOptions): StatsCompilation;
-	toString(options?: string | boolean | StatsOptions): string;
+	toJson(
+		options?:
+			| boolean
+			| StatsOptions
+			| "none"
+			| "summary"
+			| "errors-only"
+			| "errors-warnings"
+			| "minimal"
+			| "normal"
+			| "detailed"
+			| "verbose"
+	): StatsCompilation;
+	toString(
+		options?:
+			| boolean
+			| StatsOptions
+			| "none"
+			| "summary"
+			| "errors-only"
+			| "errors-warnings"
+			| "minimal"
+			| "normal"
+			| "detailed"
+			| "verbose"
+	): string;
 }
 type StatsAsset = KnownStatsAsset & Record<string, any>;
 type StatsChunk = KnownStatsChunk & Record<string, any>;
@@ -17793,6 +17881,29 @@ type StatsModuleReason = KnownStatsModuleReason & Record<string, any>;
 type StatsModuleTraceDependency = KnownStatsModuleTraceDependency &
 	Record<string, any>;
 type StatsModuleTraceItem = KnownStatsModuleTraceItem & Record<string, any>;
+type StatsObject<T, F> = T extends Compilation
+	? StatsCompilation
+	: T extends ChunkGroupInfoWithName
+		? StatsChunkGroup
+		: T extends Chunk
+			? StatsChunk
+			: T extends OriginRecord
+				? StatsChunkOrigin
+				: T extends Module
+					? StatsModule
+					: T extends ModuleGraphConnection
+						? StatsModuleReason
+						: T extends Asset
+							? StatsAsset
+							: T extends ModuleTrace
+								? StatsModuleTraceItem
+								: T extends Dependency
+									? StatsModuleTraceDependency
+									: T extends Error
+										? StatsError
+										: T extends ModuleProfile
+											? StatsProfile
+											: F;
 
 /**
  * Stats options object.
@@ -18465,6 +18576,11 @@ declare interface TsconfigOptions {
 	 * References to other tsconfig files. 'auto' inherits from TypeScript config, or an array of relative/absolute paths
 	 */
 	references?: string[] | "auto";
+
+	/**
+	 * Override baseUrl from tsconfig.json. If provided, this value will be used instead of the baseUrl in the tsconfig file
+	 */
+	baseUrl?: string;
 }
 declare interface TsconfigPathsData {
 	/**
@@ -19292,6 +19408,34 @@ declare interface chunkModuleHashMap {
 	[index: number]: string;
 	[index: string]: string;
 }
+type ecmaVersion =
+	| 3
+	| 5
+	| 6
+	| 7
+	| 8
+	| 9
+	| 10
+	| 11
+	| 12
+	| 13
+	| 14
+	| 15
+	| 16
+	| 17
+	| 2015
+	| 2016
+	| 2017
+	| 2018
+	| 2019
+	| 2020
+	| 2021
+	| 2022
+	| 2023
+	| 2024
+	| 2025
+	| 2026
+	| "latest";
 declare function exports(
 	options: Configuration,
 	callback: CallbackWebpackFunction_2<Stats, void>
@@ -20025,7 +20169,7 @@ declare namespace exports {
 		MultiCompilerOptions,
 		MultiConfiguration,
 		MultiStats,
-		MultiStatsOptions,
+		StatsOptions as MultiStatsOptions,
 		ResolveData,
 		ParserState,
 		ResolvePluginInstance,