webpack 5.111.0 → 5.112.0

package/lib/dependencies/{HtmlInlineScriptDependency.js → html/HtmlInlineScriptDependency.js}

@@ -4,27 +4,28 @@
 
 "use strict";
 
-const makeSerializable = require("../util/makeSerializable");
-const memoize = require("../util/memoize");
-const ModuleDependency = require("./ModuleDependency");
+const makeSerializable = require("../../util/makeSerializable");
+const memoize = require("../../util/memoize");
+const ModuleDependency = require("../core/ModuleDependency");
 
 // only the template needs it, and that runs only for a real html module
-const getHtmlGenerator = memoize(() => require("../html/HtmlGenerator"));
+const getHtmlGenerator = memoize(() => require("../../html/HtmlGenerator"));
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import Chunk from "../Chunk" */
-/** @import Dependency from "../Dependency" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import Entrypoint from "../Entrypoint" */
-/** @import { Range } from "../javascript/JavascriptParser" */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[number, Range, string, string]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[number, Range, string, string]>} ObjectSerializerContext */
+/** @import Chunk from "../../graph/Chunk" */
+/** @import Dependency from "../../graph/Dependency" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import Entrypoint from "../../graph/Entrypoint" */
+/** @import { Range } from "../../javascript/JavascriptParser" */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectDeserializerContext<[number, Range, string, string, Range | undefined, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectSerializerContext<[number, Range, string, string, Range | undefined, boolean]>} ObjectSerializerContext */
 
 /**
  * Represents an inline `<script>...</script>` block in an HTML module. The
  * tag's body is bundled as its own entry chunk — the same pipeline that
  * processes `<script src>` — and the inline body is replaced with a
- * `src` attribute pointing at the emitted chunk URL.
+ * `src` attribute pointing at the emitted chunk URL. A tag sharing an
+ * earlier tag's entry carries a `removeRange` and is dropped instead.
  */
 class HtmlInlineScriptDependency extends ModuleDependency {
 	/**
@@ -34,8 +35,18 @@ class HtmlInlineScriptDependency extends ModuleDependency {
 	 * @param {Range} contentRange range of the inline JS body (between `<script>` and `</script>`)
 	 * @param {string} entryName name of the entry the inline JS is bundled into
 	 * @param {string=} category dependency category used for resolving and grouping
+	 * @param {Range=} removeRange range of the whole element, when the tag is dropped
+	 * @param {boolean=} forceInline `<!-- webpackInline: true -->` was set before this tag
 	 */
-	constructor(request, insertPos, contentRange, entryName, category) {
+	constructor(
+		request,
+		insertPos,
+		contentRange,
+		entryName,
+		category,
+		removeRange,
+		forceInline
+	) {
 		super(request);
 		/** @type {number} */
 		this.insertPos = insertPos;
@@ -45,6 +56,10 @@ class HtmlInlineScriptDependency extends ModuleDependency {
 		this.entryName = entryName;
 		/** @type {string} */
 		this._category = category || "commonjs";
+		/** @type {Range | undefined} */
+		this.removeRange = removeRange;
+		/** @type {boolean} */
+		this.forceInline = forceInline === true;
 	}
 
 	get type() {
@@ -64,7 +79,9 @@ class HtmlInlineScriptDependency extends ModuleDependency {
 			.write(this.insertPos)
 			.write(this.contentRange)
 			.write(this.entryName)
-			.write(this._category);
+			.write(this._category)
+			.write(this.removeRange)
+			.write(this.forceInline);
 		super.serialize(context);
 	}
 
@@ -81,7 +98,11 @@ class HtmlInlineScriptDependency extends ModuleDependency {
 		this.entryName = c2.read();
 		const c3 = c2.rest;
 		this._category = c3.read();
-		super.deserialize(c3.rest);
+		const c4 = c3.rest;
+		this.removeRange = c4.read();
+		const c5 = c4.rest;
+		this.forceInline = c5.read();
+		super.deserialize(c5.rest);
 	}
 }
 
@@ -96,8 +117,12 @@ HtmlInlineScriptDependency.Template = class HtmlInlineScriptDependencyTemplate e
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const { runtimeTemplate } = templateContext;
+		const { runtimeTemplate, chunkGraph, module } = templateContext;
 		const dep = /** @type {HtmlInlineScriptDependency} */ (dependency);
+		if (dep.removeRange) {
+			source.replace(dep.removeRange[0], dep.removeRange[1] - 1, "");
+			return;
+		}
 		const compilation = runtimeTemplate.compilation;
 		const entrypoint = /** @type {Entrypoint | undefined} */ (
 			compilation.entrypoints.get(dep.entryName)
@@ -108,22 +133,46 @@ HtmlInlineScriptDependency.Template = class HtmlInlineScriptDependencyTemplate e
 
 		if (entrypoint) {
 			const chunk = /** @type {Chunk} */ (entrypoint.getEntrypointChunk());
+			// A sentinel only resolves in a page webpack emits; exported as a JS
+			// string it would ride along unresolved.
+			const isExtractedHtml = chunkGraph
+				.getModuleSourceTypes(module)
+				.has("html");
+			if (
+				isExtractedHtml &&
+				getHtmlGenerator().canInlineChunk(compilation, chunk) &&
+				(dep.forceInline ||
+					getHtmlGenerator().isChunkInlined(
+						compilation.outputOptions.html,
+						chunk,
+						"javascript"
+					))
+			) {
+				// The tag stays as written and its body becomes the chunk's code, so
+				// the run costs no request.
+				source.replace(
+					dep.contentRange[0],
+					dep.contentRange[1] - 1,
+					getHtmlGenerator().makeChunkInlineSentinel(chunk, "javascript")
+				);
+				return;
+			}
 			// Defer chunk-URL substitution to renderManifest — chunk hashes aren't ready yet.
 			url = getHtmlGenerator().makeChunkUrlSentinel(chunk, "javascript");
 		}
 
-		// Insert ` src="…"` right after `<script` so the inline body is
-		// served from the emitted chunk instead. The browser ignores the
-		// remaining inline body once `src` is present, but we still clear
-		// it below so the unprocessed JS doesn't ride along.
+		// Insert ` src="…"` just after `<script`, serving the body from the emitted
+		// chunk. The browser ignores an inline body beside `src`, but it is cleared
+		// below so the unprocessed JS does not ride along.
 		source.insert(dep.insertPos, ` src="${url}"`);
 		source.replace(dep.contentRange[0], dep.contentRange[1] - 1, "");
 	}
 };
 
-makeSerializable(
-	HtmlInlineScriptDependency,
+makeSerializable(HtmlInlineScriptDependency, [
+	"webpack/lib/dependencies/html/HtmlInlineScriptDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/HtmlInlineScriptDependency"
-);
+]);
 
 module.exports = HtmlInlineScriptDependency;

package/lib/dependencies/{HtmlInlineStyleDependency.js → html/HtmlInlineStyleDependency.js}

@@ -4,19 +4,19 @@
 
 "use strict";
 
-const { CSS_TEXT_TYPE } = require("../ModuleSourceTypeConstants");
-const makeSerializable = require("../util/makeSerializable");
-const ModuleDependency = require("./ModuleDependency");
+const { CSS_TEXT_TYPE } = require("../../module/ModuleSourceTypeConstants");
+const makeSerializable = require("../../util/makeSerializable");
+const ModuleDependency = require("../core/ModuleDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import CodeGenerationResults from "../CodeGenerationResults" */
-/** @import Dependency, { UpdateHashContext } from "../Dependency" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import Module from "../Module" */
-/** @import { Range } from "../javascript/JavascriptParser" */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<boolean[]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<boolean[]>} ObjectSerializerContext */
-/** @import Hash from "../util/Hash" */
+/** @import CodeGenerationResults from "../../module/CodeGenerationResults" */
+/** @import Dependency, { UpdateHashContext } from "../../graph/Dependency" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import Module from "../../module/Module" */
+/** @import { Range } from "../../javascript/JavascriptParser" */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectDeserializerContext<boolean[]>} ObjectDeserializerContext */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectSerializerContext<boolean[]>} ObjectSerializerContext */
+/** @import Hash from "../../util/Hash" */
 
 const TRAILING_WHITESPACE_REGEXP = /\s+$/;
 // One pass over the source: each char is replaced once and replacements aren't
