webpack 5.111.1 → 5.112.1

package/lib/html/HtmlGenerator.js

@@ -5,18 +5,18 @@
 "use strict";
 
 const { RawSource, ReplaceSource } = require("webpack-sources");
-const ConcatenationScope = require("../ConcatenationScope");
-const Generator = require("../Generator");
+const CssModulesPlugin = require("../css/CssModulesPlugin");
+const WebpackError = require("../errors/WebpackError");
+const Generator = require("../module/Generator");
 const {
 	HTML_TYPE,
 	HTML_TYPES,
 	JAVASCRIPT_TYPE,
 	JAVASCRIPT_TYPES
-} = require("../ModuleSourceTypeConstants");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
-const CssModulesPlugin = require("../css/CssModulesPlugin");
-const WebpackError = require("../errors/WebpackError");
+} = require("../module/ModuleSourceTypeConstants");
+const ConcatenationScope = require("../optimize/ConcatenationScope");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const Template = require("../template/Template");
 const { getUndoPath } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const { PUBLIC_PATH_AUTO } = require("../util/publicPathPlaceholder");
@@ -24,7 +24,9 @@ const { VOID } = require("./data");
 
 const getCreateNodeHash = memoize(() => require("crypto").createHash);
 
-const getCssSyntax = memoize(() => require("../css/syntax"));
+const getCssParser = memoize(() => require("../css/syntax-parser"));
+
+const getHtmlParser = memoize(() => require("./syntax-parser"));
 
 const getHtmlSyntax = memoize(() => require("./syntax"));
 
