webpack 5.108.4 → 5.109.1

package/lib/loaders/loadLoader.js

@@ -0,0 +1,100 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { pathToFileURL } = require("url");
+const LoaderLoadingError = require("../errors/LoaderLoadingError");
+
+/** @typedef {import("./LoaderRunner").LoaderObject} LoaderObject */
+
+/**
+ * Lazily-compiled dynamic `import()`. Built on first use so this file still
+ * parses on Node versions without native `import()` (<13.2), then reused.
+ * @type {((url: URL) => Promise<EXPECTED_ANY>) | undefined}
+ */
+let importModule;
+
+/**
+ * @param {LoaderObject} loader the loader to load into
+ * @param {EXPECTED_ANY} module the loaded module
+ * @param {(err?: Error) => void} callback callback
+ * @returns {void}
+ */
+function handleResult(loader, module, callback) {
+	if (typeof module !== "function" && typeof module !== "object") {
+		return callback(
+			new LoaderLoadingError(
+				`Module '${loader.path}' is not a loader (export function or es6 module)`
+			)
+		);
+	}
+
+	loader.normal = typeof module === "function" ? module : module.default;
+	loader.pitch = module.pitch;
+	loader.raw = module.raw;
+
+	if (
+		typeof loader.normal !== "function" &&
+		typeof loader.pitch !== "function"
+	) {
+		return callback(
+			new LoaderLoadingError(
+				`Module '${loader.path}' is not a loader (must have normal or pitch function)`
+			)
+		);
+	}
+	callback();
+}
+
+/**
+ * @param {LoaderObject} loader the loader to load
+ * @param {(err?: Error) => void} callback callback
+ * @returns {void}
+ */
+function loadLoader(loader, callback) {
+	if (loader.type === "module") {
+		try {
+			if (importModule === undefined) {
+				// `eval` defers parsing `import()` to runtime, so this file stays
+				// loadable on Node versions that can't parse it (<13.2).
+				// eslint-disable-next-line no-eval
+				const dynamicImport = eval("(url) => import(url)");
+				importModule = /** @type {(url: URL) => Promise<EXPECTED_ANY>} */ (
+					dynamicImport
+				);
+			}
+
+			importModule(pathToFileURL(loader.path)).then(
+				(/** @type {EXPECTED_ANY} */ module) => {
+					handleResult(loader, module, callback);
+				},
+				callback
+			);
+		} catch (err) {
+			callback(/** @type {Error} */ (err));
+		}
+		return;
+	}
+
+	let loadedModule;
+	try {
+		loadedModule = require(loader.path);
+	} catch (err) {
+		// node can choke on require when the FD limit is hit; defer to recover.
+		if (
+			err instanceof Error &&
+			/** @type {NodeJS.ErrnoException} */ (err).code === "EMFILE"
+		) {
+			setImmediate(loadLoader, loader, callback);
+			return;
+		}
+		return callback(/** @type {Error} */ (err));
+	}
+
+	return handleResult(loader, loadedModule, callback);
+}
+
+module.exports = loadLoader;

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -8,12 +8,21 @@
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { getPresentKinds } = require("../TemplatedPathPlugin");
 const AsyncWasmCompileRuntimeModule = require("../wasm-async/AsyncWasmCompileRuntimeModule");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