@@ -31,6 +31,18 @@ const ATTR_ESCAPES = { "&": "&amp;", '"': "&quot;", "'": "&#39;" };
  */
 const escapeAttrChar = (c) => ATTR_ESCAPES[c];
 
+// Character data needs only the two that open markup: `&` starts a character
+// reference and `<` a tag. A CR is written as a reference because §13.2.3.5
+// rewrites a literal one to LF before the tokenizer reads it.
+const TEXT_ESCAPE_REGEXP = /[&<\r]/g;
+/** @type {Record<string, string>} */
+const TEXT_ESCAPES = { "&": "&amp;", "<": "&lt;", "\r": "&#13;" };
+/**
+ * @param {string} c matched character
+ * @returns {string} the HTML-text-escaped entity
+ */
+const escapeTextChar = (c) => TEXT_ESCAPES[c];
+
 /**
  * Represents inline CSS in an HTML module — either a `<style>...</style>`
  * block (a stylesheet) or an element's `style="..."` attribute (a CSS
@@ -47,14 +59,23 @@ class HtmlInlineStyleDependency extends ModuleDependency {
 	 * @param {Range} range range of the inline CSS content (between `<style>` and `</style>`, or the `style` attribute value)
 	 * @param {boolean=} attribute true when the source is a `style="..."` attribute (a block's contents) rather than a `<style>` block (stylesheet)
 	 * @param {boolean=} inAttribute true when the range is an attribute value (decoded on parse, so the processed CSS must be re-escaped on write-back); defaults to `attribute` — differs only for attribute values parsed as full stylesheets
+	 * @param {boolean=} characterData true when the range is a `<style>` body in a foreign (SVG/MathML) subtree, where the content model is character data rather than raw text, so the processed CSS is escaped as text on write-back
 	 */
