@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/html/HtmlParser.js

@@ -90,10 +90,9 @@ const STYLE_ATTR_URL_REGEXP = /url\(|src\(|image\(|image-set\(/i;
 // hold a `url(...)` FuncIRI. Most are plain colors/keywords (`#fff`, `red`).
 const FUNC_IRI_URL_REGEXP = /url\(/i;
 
-// Cheap pre-filter for `<iframe srcdoc>` markup: only spin up a nested HTML
-// module when the document can reference an asset — via any attribute (`src=`,
-// `href=`, `style=`, …), a CSS `url(...)`, or a CSS `@import`. Pure
-// formatting/text markup (`<p>hi</p>`) rewrites to itself, so skip it.
+// Cheap pre-filter for `<iframe srcdoc>`: a nested HTML module is only worth
+// building when the markup can reference an asset — any attribute, a CSS
+// `url(...)` or an `@import`. Pure text markup rewrites to itself.
 const SRCDOC_ASSET_REGEXP = /[=]|url\(|@import/i;
 
 // A URL carrying its own scheme (`https:`, `data:`, …) ignores the document
@@ -370,10 +369,9 @@ const isLinkStylesheet = (attributes) => {
  */
 const dict = (...bags) => Object.assign(Object.create(null), ...bags);
 
-// Shared `SourceItem` singletons used by the built-in defaults —
-// keeping one instance per kind stabilizes V8's hidden classes across
-// lookups in the walk. `srcset` is its own type; the walk picks the
-// `parseSrcset` parser for it and otherwise treats it like `src`.
+// One shared `SourceItem` per kind, so the walk's lookups stay on a single V8
+// hidden class. `srcset` is its own type: the walk picks `parseSrcset` for it
+// and otherwise treats it like `src`.
 /** @type {SourceItem} */
 const PLAIN_SRC = { type: "src", filter: undefined };
 /** @type {SourceItem} */
@@ -389,10 +387,9 @@ const LINK_HREF = {
 	type: (attrs, css) => {
 		if (isLinkModulePreload(attrs)) return "modulepreload";
 		if (css && isLinkStylesheet(attrs)) return "stylesheet";
-		// `rel="preload"/"prefetch"` with `as="script"` (or `as="style"` when
-		// `experiments.css` is on) becomes a bundled, non-executing entry whose
-		// `href` is rewritten to the built chunk; other `as` targets (image,
-		// font, fetch, …) stay plain asset URLs.
+		// `rel="preload"/"prefetch"` with `as="script"` — or `as="style"` under
+		// `experiments.css` — becomes a non-executing entry pointing at the built
+		// chunk; every other `as` target stays a plain asset URL.
 		const rel = getAttributeValue(attrs, "rel");
 		if (rel) {
 			const rels = rel.trim().toLowerCase().split(/\s+/);
@@ -446,11 +443,9 @@ const META_CONTENT = {
 	filter: filterMetaContent
 };
 
-// Built-in lookup table, written directly in its final resolved shape:
-// `DEFAULT_SOURCES_BY_TAG[tag][attribute] = item`. No module-load
-// loop, no separate array representation — every parser created with
-// the default `sources` config just references this table and pays
-// zero per-parser work.
+// Written in its final resolved shape, `[tag][attribute] = item`, rather than
+// built from an array at module load: a parser on the default `sources` config
+// references this table and pays nothing per instance.
 /** @type {Record<string, Record<string, SourceItem>>} */
 const DEFAULT_SOURCES_BY_TAG = dict({
 	// Obsolete Java-applet element; `code`/`object` are single class/object URLs.
@@ -489,13 +484,14 @@ const DEFAULT_SOURCES_BY_TAG = dict({
 	th: dict({ background: PLAIN_SRC }),
 	track: dict({ src: PLAIN_SRC }),
 	video: dict({ poster: PLAIN_SRC, src: PLAIN_SRC }),
-	// SVG. Tag names match the tree builder's adjusted camelCase
-	// (`feImage`/`textPath`/`linearGradient`/`radialGradient`). `href`/
-	// `xlink:href` reference another element/resource; fragment-only `#id`
-	// values are left untouched, so only external `file.svg#id` is rewritten.
-	// `color-profile`'s `xlink:href` points at an external ICC profile file.
-	// `cursor`/`font-face-uri` point at an external image/font file; `altGlyph`/
-	// `glyphRef`/`tref` are legacy element references (removed in SVG 2).
+	// WHY: SVG. Tag names match the tree builder's adjusted camelCase
+	// (`feImage`/`textPath`/`linearGradient`/`radialGradient`). `href` and
+	// `xlink:href` reference another element or resource, and a fragment-only
+	// `#id` value is left untouched, so only an external `file.svg#id` is
+	// rewritten. `color-profile`'s `xlink:href` points at an external ICC profile
+	// file; `cursor` and `font-face-uri` at an external image or font file; and
+	// `altGlyph`, `glyphRef` and `tref` are legacy element references, removed in
+	// SVG 2.
 	altGlyph: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
 	"color-profile": dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
 	cursor: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
@@ -515,11 +511,11 @@ const DEFAULT_SOURCES_BY_TAG = dict({
 	// clip-path, …) are handled separately during the walk (`parseCssUrls`).
 });
 
-// SVG presentation attributes (`fill`, `stroke`, …) carry CSS `url(...)`
-// FuncIRIs; `parseCssUrls` extracts external refs as assets (internal
-// `url(#id)` is left untouched). They apply to every SVG-namespace element, so
-// the item is `namespace`-gated rather than placed in a tag bucket. The filter
-// is a cheap pre-check skipping the common plain values (`red`, `none`, `#fff`).
+// WHY: SVG presentation attributes (`fill`, `stroke`, …) carry CSS `url(...)`
+// FuncIRIs, whose external refs `parseCssUrls` extracts as assets, leaving an
+// internal `url(#id)` untouched. They apply to every SVG-namespace element, so
+// the item is `namespace`-gated rather than placed in a tag bucket, and the
+// filter is a cheap pre-check skipping the common plain values (`red`, `none`).
 /** @type {SourceItem} */
 const SVG_CSS_URL = {
 	type: "css-url",
@@ -527,21 +523,18 @@ const SVG_CSS_URL = {
 	namespace: NS_SVG
 };
 
-// The global `style=""` attribute (a CSS declaration list), available on every
-// tag and even with `sources: false`. Like every `stylesheet-style*` source it
-// only emits when `experiments.css` is on (checked where the dependency is
-// created); the filter is a cheap pre-check skipping declarations without a
-// `url()`/`src()`/… .
+// The global `style=""` attribute, available on every tag and even under
+// `sources: false`. Like every `stylesheet-style*` source it only emits when
+// `experiments.css` is on, checked where the dependency is created.
 /** @type {SourceItem} */
 const STYLE_ATTRIBUTE = {
 	type: "stylesheet-style-attribute",
 	filter: (attributes, value) => STYLE_ATTR_URL_REGEXP.test(value)
 };
 
-// Any-tag sources — applied to every element as a fallback and folded into
-// each tag bucket, so the walk resolves one object per element and reads one
-// property per attribute. `DEFAULT` (svg presentation + style) is active
-// unless `sources: false`; only the always-on style attribute survives `false`.
+// Any-tag sources, folded into each tag bucket so the walk resolves one object
+// per element and one property per attribute. `sources: false` leaves only the
+// always-on style attribute.
 /** @type {Record<string, SourceItem>} */
 const DEFAULT_ANY_SOURCES = dict({ style: STYLE_ATTRIBUTE });
 for (const name of [
@@ -625,10 +618,9 @@ const styleContentFilter = (attrs) => {
 	return t === "" || t === "text/css";
 };
 
-// Element-body sources, independent of the `sources` option (even `sources:
-// false`): inline `<script>` bodies are always processed; the `<style>` body
-// only emits when `experiments.css` is on (checked where the dependency is
-// created, like every `stylesheet-style*` source).
+// Element-body sources, independent of the `sources` option: a `<script>` body
+// is always processed, while a `<style>` body only emits when `experiments.css`
+// is on, checked where the dependency is created.
 /** @type {Record<string, ContentSourceItem>} */
 const CONTENT_SOURCES = dict({
 	script: { type: scriptContentType, filter: scriptContentFilter },
@@ -649,11 +641,9 @@ class HtmlParser extends Parser {
 		this.template = options.template;
 		/** @type {import("../../declarations/WebpackOptions").UrlHintRule[] | undefined} */
 		this._urlHints = options.urlHints;
-		// `as` selects the parse mode — the HTML analog of the CSS parser's `as`.
-		// `"document"` (default) parses a full page; any other value is the
-		// context element whose inner HTML the source is parsed as (a fragment),
-		// so context-sensitive tags (`<tr>`, `<td>`, `<option>`, …) in a partial
-		// are kept, not dropped. `"template"` is the neutral generic fragment.
+		// `as` selects the parse mode: `"document"` parses a full page, any other
+		// value names the context element whose inner HTML this is, so that a
+		// partial's `<tr>`, `<td>` or `<option>` is kept rather than dropped.
 		/** @type {string | undefined} */
 		this.fragmentContext =
 			options.as === undefined || options.as === "document"
@@ -673,13 +663,9 @@ class HtmlParser extends Parser {
 			return;
 		}
 
-		// User array — `"..."` anywhere opts the per-tag defaults in as the
-		// base; the built-in any-tag sources (svg presentation + style) are
-		// always present. A user entry with no `tag` is an any-tag source (e.g.
-		// `{ attribute: "data-style", type: "stylesheet-style-attribute" }`).
-		// User entries override regardless of position. `dict()` keeps every
-		// table null-prototype (see its doc), and per-tag writes rebuild the
-		// bucket so the aliased default buckets stay intact.
+		// `"..."` anywhere opts the per-tag defaults in as the base, and a user
+		// entry with no `tag` is an any-tag source; user entries override wherever
+		// they sit. Per-tag writes rebuild the bucket, so the defaults stay intact.
 		/** @type {SourceTable} */
 		const byTag = sources.includes("...")
 			? dict(DEFAULT_SOURCES_BY_TAG)
@@ -804,14 +790,9 @@ class HtmlParser extends Parser {
 		const css = Boolean(compilation.options.experiments.css);
 		const urlHints = this._urlHints;
 
-		// Stable, per-HTML-module prefix used when generating entry names for
-		// script src / modulepreload references so they don't collide across
-		// HTML modules in the same compilation. We hash the module's resource
-		// path (a plain absolute path) — going through `contextify` against
-		// the compilation root keeps the hash machine-stable for the same
-		// project layout. Note: `module.identifier()` returns `html|<path>`
-		// for HTML modules, which doesn't start with `/`, so contextify would
-		// leave it absolute. `module.resource` is the bare path.
+		// Per-module prefix keeping generated entry names from colliding across the
+		// HTML modules of one compilation. It hashes `module.resource` rather than
+		// `identifier()`, whose `html|` prefix `contextify` would leave absolute.
 		/** @type {string} */
 		const resource =
 			/** @type {EXPECTED_ANY} */ (module).resource || module.identifier();
@@ -820,11 +801,9 @@ class HtmlParser extends Parser {
 			.digest("hex")
 			.slice(0, 8);
 
-		// `output.html` head injection: facts are collected during the walk and
-		// become presentational dependencies afterwards — no later asset pass has
-		// to re-parse the page. `data:` documents are skipped: synthetic entry
-		// wrappers already carry the tags and iframe srcdoc pages must stay
-		// untouched.
+		// `output.html` head injection collects facts during the walk and turns
+		// them into presentational dependencies after, so no later pass re-parses
+		// the page. `data:` documents are skipped — they already carry the tags.
 		const htmlOutputOptions =
 			compilation.options && compilation.options.output
 				? compilation.options.output.html
@@ -846,10 +825,9 @@ class HtmlParser extends Parser {
 		let inHead = false;
 		// `<template>` contents are inert
 		let headTemplateDepth = 0;
-		// Depth of open `<template>` elements anywhere in the tree. Template
-		// content is an inert, separate fragment per spec, so a `<base>` inside
-		// it must NOT set the document base (`headTemplateDepth` only covers
-		// templates seen while in `<head>`, so it can't guard body templates).
+		// Depth of open `<template>` elements anywhere in the tree: their content
+		// is an inert fragment, so a `<base>` inside one must not set the document
+		// base. `headTemplateDepth` covers only `<head>`, so it cannot guard this.
 		let templateDepth = 0;
 		let headHasTitle = false;
 		let headHasBase = false;
@@ -857,17 +835,14 @@ class HtmlParser extends Parser {
 		/** @type {Set<string> | undefined} */
 		let headMetaNames;
 
-		// Script src / modulepreload references are collected per-type
-		// during the walk; HtmlModulesPlugin later turns them into real
-		// entries. `script` and `script-module` entries are chained via a
-		// leader-only dependOn so they share a runtime.
-		// `<link rel="modulepreload">` entries are kept independent — they
-		// must preload without running, so they can never become a runtime
-		// leader that other entries would import.
+		// Collected per type during the walk; HtmlModulesPlugin turns them into
+		// entries. `script` and `script-module` chain through a leader-only
+		// dependOn; modulepreload stays independent, as it must not run.
 		/**
 		 * @typedef {object} HtmlEntryInfo
 		 * @property {string} request
 		 * @property {string} entryName
+		 * @property {number} index position in the document, across all groups — the order the emitted files are named in
 		 * @property {"script" | "script-module" | "modulepreload" | "stylesheet" | "html" | "preload" | "prefetch"} type
 		 * @property {boolean=} css entry emits a CSS chunk (`<link rel="preload" as="style">`), so it needs the CSS filename template
 		 */
@@ -891,28 +866,26 @@ class HtmlParser extends Parser {
 		/** @type {HtmlEntryInfo[]} */
 		const prefetchEntries = [];
 
-		// Offset of the first classic blocking script tag; injected stylesheet
-		// `<link>`s stay ahead of it. `defer`/`async`/module scripts don't
-		// anchor — they execute after parsing (and after pending stylesheets),
-		// so CSS may follow their tags (the order Vite emits).
+		// Offset of the first classic blocking script tag, which injected stylesheet
+		// `<link>`s stay ahead of. `defer`/`async`/module scripts do not anchor: they
+		// run after parsing and after pending stylesheets.
 		let firstBlockingScriptStart = -1;
 
 		let nextEntryIndex = 0;
 
-		// `<base href>` resolves the relative URLs that follow it. A relative base
-		// (`./assets/`) rewrites them into a subdirectory — still bundled; a
-		// root-relative or absolute base (`/`, `https://cdn/`) points them outside
-		// the build, so those URLs are left untouched. Resolved in the walk below
-		// from the first `<base href>` seen (`documentBase` undefined until then).
+		// WHY: `<base href>` resolves the relative URLs that follow it. A relative base
+		// (`./assets/`) rewrites them into a subdirectory and they stay bundled; a
+		// root-relative or absolute one (`/`, `https://cdn/`) points outside the
+		// build, so those URLs are left untouched. Resolved in the walk below from
+		// the first `<base href>` seen, `documentBase` being undefined until then.
 		/** @type {string | undefined} */
 		let documentBase;
 		/** @type {string | undefined} */
 		let baseDir;
 		let baseIsExternal = false;
-		// Prepended to the emitted URLs' auto-public-path undo path so the base
-		// doesn't misdirect them: the browser resolves rewritten (relative)
-		// output URLs against the base dir, so one `../` per base segment cancels
-		// it. Undefined for absolute publicPath (no undo path is emitted).
+		// Prepended to the emitted URLs' auto-public-path undo path: the browser
+		// resolves them against the base dir, so one `../` per base segment cancels
+		// it. Undefined for an absolute publicPath, which emits no undo path.
 		/** @type {string | undefined} */
 		let baseUrlPrefix;
 
@@ -1016,10 +989,9 @@ class HtmlParser extends Parser {
 				baseIsExternal = true;
 				return;
 			}
-			// Normalize the base path into its descending directory segments,
-			// resolving `.`/`..` like the URL spec. The final segment is the
-			// referenced file (dropped) unless the href ends with `/` or a
-			// dot-segment; `up` counts `..`s that climb above the document dir.
+			// Normalize the base path into descending directory segments, resolving
+			// `.`/`..` as the URL spec does. The final segment names a file and is
+			// dropped; `up` counts the `..`s climbing above the document dir.
 			const parts = documentBase.split("/");
 			/** @type {string[]} */
 			const dirs = [];
@@ -1069,9 +1041,8 @@ class HtmlParser extends Parser {
 		};
 
 		// TODO implement full HTML parser (WASM)
-		// The walker descends into children (and `<template>` content) itself;
-		// the Element `exit` clears a pending `webpackIgnore` once an element's
-		// children are done (the old `walkChildren` behaviour).
+		// The walker descends into children and `<template>` content itself, and the
+		// Element `exit` clears a pending `webpackIgnore` once they are done.
 		new SourceProcessor()
 			.use({
 				[NodeType.Comment]: (path) => {
@@ -1219,9 +1190,8 @@ class HtmlParser extends Parser {
 						pendingWebpackIgnore = undefined;
 						pendingWebpackInline = undefined;
 
-						// `<head>` anchors are collected for every page — they place
-						// `inject: "head"` siblings and resource hints; the
-						// title/meta/base facts only when configured. Structural, so it
+						// `<head>` anchors are collected for every page, since they place
+						// `inject: "head"` siblings and resource hints. Structural, so this
 						// runs even for `webpackIgnore`d elements.
 						{
 							const name = path.tagName();
@@ -1446,11 +1416,9 @@ class HtmlParser extends Parser {
 									module.addCodeGenerationDependency(dep);
 									break;
 								}
-								// `<iframe srcdoc>`: an entity-encoded HTML document. Feed the
-								// decoded markup back through the HTML pipeline as a nested
-								// `data:text/html` module. Per spec the value is a full document
-								// whose URL is `about:srcdoc`, so its base URL is inherited from
-								// this document — asset URLs resolve against this file's context.
+								// `<iframe srcdoc>` is an entity-encoded document, fed back through
+								// the pipeline as a nested `data:text/html` module. Its URL is
+								// `about:srcdoc`, so asset URLs resolve against this file.
 								case "srcdoc": {
 									const htmlText = decodeEntities(value, true);
 									// Only spin up a nested module when there is markup that can
@@ -1478,7 +1446,8 @@ class HtmlParser extends Parser {
 										const scriptType =
 											/** @type {"script" | "script-module"} */ (type);
 										const request = dataUri("text/javascript", value);
-										const entryName = `__html_${moduleHash}_${nextEntryIndex++}`;
+										const index = nextEntryIndex++;
+										const entryName = `__html_${moduleHash}_${index}`;
 										const dep = new HtmlInlineScriptDependency(
 											request,
 											nameEnd,
@@ -1501,6 +1470,7 @@ class HtmlParser extends Parser {
 										).push({
 											request,
 											entryName,
+											index,
 											type: scriptType
 										});
 										break;
@@ -1576,12 +1546,12 @@ class HtmlParser extends Parser {
 										}
 										const s = start + (map ? map[us] : us);
 										const e = start + (map ? map[ue] : ue);
-										// `html` links the URL as its own emitted page: the same
-										// `HtmlEntryDependency` as `<script src>` / `<link>`, but the `html`
-										// kind rewrites to the page's filename and emits no sibling tags.
-										// Recorded as an independent entry (no `dependOn`), like an entry point.
+										// `html` links the URL as its own emitted page: the same dependency
+										// as `<script src>`, but rewriting to the page's filename and
+										// emitting no siblings. Independent, like an entry point.
 										if (type === "html") {
-											const entryName = `__html_${moduleHash}_${nextEntryIndex++}`;
+											const index = nextEntryIndex++;
+											const entryName = `__html_${moduleHash}_${index}`;
 											const dep = new HtmlEntryDependency(
 												request,
 												[s, e],
@@ -1591,23 +1561,22 @@ class HtmlParser extends Parser {
 											);
 											setLoc(dep, s, e);
 											module.addPresentationalDependency(dep);
-											htmlLinkEntries.push({ request, entryName, type });
+											htmlLinkEntries.push({ request, entryName, index, type });
 											continue;
 										}
-										// `rel="preload"/"prefetch"` of a bundled resource: an
-										// independent, non-executing entry whose `href` is rewritten to
-										// the built chunk's URL (CSS for `as="style"`, JS otherwise). No
-										// sibling tags — a resource hint references exactly one URL.
+										// `rel="preload"/"prefetch"` of a bundled resource: an independent,
+										// non-executing entry rewritten to the built chunk's URL. No
+										// siblings — a resource hint references exactly one URL.
 										if (type === "preload" || type === "prefetch") {
 											const as = getAttributeValue(getAttributesMap(), "as");
 											const asStyle = as
 												? as.trim().toLowerCase() === "style"
 												: false;
-											const entryName = `__html_${moduleHash}_${nextEntryIndex++}`;
-											// Tag metadata so the template can mirror `crossorigin`/
-											// `integrity` onto a native `preload` `<link>` (integrity-
-											// eligible per the SRI spec). `prefetch` gets none — the spec
-											// doesn't list it — so its `integrity` is left uncaptured.
+											const index = nextEntryIndex++;
+											const entryName = `__html_${moduleHash}_${index}`;
+											// Tag metadata letting the template mirror `crossorigin` and
+											// `integrity` onto a native `preload` `<link>`. `prefetch` is not
+											// integrity-eligible per the SRI spec, so its is left uncaptured.
 											const isNativeLink = elementName === "link";
 											const dep = new HtmlEntryDependency(
 												request,
@@ -1635,6 +1604,7 @@ class HtmlParser extends Parser {
 											).push({
 												request,
 												entryName,
+												index,
 												type,
 												css: asStyle
 											});
@@ -1649,7 +1619,8 @@ class HtmlParser extends Parser {
 											type === "modulepreload" ||
 											type === "stylesheet"
 										) {
-											const entryName = `__html_${moduleHash}_${nextEntryIndex++}`;
+											const index = nextEntryIndex++;
+											const entryName = `__html_${moduleHash}_${index}`;
 											const willBeModuleScript =
 												type === "script-module" ||
 												(outputModule && type === "script");
@@ -1693,13 +1664,9 @@ class HtmlParser extends Parser {
 													}
 												}
 											}
-											// Blocking-ness of the tag as *emitted*:
-											// `reconcileScriptTypeAttr` upgrades every script entry
-											// to `type="module"` under `output.module` and strips an
-											// authored `type="module"` otherwise — so only non-module
-											// output without `defer`/`async` blocks. Non-native
-											// elements anchor conservatively (their synthesized
-											// siblings may be plain blocking `<script>`s).
+											// Blocking-ness of the tag as emitted, not as authored:
+											// `reconcileScriptTypeAttr` decides the final `type`, so only
+											// non-module output without `defer`/`async` blocks.
 											if (
 												firstBlockingScriptStart === -1 &&
 												(type === "script" || type === "script-module") &&
@@ -1710,11 +1677,9 @@ class HtmlParser extends Parser {
 											) {
 												firstBlockingScriptStart = elementStart;
 											}
-											// Sibling-clone attribute edits, captured from the parsed
-											// attributes (offsets relative to the tag) so the template
-											// needn't re-parse the tag text: `integrity` is dropped
-											// (content-specific) and `script-module` clones are forced
-											// to `type="module"` (its value range, else inserted).
+											// Sibling-clone attribute edits, captured as offsets relative to
+											// the tag so the template need not re-parse it: `integrity` is
+											// content-specific and dropped, `script-module` forces `type`.
 											const integrityRange =
 												elementStart >= 0 && elementName === nativeTag
 													? captureIntegrityRange(path, source, elementStart)
@@ -1777,7 +1742,7 @@ class HtmlParser extends Parser {
 													: type === "stylesheet"
 														? stylesheetEntries
 														: modulePreloadEntries
-											).push({ request, entryName, type });
+											).push({ request, entryName, index, type });
 										} else {
 											const dep = new HtmlSourceDependency(request, [s, e]);
 											ResourceHintPlugin.applyDefaults(
@@ -1816,10 +1781,9 @@ class HtmlParser extends Parser {
 					}
 				}
 			})
-			// Skip AST output this walk never reads: `text` (script/style bodies are
-			// read by offset via `contentEnd`) and `doctype` — unless head injection
-			// needs the doctype as an insertion anchor; keep `comments` for
-			// magic comments (`webpackIgnore`).
+			// Skip AST output this walk never reads: `text`, since script and style
+			// bodies are read by offset, and `doctype` unless head injection needs it
+			// as an anchor. `comments` stays, for `webpackIgnore`.
 			.process(source, {
 				fragmentContext: this.fragmentContext,
 				skip: { text: true, doctype: headOptions === undefined }
@@ -1874,13 +1838,12 @@ class HtmlParser extends Parser {
 		const buildInfo = /** @type {HtmlModuleBuildInfo} */ (module.buildInfo);
 		buildInfo.strict = true;
 		if (baseUrlPrefix !== undefined) buildInfo.baseUrlPrefix = baseUrlPrefix;
-		// Hand off the collected entries to HtmlModulesPlugin; it creates the
-		// real compilation entries during the finishMake hook. The `script`
-		// and `script-module` groups are chained via a leader-only dependOn
-		// so they share a runtime; `modulepreload` and `stylesheet` entries
-		// are emitted as independent entries since `<link rel=modulepreload>`
-		// must preload without running and stylesheets have no runtime. `html`
-		// links are independent page entries too.
+		// WHY: hand the collected entries to HtmlModulesPlugin, which creates the
+		// real compilation entries during the finishMake hook. The `script` and
+		// `script-module` groups chain through a leader-only `dependOn` so they share
+		// a runtime, while `modulepreload` and `stylesheet` entries are independent:
+		// `<link rel=modulepreload>` must preload without running, and a stylesheet
+		// has no runtime. `html` links are independent page entries too.
 		if (
 			scriptEntries.length > 0 ||
 			scriptModuleEntries.length > 0 ||

package/lib/html/builtinEmbeddedRenderer.js

@@ -0,0 +1,107 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { CSS_TYPE } = require("../ModuleSourceTypeConstants");
+
+/** @import { CssProcessOptions } from "../css/syntax" */
+/** @import { EmbeddedSourceRenderer } from "./syntax" */
+
+/**
+ * What this minifies inline CSS with: the CSS minifier's own options, so an
+ * inline declaration is held to the rules a `.css` asset is.
+ * @typedef {Pick<CssProcessOptions, "environment" | "convertLengthUnits" | "rewriteCustomProperties" | "transforms" | "unusedSymbols" | "pseudoClasses">} BuiltinEmbeddedRendererOptions
+ */
+
+// Both are loaded on first render rather than at module load: a document that
+// embeds no CSS and no JSON pays for neither.
+/** @type {typeof import("../css/syntax") | undefined} */
+let _cssSyntax;
+/** @type {typeof import("./syntax") | undefined} */
+let _htmlSyntax;
+
+/**
+ * Strip the whitespace between a JSON body's tokens, every literal copied byte
+ * for byte. Re-serializing would round numbers, drop a duplicate key and rewrite
+ * the escapes that keep a string from closing the `<script>` early.
+ * @param {string} json a `<script>` body
+ * @returns {string} the stripped body, or the body as written where it is not JSON
+ */
+const stripJsonWhitespace = (json) => {
+	try {
+		JSON.parse(json);
+	} catch (_err) {
+		// Not JSON after all (a template, a placeholder) — not ours to touch.
+		return json;
+	}
+	let out = "";
+	let inString = false;
+	let escaped = false;
+	for (let i = 0; i < json.length; i++) {
+		const c = json.charCodeAt(i);
+		if (inString) {
+			out += json[i];
+			if (escaped) escaped = false;
+			else if (c === 0x5c) escaped = true;
+			else if (c === 0x22) inString = false;
+			continue;
+		}
+		if (c === 0x22) {
+			inString = true;
+			out += json[i];
+			continue;
+		}
+		// JSON whitespace (RFC 8259): tab, LF, CR, space.
+		if (c === 0x09 || c === 0x0a || c === 0x0d || c === 0x20) continue;
+		out += json[i];
+	}
+	return out;
+};
+
+/**
+ * The renderer webpack ships for what a document embeds: its own CSS minifier
+ * for a `<style>` or `style=""` and `stripJsonWhitespace` for JSON, declining
+ * every other language. A caller passes it where it has no renderer of its own,
+ * or behind one for the languages that one declines — the HTML printer minifies
+ * none of this itself.
+ * @param {BuiltinEmbeddedRendererOptions=} options the CSS minifier's options, so an inline declaration is minified as the `.css` assets are
+ * @returns {EmbeddedSourceRenderer} the renderer
+ */
+const builtinEmbeddedRenderer = (options = {}) => {
+	const { BLOCK_CONTENTS, JSON_TYPE } =
+		_htmlSyntax || (_htmlSyntax = require("./syntax"));
+	const sheet = { mode: /** @type {"minify"} */ ("minify"), ...options };
+	const block = { ...sheet, as: BLOCK_CONTENTS };
+	// A `style=""` repeats across a document far more often than it varies.
+	/** @type {Map<string, string>} */
+	const blocks = new Map();
+	return (source, info) => {
+		if (info.type === JSON_TYPE) return stripJsonWhitespace(source);
+		if (info.type !== CSS_TYPE) return undefined;
+		const isBlock = info.as === BLOCK_CONTENTS;
+		if (isBlock) {
+			const memoized = blocks.get(source);
+			if (memoized !== undefined) return memoized;
+		}
+		const { SourceProcessor } =
+			_cssSyntax || (_cssSyntax = require("../css/syntax"));
+		let code;
+		try {
+			code = new SourceProcessor().process(
+				source,
+				isBlock ? block : sheet
+			).code;
+		} catch (_err) {
+			// Text the minifier cannot read is left as written, by declining.
+			return undefined;
+		}
+		if (isBlock) blocks.set(source, code);
+		return code;
+	};
+};
+
+module.exports.builtinEmbeddedRenderer = builtinEmbeddedRenderer;
+module.exports.stripJsonWhitespace = stripJsonWhitespace;