@depup/webpack 5.111.1-depup.1 → 5.112.0-depup.0

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

@@ -9,27 +9,31 @@ const {
 	CSS_TYPE,
 	HTML_TYPE,
 	JAVASCRIPT_TYPE
-} = require("../ModuleSourceTypeConstants");
-const ResourceHintPlugin = require("../prefetch/ResourceHintPlugin");
-const ResourceHintRuntimeModule = require("../prefetch/ResourceHintRuntimeModule");
-const makeSerializable = require("../util/makeSerializable");
-const memoize = require("../util/memoize");
-const ModuleDependency = require("./ModuleDependency");
+} = require("../../module/ModuleSourceTypeConstants");
+const ResourceHintPlugin = require("../../prefetch/ResourceHintPlugin");
+const ResourceHintRuntimeModule = require("../../prefetch/ResourceHintRuntimeModule");
+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"));
+// only read when a page carries stylesheets, and it drags the css subsystem in
+const getCssModulesPlugin = memoize(() =>
+	require("../../css/CssModulesPlugin")
+);
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import Chunk from "../Chunk" */
-/** @import ChunkGraph from "../ChunkGraph" */
-/** @import Dependency from "../Dependency" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import Entrypoint from "../Entrypoint" */
-/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import Chunk from "../../graph/Chunk" */
+/** @import ChunkGraph from "../../graph/ChunkGraph" */
+/** @import Dependency, { DependencyKinds } from "../../graph/Dependency" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import Entrypoint from "../../graph/Entrypoint" */
+/** @import { Range } from "../../javascript/JavascriptParser" */
 /** @typedef {"script" | "script-module" | "modulepreload" | "stylesheet" | "html" | "preload" | "prefetch"} HtmlEntryElementKind */
 
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, string, HtmlEntryElementKind, number, number, boolean, string, number, boolean, number, (Range | null), (Range | null), boolean, number, number]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, string, HtmlEntryElementKind, number, number, boolean, string, number, boolean, number, (Range | null), (Range | null), boolean, number, number]>} ObjectSerializerContext */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, string, HtmlEntryElementKind, number, number, boolean, string, number, boolean, number, (Range | null), (Range | null), boolean, number, number]>} ObjectDeserializerContext */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectSerializerContext<[string, string, HtmlEntryElementKind, number, number, boolean, string, number, boolean, number, (Range | null), (Range | null), boolean, number, number]>} ObjectSerializerContext */
 
 class HtmlEntryDependency extends ModuleDependency {
 	/**
@@ -193,11 +197,11 @@ const getEntrypointChunksInLoadOrder = (entrypoint) => {
 
 	/** @type {Set<Chunk>} */
 	const chunksLoadedByAncestorTags = new Set();
-	/** @type {Set<import("../ChunkGroup")>} */
+	/** @type {Set<import("../../graph/ChunkGroup")>} */
 	const visitedGroups = new Set();
 	/**
 	 * Collects the chunks an ancestor entry's own tags already load.
-	 * @param {import("../ChunkGroup")} group chunk group to walk up from
+	 * @param {import("../../graph/ChunkGroup")} group chunk group to walk up from
 	 * @returns {void}
 	 */
 	const walk = (group) => {
@@ -296,83 +300,6 @@ const chunkHasCss = (chunk, chunkGraph) =>
 		chunkGraph.getChunkModulesIterableBySourceType(chunk, CSS_IMPORT_TYPE)
 	);
 
-/**
- * Deterministic tie-break key for CSS link ordering. `chunk.name` and
- * `chunk.id` are both stable strings (when present); one of them is set for
- * every chunk webpack emits. We can't rely on `Array.prototype.sort` being
- * stable — webpack still supports Node 10.13 where V8's sort is not guaranteed
- * stable for arrays larger than ten elements — so any time
- * `firstCssModulePostOrderIndex` returns the same value for two chunks (most
- * commonly when several chunks have no reachable CSS module in the entrypoint's
- * dependency walk and all map to `Infinity`) this key picks the canonical order.
- * Computed once per chunk when building the sort array rather than per
- * comparison.
- * @param {Chunk} chunk chunk
- * @returns {string} the tie-break key
- */
-const cssChunkSortKey = (chunk) =>
-	`${chunk.name || ""} ${
-		chunk.id === null || chunk.id === undefined ? "" : chunk.id
-	}`;
-
-/**
- * Sort comparator for the CSS sibling emission order. Direct subtraction
- * would yield `NaN` when both indices are `Infinity` (the documented
- * fallback for chunks whose CSS modules the entrypoint's walk never
- * reaches), and `Array#sort` doesn't promise stable ordering on the legacy
- * Node 10 targets this repo still supports — so the tie-breaker must always
- * run when the indices match, including the `Infinity === Infinity` case.
- * @param {{ index: number, key: string }} a first entry
- * @param {{ index: number, key: string }} b second entry
- * @returns {-1 | 0 | 1} sort order
- */
-const compareCssChunkOrder = (a, b) => {
-	if (a.index < b.index) return -1;
-	if (a.index > b.index) return 1;
-	if (a.key < b.key) return -1;
-	if (a.key > b.key) return 1;
-	return 0;
-};
-
-const CSS_SOURCE_TYPES = [CSS_TYPE, CSS_IMPORT_TYPE];
-
-/**
- * Smallest post-order index among the CSS modules of a chunk, taken
- * from the entrypoint's view of the dependency graph. Used to sort
- * sibling CSS chunks so they appear in source import order in the
- * extracted HTML — `entrypoint.chunks` itself does not give that
- * ordering for arbitrary splitChunks layouts. Considers both
- * `CSS_TYPE` and `CSS_IMPORT_TYPE` modules so a chunk made up
- * exclusively of `@import` placeholder modules (e.g. when splitChunks
- * separates them from their target CSS) still sorts by its true
- * source position rather than collapsing to `Infinity` and relying on
- * the chunk-name tie-breaker.
- * @param {Chunk} chunk chunk
- * @param {Entrypoint} entrypoint entrypoint the chunk belongs to
- * @param {ChunkGraph} chunkGraph chunk graph
- * @returns {number} the lowest post-order index of any CSS or
- * CSS-import module in the chunk, or `Number.POSITIVE_INFINITY` when
- * no such module has a defined index (e.g. for a module the
- * entrypoint never reached on its own dependency walk — runtime-only
- * modules, modules reached via `dependOn`, etc.) so such chunks sort
- * last among CSS chunks
- */
-const firstCssModulePostOrderIndex = (chunk, entrypoint, chunkGraph) => {
-	let min = Number.POSITIVE_INFINITY;
-	for (const sourceType of CSS_SOURCE_TYPES) {
-		const modules = chunkGraph.getChunkModulesIterableBySourceType(
-			chunk,
-			sourceType
-		);
-		if (!modules) continue;
-		for (const module of modules) {
-			const idx = entrypoint.getModulePostOrderIndex(module);
-			if (idx !== undefined && idx < min) min = idx;
-		}
-	}
-	return min;
-};
-
 /**
  * Build a fresh `<link rel="stylesheet" href="…">` for a CSS chunk that
  * was pulled in by a `<script src>` entry — the originating tag was a
@@ -553,7 +480,7 @@ const polyfilledSources = new WeakSet();
  * @property {string} entryName name of the entry this page loads
  * @property {Entrypoint} entrypoint the entrypoint
  * @property {"html" | "js"} hostType `"html"` when the entry has an extracted HTML page; `"js"` when a JS-only entry is being consulted (SSR framework case)
- * @property {import("../Compilation")} compilation the compilation
+ * @property {import("../../Compilation")} compilation the compilation
  * @property {{ rel: "modulepreload" | "preload" | "prefetch", chunk: string, hostChunks: string[] }[]} defaultHints the auto initial-graph hints (`chunk` / `hostChunks` name the referencing chunk — Vite's `hostId`)
  */
 
@@ -592,7 +519,7 @@ const buildLinkTag = (rel, attrs) =>
 /**
  * The chunks a hint means when it names a page: a page loads no JavaScript of
  * its own, so the hint follows the entries the parser extracted from it.
- * @param {import("../Compilation")} compilation compilation
+ * @param {import("../../Compilation")} compilation compilation
  * @param {Chunk} chunk chunk a hint resolved to
  * @returns {Chunk[]} the chunks to hint at
  */
@@ -615,7 +542,7 @@ const resolvePageChunk = (compilation, chunk) => {
 	if (modules === undefined) return chunks.length === 0 ? [chunk] : chunks;
 	for (const module of modules) {
 		const { htmlEntries } =
-			/** @type {import("../html/HtmlModule").HtmlModuleBuildInfo} */ (
+			/** @type {import("../../html/HtmlModule").HtmlModuleBuildInfo} */ (
 				module.buildInfo
 			) || {};
 		if (!htmlEntries) continue;
@@ -636,7 +563,7 @@ const resolvePageChunk = (compilation, chunk) => {
  * resolved with the final hash and public path), an `href` is used verbatim, and
  * `preconnect`/`dns-prefetch` use only `href`. Unknown chunk/entry names are skipped.
  * @param {HtmlResourceHint} desc the descriptor
- * @param {{ compilation: import("../Compilation"), chunkGraph: ChunkGraph, chunkByName: Map<string, Chunk>, outputCrossOrigin: string, integrityOn: boolean }} ctx resolution context
+ * @param {{ compilation: import("../../Compilation"), chunkGraph: ChunkGraph, chunkByName: Map<string, Chunk>, outputCrossOrigin: string, integrityOn: boolean }} ctx resolution context
  * @returns {string[]} the resolved tags
  */
 const resolveResourceHint = (desc, ctx) => {
@@ -837,10 +764,6 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 			compilation.outputOptions.module === true ? ' type="module"' : "";
 
 		const entryContentHashType = isStylesheet ? "css" : "javascript";
-		const inlineOption =
-			typeof htmlOption === "object" ? htmlOption.inline : undefined;
-		/** @type {RegExp[] | null} */
-		const inlinePatterns = Array.isArray(inlineOption) ? inlineOption : null;
 		/**
 		 * @param {Chunk} chunk chunk to test
 		 * @param {"javascript" | "css"} contentType which asset of the chunk is being emitted
@@ -850,25 +773,18 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 			// A `<link rel="modulepreload">` is a void fetch hint — inlining it would
 			// emit an unclosed, executing `<script>`.
 			if (dep.elementKind === "modulepreload") return false;
+			if (!getHtmlGenerator().canInlineChunk(compilation, chunk)) {
+				return false;
+			}
 			if (dep.forceInline) return true;
-			if (!inlineOption) return false;
-			if (inlineOption === true) return true;
-			// `"script"`/`"style"` inline by asset type, not chunk name — a chunk's
-			// JS and CSS share a name, so only the emitted `contentType` tells them
-			// apart.
-			if (inlineOption === "script") return contentType === "javascript";
-			if (inlineOption === "style") return contentType === "css";
-			const name = chunk.name || String(chunk.id);
-			return /** @type {RegExp[]} */ (inlinePatterns).some((re) =>
-				re.test(name)
-			);
+			return getHtmlGenerator().isChunkInlined(htmlOption, chunk, contentType);
 		};
 
 		// Only inline when the HTML module is emitted as a standalone page (extract mode).
 		// If it's exported as a JS string, sentinels would end up embedded in the JS chunk.
 		const isExtractedHtml = chunkGraph
 			.getModuleSourceTypes(
-				/** @type {import("../Module")} */ (templateContext.module)
+				/** @type {import("../../module/Module")} */ (templateContext.module)
 			)
 			.has("html");
 		const entryInlined =
@@ -1029,8 +945,8 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 				// mini-css-extract#959 symptom. The order is re-derived from the
 				// entrypoint's module post-order index, which follows the dependency
 				// walk and so the source's import order.
-				/** @type {{ chunk: Chunk, index: number, key: string }[]} */
-				const cssChunkOrder = [];
+				/** @type {Chunk[]} */
+				const cssChunks = [];
 				/** @type {Chunk[]} */
 				const jsChunks = [];
 				for (let i = 0; i < orderedChunks.length - 1; i++) {
@@ -1038,15 +954,7 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 					const hasCss = chunkHasCss(chunk, chunkGraph);
 					const hasJs = chunkHasJs(chunk, chunkGraph);
 					if (hasCss) {
-						cssChunkOrder.push({
-							chunk,
-							index: firstCssModulePostOrderIndex(
-								chunk,
-								entrypoint,
-								chunkGraph
-							),
-							key: cssChunkSortKey(chunk)
-						});
+						cssChunks.push(chunk);
 					}
 					// Anything not CSS-only stays on the JS lane in `orderedChunks` order,
 					// preserving the runtime-first invariant. A chunk emitting neither
@@ -1057,17 +965,13 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 				// ordering so its `<link>` lands in the right cascade position
 				// relative to the sibling CSS chunks.
 				if (chunkHasCss(entryChunk, chunkGraph)) {
-					cssChunkOrder.push({
-						chunk: entryChunk,
-						index: firstCssModulePostOrderIndex(
-							entryChunk,
-							entrypoint,
-							chunkGraph
-						),
-						key: cssChunkSortKey(entryChunk)
-					});
+					cssChunks.push(entryChunk);
 				}
-				cssChunkOrder.sort(compareCssChunkOrder);
+				const cssChunkOrder = getCssModulesPlugin().getCssChunksInCascadeOrder(
+					cssChunks,
+					entrypoint,
+					chunkGraph
+				);
 				// Stylesheets land in `<head>`. A classic blocking script pins them
 				// ahead of itself, so it never awaits later CSS; with only `defer` and
 				// module scripts they go last, which starts the script fetches earlier.
@@ -1080,7 +984,7 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 							? dep.cssAnchor
 							: dep.tagStart;
 				cssHtml = cssChunkOrder
-					.map(({ chunk }) => buildSibling(chunk, "css"))
+					.map((chunk) => buildSibling(chunk, "css"))
 					.join("");
 				for (const chunk of jsChunks) {
 					siblings.push(buildSibling(chunk, "javascript"));
@@ -1209,7 +1113,9 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 						// `<script>` entry — that's what users key on.
 						let entryName = dep.entryName;
 						for (const c of chunkGraph.getModuleChunks(
-							/** @type {import("../Module")} */ (templateContext.module)
+							/** @type {import("../../module/Module")} */ (
+								templateContext.module
+							)
 						)) {
 							if (c.name) {
 								entryName = c.name;
@@ -1270,7 +1176,7 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 				const asAttr =
 					md.asAttribute ||
 					ResourceHintRuntimeModule.guessAsAttribute(
-						/** @type {import("./URLDependency")} */ (md).request || ""
+						/** @type {import("../url/URLDependency")} */ (md).request || ""
 					);
 				const typeAttr = md.typeAttribute;
 				const mediaAttr = md.mediaAttribute;
@@ -1327,9 +1233,13 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 	}
 };
 
-makeSerializable(
-	HtmlEntryDependency,
+makeSerializable(HtmlEntryDependency, [
+	"webpack/lib/dependencies/html/HtmlEntryDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/HtmlEntryDependency"
-);
+]);
+
+/** @type {Set<keyof DependencyKinds>} */
+HtmlEntryDependency.KINDS = new Set([...ModuleDependency.KINDS, "html-entry"]);
 
 module.exports = HtmlEntryDependency;

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

@@ -4,17 +4,17 @@
 
 "use strict";
 
-const { HTML_TYPE } = require("../ModuleSourceTypeConstants");
-const makeSerializable = require("../util/makeSerializable");
-const ModuleDependency = require("./ModuleDependency");
+const { HTML_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" */
-/** @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" */
+/** @import Hash from "../../util/Hash" */
 
 // One pass over the source: each char is replaced once and replacements aren't
 // re-scanned, so this matches the `&`-first sequential escape chain exactly.
@@ -98,9 +98,10 @@ HtmlInlineHtmlDependency.Template = class HtmlInlineHtmlDependencyTemplate exten
 	}
 };
 
-makeSerializable(
-	HtmlInlineHtmlDependency,
+makeSerializable(HtmlInlineHtmlDependency, [
+	"webpack/lib/dependencies/html/HtmlInlineHtmlDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/HtmlInlineHtmlDependency"
-);
+]);
 
 module.exports = HtmlInlineHtmlDependency;

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,6 +133,30 @@ 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");
 		}
@@ -120,9 +169,10 @@ HtmlInlineScriptDependency.Template = class HtmlInlineScriptDependencyTemplate e
 	}
 };
 
-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();
 	}
 }
 
@@ -134,15 +157,27 @@ HtmlInlineStyleDependency.Template = class HtmlInlineStyleDependencyTemplate ext
 			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;