@@ -48,7 +50,7 @@ const getHtmlSyntax = memoize(() => require("./syntax"));
 const serializeAttrs = (attrs) => {
 	let out = "";
 	if (attrs) {
-		const { escapeAttribute } = getHtmlSyntax();
+		const { escapeAttribute } = getHtmlParser();
 		for (const name of Object.keys(attrs)) {
 			const value = attrs[name];
 			if (value === false || value === undefined || value === null) continue;
@@ -125,9 +127,11 @@ const metaIsCsp = (attrs) => {
 	return false;
 };
 
+/** @import { BuiltHtmlModule, HtmlNormalModule } from "./HtmlModule" */
 /** @import { Source } from "webpack-sources" */
 /** @import { HtmlGeneratorOptions } from "../../declarations/WebpackOptions" */
 /** @typedef {import("../../declarations/WebpackOptions").OutputHtmlOptions["csp"]} CspOption */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized["html"]} HtmlOption */
 /** @import { HtmlTagDescriptor, HtmlMutableTag } from "./HtmlModulesPlugin" */
 /** @typedef {"head" | "body"} HtmlTagLocation */
 /**
@@ -142,29 +146,28 @@ const metaIsCsp = (attrs) => {
  */
 /** @typedef {{ headOpen: number, headEnd: number, bodyOpen: number, bodyEnd: number }} HtmlAnchors */
 /** @typedef {{ tags: HtmlMutableTag[], spans: (HtmlTagSpan | null)[], originals: (string | null)[], descriptors: (HtmlTagDescriptor | null)[], anchors: HtmlAnchors }} HtmlModel */
-/** @import Chunk from "../Chunk" */
+/** @import Chunk from "../graph/Chunk" */
 /** @import Compilation, { DependencyConstructor } from "../Compilation" */
 /** @typedef {boolean | string[] | ((asset: { chunk: Chunk, filename: string }) => string[] | false)} HtmlIntegrity */
-/** @import CodeGenerationResults from "../CodeGenerationResults" */
-/** @import Dependency from "../Dependency" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import { GenerateContext, UpdateHashContext } from "../Generator" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
+/** @import Dependency from "../graph/Dependency" */
+/** @import { DependencyTemplateContext } from "../template/DependencyTemplate" */
+/** @import { GenerateContext, UpdateHashContext } from "../module/Generator" */
 /**
  * @import Module, {
  * 	SourceType,
  * 	SourceTypes,
  * 	ConcatenationBailoutReasonContext,
  * 	RuntimeRequirements
- * } from "../Module"
+ * } from "../module/Module"
  */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import NormalModule from "../NormalModule" */
-/** @import { HtmlModuleBuildInfo } from "./HtmlModule" */
-/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import NormalModule from "../module/NormalModule" */
+/** @import RuntimeTemplate from "../template/RuntimeTemplate" */
 /** @import Hash from "../util/Hash" */
 /**
  * @template T
- * @typedef {import("../InitFragment")<T>} InitFragment
+ * @typedef {import("../template/InitFragment")<T>} InitFragment
  */
 
 /**
@@ -253,6 +256,10 @@ const INTEGRITY_SENTINEL_STRIP_REGEXP =
 // The resolver ignores it.
 const INLINE_SENTINEL_REGEXP =
 	/__WEBPACK_HTML_INLINE__([0-9a-f]+)__([a-z]+)(?:__[0-9a-f]+)?__END__/g;
+// The same, with the `;` a minifier ends the sentinel's statement with, which a
+// chunk ending in its own `;` would double.
+const INLINE_SENTINEL_STATEMENT_REGEXP =
+	/__WEBPACK_HTML_INLINE__([0-9a-f]+)__([a-z]+)(?:__[0-9a-f]+)?__END__(;?)/g;
 
 /**
  * Rewrite relative `url(...)` references in a CSS chunk so they still resolve
@@ -272,7 +279,7 @@ const rebaseCssUrls = (css, fromFile, toFile, outputPath) => {
 	const fromUndo = getUndoPath(fromFile, outputPath, false);
 	const toUndo = getUndoPath(toFile, outputPath, false);
 	if (fromUndo === toUndo) return css;
-	const { readToken, TT_URL } = getCssSyntax();
+	const { readToken, TokenType } = getCssParser();
 	const token = {
 		type: 0,
 		start: 0,
@@ -287,7 +294,7 @@ const rebaseCssUrls = (css, fromFile, toFile, outputPath) => {
 	let out = "";
 	while (readToken(css, pos, token) !== undefined) {
 		pos = token.end;
-		if (token.type !== TT_URL) continue;
+		if (token.type !== TokenType.Url) continue;
 		const url = css.slice(token.contentStart, token.contentEnd);
 		// Rebase only the undo-path-relative urls; a root-relative (`/`), fragment
 		// (`#`) or scheme (`data:`, …, a `:` before any `/`) url is absolute.
@@ -309,6 +316,14 @@ const rebaseCssUrls = (css, fromFile, toFile, outputPath) => {
 	return last === 0 ? css : out + css.slice(last);
 };
 
+/**
+ * The module type the JSDoc inherited from `Generator` names.
+ * @typedef {HtmlNormalModule} TModule
+ */
+
+/**
+ * @extends {Generator<TModule>}
+ */
 class HtmlGenerator extends Generator {
 	/**
 	 * Emit a sentinel for a chunk URL that can't be resolved at code-gen time
@@ -359,7 +374,7 @@ class HtmlGenerator extends Generator {
 					);
 				}
 				const filename = compilation.getPath(
-					/** @type {import("../TemplatedPathPlugin").TemplatePath} */
+					/** @type {import("../template/TemplatedPathPlugin").TemplatePath} */
 					(filenameTemplate),
 					{
 						chunk,
@@ -430,7 +445,7 @@ class HtmlGenerator extends Generator {
 		if (!content.includes("__WEBPACK_HTML_ASSET_URL__")) return content;
 		const byIdentifier = getModulesByIdentifier(compilation);
 		const codeGenerationResults =
-			/** @type {import("../CodeGenerationResults")} */
+			/** @type {import("../module/CodeGenerationResults")} */
 			(compilation.codeGenerationResults);
 		return content.replace(ASSET_URL_SENTINEL_REGEXP, (_, hex) => {
 			const id = Buffer.from(hex, "hex").toString("utf8");
@@ -575,6 +590,51 @@ class HtmlGenerator extends Generator {
 		);
 	}
 
+	/**
+	 * Whether a chunk's content may be written into the page at all. An ES
+	 * module chunk another group loads the runtime from must stay a file, or
+	 * the page would run two copies of it.
+	 * @param {Compilation} compilation the compilation
+	 * @param {Chunk} chunk chunk to test
+	 * @returns {boolean} false when the chunk has to stay a separate file
+	 */
+	static canInlineChunk(compilation, chunk) {
+		if (compilation.outputOptions.module !== true) return true;
+		for (const group of chunk.groupsIterable) {
+			if (group.getChildren().length > 0) return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Whether `output.html.inline` writes a chunk's content into the page rather
+	 * than referencing it. The string forms select by asset type, since a
+	 * chunk's JavaScript and CSS share one name.
+	 * @param {HtmlOption} htmlOption the `output.html` option
+	 * @param {Chunk} chunk chunk to test
+	 * @param {"javascript" | "css"} contentType which asset of the chunk is emitted
+	 * @returns {boolean} true when that content is written into the page
+	 */
+	static isChunkInlined(htmlOption, chunk, contentType) {
+		const inlineOption =
+			typeof htmlOption === "object" ? htmlOption.inline : undefined;
+		if (!inlineOption) return false;
+		if (inlineOption === true) return true;
+		if (inlineOption === "script") return contentType === "javascript";
+		if (inlineOption === "style") return contentType === "css";
+		// A tag's chunk is named after its page, so the template it emits under is
+		// matched too; a global pattern carries `lastIndex`, so it is reset.
+		const name = chunk.name || String(chunk.id);
+		const { filenameTemplate } = chunk;
+		return inlineOption.some((re) => {
+			re.lastIndex = 0;
+			if (re.test(name)) return true;
+			if (typeof filenameTemplate !== "string") return false;
+			re.lastIndex = 0;
+			return re.test(filenameTemplate);
+		});
+	}
+
 	/**
 	 * @param {Chunk} chunk chunk
 	 * @param {"javascript" | "css"} contentHashType which chunk asset to inline
@@ -603,13 +663,13 @@ class HtmlGenerator extends Generator {
 	) {
 		if (!content.includes("__WEBPACK_HTML_INLINE__")) return content;
 		const chunksById = getChunksById(compilation);
-		const outputPath = /** @type {string} */ (compilation.outputOptions.path);
+		const outputPath = compilation.outputOptions.path;
 		return content.replace(
-			INLINE_SENTINEL_REGEXP,
-			(_, hexId, contentHashType) => {
+			INLINE_SENTINEL_STATEMENT_REGEXP,
+			(_, hexId, contentHashType, terminator) => {
 				const chunkId = Buffer.from(hexId, "hex").toString("utf8");
 				const chunk = chunksById.get(chunkId);
-				if (!chunk) return "";
+				if (!chunk) return terminator;
 				const isCss = contentHashType === "css";
 				let out = "";
 				for (const file of chunk.files) {
@@ -635,7 +695,7 @@ class HtmlGenerator extends Generator {
 					out += raw;
 					if (inlinedFiles) inlinedFiles.add(file);
 				}
-				return out;
+				return out.endsWith(";") ? out : out + terminator;
 			}
 		);
 	}
@@ -670,17 +730,28 @@ class HtmlGenerator extends Generator {
 		// `skip.text` populates `contentEnd` (raw-text body end) without
 		// materializing text nodes; `</script` stays escaped, so CSP hashes match
 		// the exact bytes the browser sees.
-		const { NodeType, SourceProcessor } = getHtmlSyntax();
+		const { Field, Flag, NodeType, Part } = getHtmlParser();
+		const { SourceProcessor } = getHtmlSyntax();
+		/**
+		 * Where an element's content starts; a parser-inserted one has no tag, so
+		 * its content starts where it does.
+		 * @param {import("./syntax-parser").HtmlPath} path the element's path
+		 * @returns {number} the offset
+		 */
+		const contentStart = (path) => {
+			const start = path.startOf(Part.content);
+			return start === -1 ? path.start() : start;
+		};
 		new SourceProcessor()
 			.use({
 				[NodeType.Element]: {
 					enter: (path) => {
-						const name = path.tagName();
+						const name = path.name();
 						if (name === "head") {
-							if (headOpen < 0) headOpen = headEnd = path.tagEnd();
+							if (headOpen < 0) headOpen = headEnd = contentStart(path);
 							headDepth++;
 						} else if (name === "body") {
-							if (bodyOpen < 0) bodyOpen = bodyEnd = path.tagEnd();
+							if (bodyOpen < 0) bodyOpen = bodyEnd = contentStart(path);
 							bodyDepth++;
 						}
 					},
@@ -688,7 +759,7 @@ class HtmlGenerator extends Generator {
 					// closes. `script`, `style`, `link` and `meta` never nest in each
 					// other, so exiting keeps them in source order.
 					exit: (path) => {
-						const name = path.tagName();
+						const name = path.name();
 						if (name === "head") {
 							if (headDepth > 0) headDepth--;
 							return;
@@ -710,13 +781,14 @@ class HtmlGenerator extends Generator {
 						}
 						/** @type {Record<string, string | boolean | undefined>} */
 						const attrs = {};
-						const count = path.attributeCount();
+						const count = path.fieldCount(Field.attributes);
 						for (let i = 0; i < count; i++) {
-							const attr = path.attributeAt(i);
-							attrs[path.attributeName(attr)] =
-								path.attributeValueStart(attr) === -1
+							const attr = path.field(i, Field.attributes);
+							const valueStart = path.startOf(Part.value, attr);
+							attrs[path.name(attr)] =
+								valueStart === -1
 									? true
-									: path.attributeValue(attr);
+									: path.source(valueStart, path.endOf(Part.value, attr));
 						}
 						const isRawText = name === "script" || name === "style";
 						tags.push({
@@ -726,12 +798,12 @@ class HtmlGenerator extends Generator {
 						});
 						spans.push({
 							start: path.start(),
-							openEnd: path.tagEnd(),
+							openEnd: path.startOf(Part.content),
 							end,
 							location: bodyDepth > 0 ? "body" : "head",
-							nameEnd: isRawText ? path.nameEnd() : -1,
-							contentEnd: isRawText ? path.contentEnd() : -1,
-							selfClosing: path.selfClosing()
+							nameEnd: isRawText ? path.endOf(Part.name) : -1,
+							contentEnd: isRawText ? path.endOf(Part.content) : -1,
+							selfClosing: path.flag(Flag.selfClosing)
 						});
 						originals.push(snapshotAttrs(attrs));
 						descriptors.push(null);
@@ -786,7 +858,7 @@ class HtmlGenerator extends Generator {
 	 * @returns {string} the rendered HTML
 	 */
 	static renderHtml(content, model, csp) {
-		const { escapeAttribute } = getHtmlSyntax();
+		const { escapeAttribute } = getHtmlParser();
 		const { tags, spans, originals, descriptors, anchors } = model;
 		// CSP setup: an author-declared policy (page's own or injected) wins.
 		const options = csp ? (csp === true ? {} : csp) : undefined;
@@ -1057,7 +1129,7 @@ class HtmlGenerator extends Generator {
 
 	/**
 	 * Returns the reason this module cannot be concatenated, when one exists.
-	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {TModule} module module for which the bailout reason should be determined
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
@@ -1077,7 +1149,7 @@ class HtmlGenerator extends Generator {
 	 * `originModule` (the EntryDependency added by `compilation.addEntry`) —
 	 * this covers both HTML-as-entry-point and a linked `type: "html"` page
 	 * (added as its own entry by HtmlModulesPlugin).
-	 * @param {NormalModule} module module
+	 * @param {TModule} module module
 	 * @returns {boolean} true when the module is an entry
 	 */
 	_isEntryModule(module) {
@@ -1094,7 +1166,7 @@ class HtmlGenerator extends Generator {
 	 * when the option is left unspecified, extraction defaults to on for HTML
 	 * modules used as compilation entries — that's the HTML-as-entry-point case
 	 * and a linked `type: "html"` page (which is added as its own entry).
-	 * @param {NormalModule} module module
+	 * @param {TModule} module module
 	 * @returns {boolean} true when the `.html` file should be emitted
 	 */
 	_shouldExtract(module) {
@@ -1108,7 +1180,7 @@ class HtmlGenerator extends Generator {
 	 * Whether this module exposes the `html` source type. Like `_shouldExtract`,
 	 * but `"inline"` also exposes it — the processed HTML is read back into the
 	 * host attribute (e.g. `<iframe srcdoc>`) instead of emitted as a file.
-	 * @param {NormalModule} module module
+	 * @param {TModule} module module
 	 * @returns {boolean} true when the `html` source type is available
 	 */
 	_shouldExposeHtmlType(module) {
@@ -1118,7 +1190,7 @@ class HtmlGenerator extends Generator {
 
 	/**
 	 * Returns the source types available for this module.
-	 * @param {NormalModule} module fresh module
+	 * @param {TModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
@@ -1142,7 +1214,7 @@ class HtmlGenerator extends Generator {
 
 	/**
 	 * Returns the estimated size for the requested source type.
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
@@ -1176,7 +1248,7 @@ class HtmlGenerator extends Generator {
 
 	/**
 	 * Processes the provided dependencies block.
-	 * @param {import("../DependenciesBlock")} block the dependencies block which will be processed
+	 * @param {import("../graph/DependenciesBlock")} block the dependencies block which will be processed
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the template context
 	 * @returns {void}
@@ -1193,7 +1265,7 @@ class HtmlGenerator extends Generator {
 
 	/**
 	 * Processes the provided module.
-	 * @param {NormalModule} module the module to generate
+	 * @param {TModule} module the module to generate
 	 * @param {InitFragment<GenerateContext>[]} initFragments mutable list of init fragments
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {GenerateContext} generateContext the generateContext
@@ -1202,7 +1274,7 @@ class HtmlGenerator extends Generator {
 	sourceModule(module, initFragments, source, generateContext) {
 		// Only `dependency` varies across `template.apply` calls, so one context
 		// (and one lazy `chunkInitFragments` getter) serves the whole module.
-		/** @type {InitFragment<GenerateContext>[] | undefined} */
+		/** @type {InitFragment<import("../javascript/JavascriptModulesPlugin").ChunkRenderContext>[] | undefined} */
 		let chunkInitFragments;
 		/** @type {DependencyTemplateContext} */
 		const templateContext = {
@@ -1257,7 +1329,7 @@ class HtmlGenerator extends Generator {
 	 * `undefined`, the placeholders are preserved so the caller (typically
 	 * `HtmlModulesPlugin#renderManifest`, which only knows the final
 	 * `.html` filename after code generation) can resolve them itself.
-	 * @param {NormalModule} module the module to render
+	 * @param {TModule} module the module to render
 	 * @param {GenerateContext} generateContext the generate context
 	 * @param {string=} undoPath value to substitute for `[webpack/auto]` placeholders
 	 * @returns {string} the rewritten HTML
@@ -1289,14 +1361,14 @@ class HtmlGenerator extends Generator {
 		if (!rawContent.includes(PUBLIC_PATH_AUTO)) return rawContent;
 		// A relative `<base href>` prepends `../`s so the base can't misdirect
 		// the rewritten URLs (see `HtmlParser`).
-		const basePrefix =
-			/** @type {HtmlModuleBuildInfo} */ (module.buildInfo).baseUrlPrefix || "";
+		const { buildInfo } = /** @type {BuiltHtmlModule} */ (module);
+		const basePrefix = buildInfo.baseUrlPrefix || "";
 		return rawContent.split(PUBLIC_PATH_AUTO).join(basePrefix + undoPath);
 	}
 
 	/**
 	 * Generates generated code for this runtime module.
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
@@ -1393,7 +1465,7 @@ class HtmlGenerator extends Generator {
 	 * express — fine in a dev-server context because the regular
 	 * (non-hot-update) `page.html` chunk is re-emitted on every rebuild,
 	 * so the reloaded page picks up the new head.
-	 * @param {NormalModule} module module
+	 * @param {TModule} module module
 	 * @param {string} html the rewritten HTML content (with placeholders resolved)
 	 * @param {boolean} extracting whether the HTML module is being extracted as a real `.html` file
 	 * @param {RuntimeTemplate} runtimeTemplate runtime template (drives `const`/arrow emission based on environment support)
@@ -1613,7 +1685,7 @@ class HtmlGenerator extends Generator {
 	/**
 	 * Generates fallback output for the provided error condition.
 	 * @param {Error} error the error
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
@@ -1640,7 +1712,7 @@ class HtmlGenerator extends Generator {
 	/**
 	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 * @param {UpdateHashContext<TModule>} updateHashContext context for updating hash
 	 */
 	updateHash(hash, updateHashContext) {
 		hash.update("html");

package/lib/html/HtmlModule.js

@@ -4,16 +4,17 @@
 
 "use strict";
 
-const NormalModule = require("../NormalModule");
+const NormalModule = require("../module/NormalModule");
 const makeSerializable = require("../util/makeSerializable");
 
 /**
  * @import {
  * 	NormalModuleBuildInfo,
  * 	NormalModuleCreateData
- * } from "../NormalModule"
+ * } from "../module/NormalModule"
  */
 /** @import { HtmlEntryInfo } from "./HtmlModulesPlugin" */
+/** @import { BuildMeta, ModuleKinds } from "../module/Module" */
 
 /**
  * Defines the build info properties specific to html modules.
@@ -24,6 +25,16 @@ const makeSerializable = require("../util/makeSerializable");
 
 /** @typedef {NormalModuleBuildInfo & KnownHtmlModuleBuildInfo} HtmlModuleBuildInfo */
 
+/**
+ * An html module before or after its build, typed with its build info.
+ * @typedef {NormalModule & { buildInfo?: HtmlModuleBuildInfo }} HtmlNormalModule
+ */
+
+/**
+ * A built html module, typed with its build info and build meta.
+ * @typedef {NormalModule & { buildInfo: HtmlModuleBuildInfo, buildMeta: BuildMeta }} BuiltHtmlModule
+ */
+
 /**
  * Module class for `html` modules. HTML-specific properties should live here instead of `NormalModule`.
  */
@@ -42,4 +53,7 @@ class HtmlModule extends NormalModule {
 
 makeSerializable(HtmlModule, "webpack/lib/html/HtmlModule");
 
+/** @type {Set<keyof ModuleKinds>} */
+HtmlModule.KINDS = new Set([...NormalModule.KINDS, "html"]);
+
 module.exports = HtmlModule;