-	constructor(request, range, attribute = false, inAttribute = attribute) {
+	constructor(
+		request,
+		range,
+		attribute = false,
+		inAttribute = attribute,
+		characterData = false
+	) {
 		super(request);
 		this.range = range;
 		/** @type {boolean} */
 		this.attribute = attribute;
 		/** @type {boolean} */
 		this.inAttribute = inAttribute;
+		/** @type {boolean} */
+		this.characterData = characterData;
 	}
 
 	get type() {
@@ -87,6 +108,7 @@ class HtmlInlineStyleDependency extends ModuleDependency {
 		super.serialize(context);
 		context.write(this.attribute);
 		context.write(this.inAttribute);
+		context.write(this.characterData);
 	}
 
 	/**
@@ -97,6 +119,7 @@ class HtmlInlineStyleDependency extends ModuleDependency {
 		super.deserialize(context);
 		this.attribute = context.read();
 		this.inAttribute = context.read();
+		this.characterData = context.read();
 	}
 }
 
@@ -127,23 +150,34 @@ HtmlInlineStyleDependency.Template = class HtmlInlineStyleDependencyTemplate ext
 			}
 		}
 
-		// An attribute value was entity-decoded before parsing, so re-escape
-		// the processed CSS to keep the surrounding markup valid in any
-		// quoting context, and drop the trailing newline the CSS generator
-		// appends so the rewritten attribute stays on one line.
+		// An attribute value was entity-decoded before parsing, so the processed CSS
+		// is re-escaped to keep the markup valid in any quoting context, and the
+		// generator's trailing newline dropped to keep it on one line.
 		if (dep.inAttribute) {
 			cssText = cssText
 				.replace(TRAILING_WHITESPACE_REGEXP, "")
 				.replace(ATTR_ESCAPE_REGEXP, escapeAttrChar);
+		} else {
+			// A `<style>` body keeps the whitespace its source ends with: the newline
+			// the generator appends to hold a stylesheet's modules apart is no fixed
+			// point here, and a page built from an emitted one would gain one a pass.
+			if (cssText.endsWith("\n")) cssText = cssText.slice(0, -1);
+			if (dep.characterData) {
+				// A foreign `<style>` body was entity-decoded before parsing, so the
+				// processed CSS is escaped back as text — its newlines stay literal,
+				// which an attribute value could not afford.
+				cssText = cssText.replace(TEXT_ESCAPE_REGEXP, escapeTextChar);
+			}
 		}
 
 		source.replace(dep.range[0], dep.range[1] - 1, cssText);
 	}
 };
 
-makeSerializable(
-	HtmlInlineStyleDependency,
+makeSerializable(HtmlInlineStyleDependency, [
+	"webpack/lib/dependencies/html/HtmlInlineStyleDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/HtmlInlineStyleDependency"
-);
+]);
 
 module.exports = HtmlInlineStyleDependency;

package/lib/dependencies/{HtmlSourceDependency.js → html/HtmlSourceDependency.js}

@@ -5,30 +5,30 @@
 
 "use strict";
 
-const { ASSET_URL_TYPE } = require("../ModuleSourceTypeConstants");
-const RawDataUrlModule = require("../asset/RawDataUrlModule");
-const makeSerializable = require("../util/makeSerializable");
-const memoize = require("../util/memoize");
-const ModuleDependency = require("./ModuleDependency");
+const RawDataUrlModule = require("../../asset/RawDataUrlModule");
+const { ASSET_URL_TYPE } = require("../../module/ModuleSourceTypeConstants");
+const makeSerializable = require("../../util/makeSerializable");
+const memoize = require("../../util/memoize");
+const ModuleDependency = require("../core/ModuleDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import CodeGenerationResults from "../CodeGenerationResults" */
-/** @import Dependency, { UpdateHashContext } from "../Dependency" */
+/** @import CodeGenerationResults from "../../module/CodeGenerationResults" */
+/** @import Dependency, { UpdateHashContext, DependencyKinds } from "../../graph/Dependency" */
 /**
  * @import {
  * 	CssDependencyTemplateContext as DependencyTemplateContext
- * } from "../DependencyTemplate"
+ * } from "../../template/DependencyTemplate"
  */
-/** @import Module, { BuildInfo } from "../Module" */
-/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import Module, { BuildInfo } from "../../module/Module" */
+/** @import { Range } from "../../javascript/JavascriptParser" */
 /**
  * @import {
  * 	ObjectDeserializerContext,
  * 	ObjectSerializerContext
- * } from "../serialization/ObjectMiddleware"
+ * } from "../../serialization/ObjectMiddleware"
  */
-/** @import Hash from "../util/Hash" */
-/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import Hash from "../../util/Hash" */
+/** @import { RuntimeSpec } from "../../util/runtime" */
 
 const getIgnoredRawDataUrlModule = memoize(
 	() => new RawDataUrlModule("data:,", "ignored-asset", "(ignored asset)")
@@ -172,9 +172,16 @@ HtmlSourceDependency.Template = class HtmlSourceDependencyTemplate extends (
 	}
 };
 
-makeSerializable(
-	HtmlSourceDependency,
+makeSerializable(HtmlSourceDependency, [
+	"webpack/lib/dependencies/html/HtmlSourceDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/HtmlSourceDependency"
-);
+]);
+
+/** @type {Set<keyof DependencyKinds>} */
+HtmlSourceDependency.KINDS = new Set([
+	...ModuleDependency.KINDS,
+	"html-source"
+]);
 
 module.exports = HtmlSourceDependency;

package/lib/dependencies/{ImportContextDependency.js → import/ImportContextDependency.js}

@@ -5,16 +5,17 @@
 
 "use strict";
 
-const makeSerializable = require("../util/makeSerializable");
-const ContextDependency = require("./ContextDependency");
-const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+const makeSerializable = require("../../util/makeSerializable");
+const ContextDependency = require("../context/ContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("../context/ContextDependencyTemplateAsRequireCall");
+const { ImportPhaseUtils } = require("../core/ImportPhase");
 const importOptionsCheck = require("./importOptionsCheck");
 
-/** @import { Range } from "../javascript/JavascriptParser" */
-/** @import { ObjectDeserializerContext, ObjectSerializerContext } from "../serialization/ObjectMiddleware" */
-/** @import { ContextDependencyOptions } from "./ContextDependency" */
+/** @import { Range } from "../../javascript/JavascriptParser" */
+/** @import { ObjectDeserializerContext, ObjectSerializerContext } from "../../serialization/ObjectMiddleware" */
+/** @import { ContextDependencyOptions } from "../context/ContextDependency" */
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
 
 class ImportContextDependency extends ContextDependency {
 	/**
@@ -46,6 +47,9 @@ class ImportContextDependency extends ContextDependency {
 	 */
 	getResourceIdentifier() {
 		let str = super.getResourceIdentifier();
+		if (this.options.phase) {
+			str += `|phase${ImportPhaseUtils.stringify(this.options.phase)}`;
+		}
 
 		if (this.options.attributes) {
 			str += `|attributes${JSON.stringify(this.options.attributes)}`;
@@ -77,10 +81,11 @@ class ImportContextDependency extends ContextDependency {
 	}
 }
 
-makeSerializable(
-	ImportContextDependency,
+makeSerializable(ImportContextDependency, [
+	"webpack/lib/dependencies/import/ImportContextDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/ImportContextDependency"
-);
+]);
 
 ImportContextDependency.Template = class ImportContextDependencyTemplate extends (
 	ContextDependencyTemplateAsRequireCall
@@ -95,6 +100,15 @@ ImportContextDependency.Template = class ImportContextDependencyTemplate extends
 	 * @returns {void}
 	 */
 	replaceCall(dep, source, moduleExports, templateContext) {
+		if (ImportPhaseUtils.isSource(dep.options.phase)) {
+			source.insert(
+				/** @type {Range} */ (dep.range)[1],
+				`.then(${templateContext.runtimeTemplate.returningFunction(
+					'm["default"]',
+					"m"
+				)})`
+			);
+		}
 		const optionsRange = /** @type {ImportContextDependency} */ (dep)
 			.optionsRange;
 		if (optionsRange === undefined) {

package/lib/dependencies/{ImportDependency.js → import/ImportDependency.js}

@@ -5,35 +5,36 @@
 
 "use strict";
 
-const Dependency = require("../Dependency");
-const makeSerializable = require("../util/makeSerializable");
-const HarmonyImportGuard = require("./HarmonyImportGuard");
-const { ImportPhaseUtils } = require("./ImportPhase");
-const ModuleDependency = require("./ModuleDependency");
+const Dependency = require("../../graph/Dependency");
+const makeSerializable = require("../../util/makeSerializable");
+const { ImportPhaseUtils } = require("../core/ImportPhase");
+const ModuleDependency = require("../core/ModuleDependency");
+const ESMImportGuard = require("../esm/ESMImportGuard");
 const importOptionsCheck = require("./importOptionsCheck");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import AsyncDependenciesBlock from "../AsyncDependenciesBlock" */
+/** @import AsyncDependenciesBlock from "../../graph/AsyncDependenciesBlock" */
 /**
  * @import {
  * 	GetConditionFn,
  * 	RawReferencedExports,
- * 	ReferencedExports
- * } from "../Dependency"
+ * 	ReferencedExports,
+ * 	DependencyKinds
+ * } from "../../graph/Dependency"
  */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import Module, { BuildMeta } from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import { ImportAttributes, Range } from "../javascript/JavascriptParser" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import Module, { BuildMeta } from "../../module/Module" */
+/** @import ModuleGraph from "../../graph/ModuleGraph" */
+/** @import { ImportAttributes, Range } from "../../javascript/JavascriptParser" */
 /**
  * @import {
  * 	ObjectDeserializerContext,
  * 	ObjectSerializerContext
- * } from "../serialization/ObjectMiddleware"
+ * } from "../../serialization/ObjectMiddleware"
  */
-/** @import { RuntimeSpec } from "../util/runtime" */
-/** @import { DependencyGuard } from "./HarmonyImportGuard" */
-/** @import { ImportPhaseType } from "./ImportPhase" */
+/** @import { RuntimeSpec } from "../../util/runtime" */
+/** @import { DependencyGuard } from "../esm/ESMImportGuard" */
+/** @import { ImportPhaseType } from "../core/ImportPhase" */
 
 class ImportDependency extends ModuleDependency {
 	/**
@@ -79,7 +80,7 @@ class ImportDependency extends ModuleDependency {
 		const guards = this.branchGuards;
 		if (guards === undefined) return null;
 		return (connection, runtime) =>
-			!HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime);
+			!ESMImportGuard.isDeadByGuards(guards, moduleGraph, runtime);
 	}
 
 	/**
@@ -166,7 +167,11 @@ class ImportDependency extends ModuleDependency {
 	}
 }
 
-makeSerializable(ImportDependency, "webpack/lib/dependencies/ImportDependency");
+makeSerializable(ImportDependency, [
+	"webpack/lib/dependencies/import/ImportDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
+	"webpack/lib/dependencies/ImportDependency"
+]);
 
 ImportDependency.Template = class ImportDependencyTemplate extends (
 	ModuleDependency.Template
@@ -241,4 +246,7 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 	}
 };
 
+/** @type {Set<keyof DependencyKinds>} */
+ImportDependency.KINDS = new Set([...ModuleDependency.KINDS, "dynamic-import"]);
+
 module.exports = ImportDependency;

package/lib/dependencies/{ImportEagerDependency.js → import/ImportEagerDependency.js}

@@ -5,15 +5,16 @@
 
 "use strict";
 
-const makeSerializable = require("../util/makeSerializable");
+const makeSerializable = require("../../util/makeSerializable");
+const { ImportPhaseUtils } = require("../core/ImportPhase");
 const ImportDependency = require("./ImportDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import Dependency, { RawReferencedExports } from "../Dependency" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import Module, { BuildMeta } from "../Module" */
-/** @import { ImportAttributes, Range } from "../javascript/JavascriptParser" */
-/** @import { ImportPhaseType } from "./ImportPhase" */
+/** @import Dependency, { RawReferencedExports } from "../../graph/Dependency" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import Module, { BuildMeta } from "../../module/Module" */
+/** @import { ImportAttributes, Range } from "../../javascript/JavascriptParser" */
+/** @import { ImportPhaseType } from "../core/ImportPhase" */
 
 class ImportEagerDependency extends ImportDependency {
 	/**
@@ -37,10 +38,11 @@ class ImportEagerDependency extends ImportDependency {
 	}
 }
 
-makeSerializable(
-	ImportEagerDependency,
+makeSerializable(ImportEagerDependency, [
+	"webpack/lib/dependencies/import/ImportEagerDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/ImportEagerDependency"
-);
+]);
 
 ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
 	ImportDependency.Template
@@ -58,7 +60,7 @@ ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
 		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
 	) {
 		const dep = /** @type {ImportEagerDependency} */ (dependency);
-		const content = runtimeTemplate.moduleNamespacePromise({
+		let content = runtimeTemplate.moduleNamespacePromise({
 			chunkGraph,
 			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 			request: dep.request,
@@ -67,6 +69,12 @@ ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
 			dependency: dep,
 			runtimeRequirements
 		});
+		if (ImportPhaseUtils.isSource(dep.phase)) {
+			content = `${content}.then(${runtimeTemplate.returningFunction(
+				'm["default"]',
+				"m"
+			)})`;
+		}
 
 		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}

package/lib/dependencies/{ImportParserPlugin.js → import/ImportParserPlugin.js}

@@ -5,29 +5,29 @@
 
 "use strict";
 
-const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const AsyncDependenciesBlock = require("../../graph/AsyncDependenciesBlock");
 
 const {
-	VariableInfo,
-	getImportAttributes
-} = require("../javascript/JavascriptParser");
-const memoize = require("../util/memoize");
-const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
-const ContextDependencyHelpers = require("./ContextDependencyHelpers");
-const { getNonOptionalPart } = require("./HarmonyImportDependency");
-const HarmonyImportGuard = require("./HarmonyImportGuard");
+	getImportAttributes,
+	isVariableInfo
+} = require("../../javascript/JavascriptParser");
+const memoize = require("../../util/memoize");
+const ContextDependencyHelpers = require("../context/ContextDependencyHelpers");
+const { createGetImportPhase } = require("../core/ImportPhase");
+const { getNonOptionalPart } = require("../esm/ESMImportDependency");
+const ESMImportGuard = require("../esm/ESMImportGuard");
+const traverseDestructuringAssignmentProperties = require("../helpers/traverseDestructuringAssignmentProperties");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
-const { createGetImportPhase } = require("./ImportPhase");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
 const getUnsupportedFeatureWarning = memoize(() =>
-	require("../errors/UnsupportedFeatureWarning")
+	require("../../errors/UnsupportedFeatureWarning")
 );
 
 const getCommentCompilationWarning = memoize(() =>
-	require("../errors/CommentCompilationWarning")
+	require("../../errors/CommentCompilationWarning")
 );
 
 /**
@@ -42,18 +42,18 @@ const getCommentCompilationWarning = memoize(() =>
 /**
  * @import {
  * 	JavascriptParserOptions
- * } from "../../declarations/WebpackOptions"
+ * } from "../../../declarations/WebpackOptions"
  */
-/** @import { RawChunkGroupOptions } from "../ChunkGroup" */
-/** @import { ContextMode } from "../ContextModule" */
-/** @import { RawReferencedExports } from "../Dependency" */
-/** @import { BuildMeta } from "../Module" */
+/** @import { RawChunkGroupOptions } from "../../graph/ChunkGroup" */
+/** @import { ContextMode } from "../../context/ContextModule" */
+/** @import { RawReferencedExports } from "../../graph/Dependency" */
+/** @import { BuildMeta } from "../../module/Module" */
 /**
  * @import JavascriptParser, {
  * 	ImportExpression,
  * 	Range,
  * 	JavascriptParserState
- * } from "../javascript/JavascriptParser"
+ * } from "../../javascript/JavascriptParser"
  */
 
 /** @typedef {{ references: RawReferencedExports, expression: ImportExpression }} ImportSettings */
@@ -250,7 +250,7 @@ class ImportParserPlugin {
 				const nameInfo = parser.getNameForExpression(expr);
 				if (
 					nameInfo &&
-					nameInfo.rootInfo instanceof VariableInfo &&
+					isVariableInfo(nameInfo.rootInfo) &&
 					nameInfo.rootInfo.name &&
 					parser.getTagData(nameInfo.rootInfo.name, dynamicImportTag)
 				) {
@@ -641,7 +641,7 @@ class ImportParserPlugin {
 					dep.optional = Boolean(parser.scope.inTry);
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
-					HarmonyImportGuard.attachDependencyGuards(parser, dep);
+					ESMImportGuard.attachDependencyGuards(parser, dep);
 				}
 			} else {
 				if (mode === "weak") {