+ * that runtime module must be requested (`[hash]` is the per-module hash here).
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} whether it references the compilation `[fullhash]`
+ */
+const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+
 /**
  * Defines the read file compile async wasm plugin options type used by this module.
  * @typedef {object} ReadFileCompileAsyncWasmPluginOptions
@@ -68,7 +77,11 @@ class ReadFileCompileAsyncWasmPlugin {
 									"",
 									"// Fake fetch response",
 									"resolve({",
-									Template.indent(["arrayBuffer() { return buffer; }"]),
+									Template.indent([
+										// Return a real ArrayBuffer: some runtimes (e.g. Deno)
+										// reject a Node Buffer view here as "not a buffer source".
+										"arrayBuffer() { return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); }"
+									]),
 									"});"
 								]),
 								"});"
@@ -90,7 +103,11 @@ class ReadFileCompileAsyncWasmPlugin {
 										"",
 										"// Fake fetch response",
 										"resolve({",
-										Template.indent(["arrayBuffer() { return buffer; }"]),
+										Template.indent([
+											// Return a real ArrayBuffer: some runtimes (e.g. Deno)
+											// reject a Node Buffer view here as "not a buffer source".
+											"arrayBuffer() { return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); }"
+										]),
 										"});"
 									]),
 									"});"
@@ -112,6 +129,11 @@ class ReadFileCompileAsyncWasmPlugin {
 					) {
 						return;
 					}
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmLoadingRuntimeModule({
@@ -133,6 +155,11 @@ class ReadFileCompileAsyncWasmPlugin {
 					) {
 						return;
 					}
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmCompileRuntimeModule({

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -8,11 +8,20 @@
 const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { getPresentKinds } = require("../TemplatedPathPlugin");
 const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
+ * that runtime module must be requested (`[hash]` is the per-module hash here).
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} whether it references the compilation `[fullhash]`
+ */
+const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+
 /**
  * Defines the read file compile wasm plugin options type used by this module.
  * @typedef {object} ReadFileCompileWasmPluginOptions
@@ -68,7 +77,11 @@ class ReadFileCompileWasmPlugin {
 									"",
 									"// Fake fetch response",
 									"resolve({",
-									Template.indent(["arrayBuffer() { return buffer; }"]),
+									Template.indent([
+										// Return a real ArrayBuffer: some runtimes (e.g. Deno)
+										// reject a Node Buffer view here as "not a buffer source".
+										"arrayBuffer() { return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); }"
+									]),
 									"});"
 								]),
 								"});"
@@ -90,7 +103,11 @@ class ReadFileCompileWasmPlugin {
 										"",
 										"// Fake fetch response",
 										"resolve({",
-										Template.indent(["arrayBuffer() { return buffer; }"]),
+										Template.indent([
+											// Return a real ArrayBuffer: some runtimes (e.g. Deno)
+											// reject a Node Buffer view here as "not a buffer source".
+											"arrayBuffer() { return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); }"
+										]),
 										"});"
 									]),
 									"});"
@@ -113,6 +130,11 @@ class ReadFileCompileWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.moduleCache);
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new WasmChunkLoadingRuntimeModule({

package/lib/optimize/AggressiveMergingPlugin.js

@@ -53,8 +53,16 @@ class AggressiveMergingPlugin {
 				},
 				(chunks) => {
 					const chunkGraph = compilation.chunkGraph;
-					/** @type {{ a: Chunk, b: Chunk, improvement: number }[]} */
-					const combinations = [];
+					// Only the single best pair is merged per pass (the hook re-runs
+					// after each merge), so track the max directly instead of building
+					// and sorting the full O(chunks²) list of pairs every pass. A strict
+					// `>` keeps the first-encountered best, matching the previous stable
+					// descending sort's `[0]`.
+					/** @type {Chunk | undefined} */
+					let bestA;
+					/** @type {Chunk | undefined} */
+					let bestB;
+					let bestImprovement = -Infinity;
 					for (const a of chunks) {
 						if (a.canBeInitial()) continue;
 						for (const b of chunks) {
@@ -73,23 +81,19 @@ class AggressiveMergingPlugin {
 								chunkOverhead: 0
 							});
 							const improvement = (aSize + bSize) / abSize;
-							combinations.push({
-								a,
-								b,
-								improvement
-							});
+							if (improvement > bestImprovement) {
+								bestImprovement = improvement;
+								bestA = a;
+								bestB = b;
+							}
 						}
 					}
 
-					combinations.sort((a, b) => b.improvement - a.improvement);
-
-					const pair = combinations[0];
-
-					if (!pair) return;
-					if (pair.improvement < minSizeReduce) return;
+					if (bestA === undefined) return;
+					if (bestImprovement < minSizeReduce) return;
 
-					chunkGraph.integrateChunks(pair.b, pair.a);
-					compilation.chunks.delete(pair.a);
+					chunkGraph.integrateChunks(/** @type {Chunk} */ (bestB), bestA);
+					compilation.chunks.delete(bestA);
 					return true;
 				}
 			);

package/lib/optimize/ConcatenatedModule.js

@@ -26,8 +26,11 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { DEFAULTS } = require("../config/defaults");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
+const { isCommonJsWrapped } = require("../javascript/JavascriptGenerator");
 const JavascriptParser = require("../javascript/JavascriptParser");
 const {
+	getDeferredCycleModuleIds,
+	getDeferredCycleModules,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
@@ -82,6 +85,7 @@ const { InlinedUsedName } = require("./InlineExports");
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../RequestShortener")} RequestShortener */
@@ -95,6 +99,7 @@ const { InlinedUsedName } = require("./InlineExports");
 /** @typedef {import("../javascript/JavascriptModulesPlugin").Variable} Variable */
 /** @typedef {import("../javascript/JavascriptParser").Program} Program */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/Hash").HashFunction} HashFunction */
@@ -153,6 +158,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {"concatenated"} type
  * @property {Module} module
  * @property {number} index
+ * @property {boolean=} cjsWrapped a "weird" CommonJS module executed via the CJS wrapper runtime helper with real module/exports objects
  * @property {Program | undefined} ast
  * @property {Source | undefined} internalSource
  * @property {ReplaceSource | undefined} source
@@ -354,6 +360,9 @@ const getFinalBinding = (
 	if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
+				// a concatenated CommonJS module has no runtime exports object;
+				// its fake namespace is built over the generated namespace object
+				if (info.type === "concatenated") neededNamespaceObjects.add(info);
 				if (deferred) info.deferredNamespaceObjectUsed = true;
 				else info.interopNamespaceObject2Used = true;
 				return {
@@ -367,6 +376,7 @@ const getFinalBinding = (
 					exportName
 				};
 			case "default-with-named":
+				if (info.type === "concatenated") neededNamespaceObjects.add(info);
 				if (deferred) info.deferredNamespaceObjectUsed = true;
 				else info.interopNamespaceObjectUsed = true;
 				return {
@@ -657,7 +667,9 @@ const getFinalBinding = (
 					alreadyVisited
 				);
 			}
-			if (info.namespaceExportSymbol) {
+			// A wrapped module resolves every export through its live exports
+			// alias (namespaceObjectName), same as namespaceExportSymbol modules.
+			if (info.namespaceExportSymbol || info.cjsWrapped) {
 				const usedName = /** @type {ExportName} */ (
 					exportsInfo.getUsedName(exportName, runtime)
 				);
@@ -985,20 +997,32 @@ class ConcatenatedModule extends Module {
 
 		for (const m of this._modules) {
 			// populate cacheable
-			if (!(/** @type {BuildInfo} */ (m.buildInfo).cacheable)) {
+			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
+				m.buildInfo
+			);
+			if (!cacheable) {
 				this.buildInfo.cacheable = false;
+				if (notCacheableReasons) {
+					const reasons =
+						this.buildInfo.notCacheableReasons ||
+						(this.buildInfo.notCacheableReasons = []);
+					for (const reason of notCacheableReasons) {
+						if (!reasons.includes(reason)) reasons.push(reason);
+					}
+				}
 			}
 
-			// populate dependencies
-			for (const d of m.dependencies.filter(
-				(dep) =>
-					!Dependency.canConcatenate(dep) ||
+			// populate dependencies — keep only deps that leave the concat set
+			for (const d of m.dependencies) {
+				if (
+					!Dependency.canConcatenate(d) ||
 					!this._modules.has(
 						/** @type {Module} */
-						(compilation.moduleGraph.getModule(dep))
+						(compilation.moduleGraph.getModule(d))
 					)
-			)) {
-				this.dependencies.push(d);
+				) {
+					this.dependencies.push(d);
+				}
 			}
 			// populate codeGenerationDependencies — the inner modules'
 			// templates are applied during ConcatenatedModule.codeGeneration,
@@ -1517,7 +1541,7 @@ class ConcatenatedModule extends Module {
 
 		// get all global names
 		for (const info of modulesWithInfo) {
-			if (info.type === "concatenated") {
+			if (info.type === "concatenated" && !info.cjsWrapped) {
 				// ignore symbols from moduleScope
 				if (info.moduleScope) {
 					ignoredScopes.add(info.moduleScope);
@@ -1707,6 +1731,23 @@ class ConcatenatedModule extends Module {
 			);
 			switch (info.type) {
 				case "concatenated": {
+					if (info.cjsWrapped) {
+						// Wrapped modules expose one shared-scope name: the final
+						// exports object used as the namespace.
+						const namespaceObjectName = findNewName(
+							"namespaceObject",
+							allUsedNames,
+							namespaceObjectUsedNames,
+							info.module.readableIdentifier(requestShortener)
+						);
+						allUsedNames.add(namespaceObjectName);
+						topLevelDeclarations.add(namespaceObjectName);
+						info.namespaceObjectName = namespaceObjectName;
+						// Route every binding to the live exports alias and skip the
+						// materialized namespace object generated for other modules.
+						info.namespaceExportSymbol = namespaceObjectName;
+						break;
+					}
 					const variables = /** @type {Scope} */ (info.moduleScope).variables;
 					for (const variable of variables) {
 						const name = variable.name;
@@ -1714,10 +1755,12 @@ class ConcatenatedModule extends Module {
 						const newName = _findNewName(name, info, references);
 						if (newName) {
 							const source = /** @type {ReplaceSource} */ (info.source);
-							const allIdentifiers = new Set([
-								...references.map((r) => r.identifier),
-								...variable.identifiers
-							]);
+							/** @type {Set<Identifier>} */
+							const allIdentifiers = new Set();
+							for (const r of references) allIdentifiers.add(r.identifier);
+							for (const identifier of variable.identifiers) {
+								allIdentifiers.add(identifier);
+							}
 							for (const identifier of allIdentifiers) {
 								const r = /** @type {Range} */ (identifier.range);
 								const path = getPathInAst(
@@ -1843,18 +1886,18 @@ class ConcatenatedModule extends Module {
 
 		// Find and replace references to modules
 		for (const info of moduleToInfoMap.values()) {
-			if (info.type === "concatenated") {
+			if (info.type === "concatenated" && !info.cjsWrapped) {
 				const globalScope = /** @type {Scope} */ (info.globalScope);
 				// group references by name
 				/** @type {Map<string, Reference[]>} */
 				const referencesByName = new Map();
 				for (const reference of globalScope.through) {
 					const name = reference.identifier.name;
-					if (!referencesByName.has(name)) {
-						referencesByName.set(name, []);
+					let references = referencesByName.get(name);
+					if (references === undefined) {
+						referencesByName.set(name, (references = []));
 					}
-					/** @type {Reference[]} */
-					(referencesByName.get(name)).push(reference);
+					references.push(reference);
 				}
 				for (const [name, references] of referencesByName) {
 					const match = ConcatenationScope.matchModuleReference(name);
@@ -2081,7 +2124,9 @@ class ConcatenatedModule extends Module {
 				if (!usedName) continue;
 				if (usedName instanceof InlinedUsedName) {
 					nsObj.push(
-						`\n  ${propertyName(exportInfo.name)}: ${runtimeTemplate.returningFunction(
+						`\n  ${propertyName(
+							exportInfo.name
+						)}: ${runtimeTemplate.returningFunction(
 							usedName.render(
 								Template.toNormalComment(
 									`inlined export ${propertyAccess([exportInfo.name])}`
@@ -2094,7 +2139,9 @@ class ConcatenatedModule extends Module {
 					// import variable; concatenated ones resolve to an internal binding.
 					const finalName =
 						info.type === "external"
-							? `${/** @type {string} */ (info.name)}${propertyAccess([usedName])}`
+							? `${/** @type {string} */ (info.name)}${propertyAccess([
+									usedName
+								])}`
 							: getFinalName(
 									moduleGraph,
 									info,
@@ -2112,9 +2159,9 @@ class ConcatenatedModule extends Module {
 									true
 								);
 					nsObj.push(
-						`\n  ${propertyName(exportInfo.name)}: ${runtimeTemplate.returningFunction(
-							finalName
-						)}`
+						`\n  ${propertyName(
+							exportInfo.name
+						)}: ${runtimeTemplate.returningFunction(finalName)}`
 					);
 				}
 			}
@@ -2131,7 +2178,9 @@ class ConcatenatedModule extends Module {
 			escapeNamespaceObjectSources.set(
 				info,
 				`
-// NAMESPACE OBJECT (decoupled): ${info.module.readableIdentifier(requestShortener)}
+// NAMESPACE OBJECT (decoupled): ${info.module.readableIdentifier(
+					requestShortener
+				)}
 var ${name} = {};
 ${RuntimeGlobals.makeNamespaceObject}(${name});
 ${defineGetters}`
@@ -2154,7 +2203,9 @@ ${defineGetters}`
 					// TODO: Replace with the inlined value directly at the call site
 					if (usedName instanceof InlinedUsedName) {
 						nsObj.push(
-							`\n  ${propertyName(exportInfo.name)}: ${runtimeTemplate.returningFunction(
+							`\n  ${propertyName(
+								exportInfo.name
+							)}: ${runtimeTemplate.returningFunction(
 								usedName.render(
 									Template.toNormalComment(
 										`inlined export ${propertyAccess([exportInfo.name])}`
@@ -2180,9 +2231,9 @@ ${defineGetters}`
 							true
 						);
 						nsObj.push(
-							`\n  ${propertyName(usedName)}: ${runtimeTemplate.returningFunction(
-								finalName
-							)}`
+							`\n  ${propertyName(
+								usedName
+							)}: ${runtimeTemplate.returningFunction(finalName)}`
 						);
 					}
 				}
@@ -2232,6 +2283,16 @@ ${defineGetters}`
 					),
 					// an async module will opt-out of the concat module optimization.
 					[],
+					// A closure member absorbed into this concatenation shares this
+					// module's runtime id (and thus its `evaluating` flag); resolve it
+					// to that id instead of the member's now-absent standalone id.
+					getDeferredCycleModuleIds(
+						getDeferredCycleModules(moduleGraph, info.module),
+						(mod) =>
+							moduleToInfoMap.has(mod)
+								? chunkGraph.getModuleId(this)
+								: chunkGraph.getModuleId(mod)
+					),
 					runtimeRequirements
 				);
 				runtimeRequirements.add(RuntimeGlobals.require);
@@ -2269,7 +2330,18 @@ ${defineGetters}`
 					result.add(
 						`\n;// ${info.module.readableIdentifier(requestShortener)}\n`
 					);
-					result.add(/** @type {ReplaceSource} */ (info.source));
+					if (info.cjsWrapped) {
+						// Real CommonJS semantics via the runtime helper: it calls the
+						// body with this = exports and returns the final module.exports.
+						runtimeRequirements.add(RuntimeGlobals.commonJsWrap);
+						result.add(
+							`var ${info.namespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.commonJsWrap}(function(${info.module.moduleArgument}, ${info.module.exportsArgument}) {\n`
+						);
+						result.add(/** @type {ReplaceSource} */ (info.source));
+						result.add("\n});\n");
+					} else {
+						result.add(/** @type {ReplaceSource} */ (info.source));
+					}
 					if (info.chunkInitFragments) {
 						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
 					}
@@ -2403,6 +2475,33 @@ ${defineGetters}`
 		if (info.type === "concatenated") {
 			const m = info.module;
 			try {
+				if (info.cjsWrapped) {
+					// A wrapped module renders its normal module source (real
+					// module/exports objects, own module ids) inside an IIFE, so it
+					// needs no concatenation scope, reference rewriting, or scope
+					// analysis — the wrapper isolates its top-level declarations.
+					const codeGenResult = m.codeGeneration({
+						dependencyTemplates,
+						runtimeTemplate,
+						moduleGraph,
+						chunkGraph,
+						runtime,
+						runtimes,
+						codeGenerationResults,
+						sourceTypes: JAVASCRIPT_TYPES
+					});
+					const source =
+						/** @type {Source} */
+						(codeGenResult.sources.get(JAVASCRIPT_TYPE));
+					const data = codeGenResult.data;
+					info.runtimeRequirements =
+						/** @type {ReadOnlyRuntimeRequirements} */
+						(codeGenResult.runtimeRequirements);
+					info.internalSource = source;
+					info.source = new ReplaceSource(source);
+					info.chunkInitFragments = data && data.get("chunkInitFragments");
+					return;
+				}
 				// Create a concatenation scope to track and capture information
 				const concatenationScope = new ConcatenationScope(
 					modulesMap,
@@ -2434,11 +2533,17 @@ ${defineGetters}`
 				let ast;
 
 				try {
+					const { experiments } = this.compilation.options;
+
 					({ ast } = JavascriptParser._parse(
 						code,
 						{
 							sourceType: "module",
-							ranges: true
+							ranges: true,
+							// generated code contains phase imports when the experiments are on
+							importPhases: Boolean(
+								experiments.deferImport || experiments.sourceImport
+							)
 						},
 						JavascriptParser._getModuleParseFunction(this.compilation, m)
 					));
@@ -2511,6 +2616,9 @@ ${defineGetters}`
 							type: "concatenated",
 							module: info.module,
 							index,
+							cjsWrapped: isCommonJsWrapped(
+								/** @type {NormalModule} */ (info.module)
+							),
 							ast: undefined,
 							chunkInitFragments: undefined,
 							internalSource: undefined,

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -76,6 +76,12 @@ class FlagIncludedChunksPlugin {
 					chunkModulesHash.set(chunk, hash);
 				}
 
+				// Chunks that received an included id and need their `ids` re-sorted
+				// once, after all pushes — instead of re-sorting on every push
+				// inside the nested loop below (https://github.com/webpack/webpack/issues/18837).
+				/** @type {Set<Chunk>} */
+				const chunksWithIncludedIds = new Set();
+
 				for (const chunkA of chunks) {
 					const chunkAHash =
 						/** @type {number} */
@@ -125,11 +131,15 @@ class FlagIncludedChunksPlugin {
 
 						/** @type {ChunkId[]} */
 						(chunkB.ids).push(/** @type {ChunkId} */ (chunkA.id));
-						// https://github.com/webpack/webpack/issues/18837
-						/** @type {ChunkId[]} */
-						(chunkB.ids).sort(compareIds);
+						chunksWithIncludedIds.add(chunkB);
 					}
 				}
+
+				// Sort each affected chunk's ids once (https://github.com/webpack/webpack/issues/18837).
+				for (const chunk of chunksWithIncludedIds) {
+					/** @type {ChunkId[]} */
+					(chunk.ids).sort(compareIds);
+				}
 			});
 		});
 	}