webpack 5.108.2 → 5.108.4

package/lib/dependencies/ImportParserPlugin.js

@@ -435,15 +435,13 @@ class ImportParserPlugin {
 					}
 				}
 				if (importOptions.webpackExports !== undefined) {
-					if (
-						!(
-							typeof importOptions.webpackExports === "string" ||
-							(Array.isArray(importOptions.webpackExports) &&
-								importOptions.webpackExports.every(
-									(item) => typeof item === "string"
-								))
-						)
-					) {
+					if (!(
+						typeof importOptions.webpackExports === "string" ||
+						(Array.isArray(importOptions.webpackExports) &&
+							importOptions.webpackExports.every(
+								(item) => typeof item === "string"
+							))
+					)) {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,

package/lib/html/HtmlGenerator.js

@@ -14,8 +14,12 @@ const {
 } = require("../ModuleSourceTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const memoize = require("../util/memoize");
 const { PUBLIC_PATH_AUTO } = require("../util/publicPathPlaceholder");
 
+// Lazy so loading the HTML generator doesn't pull in the whole CSS pipeline.
+const getCssModulesPlugin = memoize(() => require("../css/CssModulesPlugin"));
+
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").HtmlGeneratorOptions} HtmlGeneratorOptions */
 /** @typedef {import("../Chunk")} Chunk */
@@ -31,6 +35,7 @@ const { PUBLIC_PATH_AUTO } = require("../util/publicPathPlaceholder");
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("./HtmlModule").HtmlModuleBuildInfo} HtmlModuleBuildInfo */
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/Hash")} Hash */
@@ -94,9 +99,7 @@ class HtmlGenerator extends Generator {
 				if (!chunk) return "data:,";
 				let filenameTemplate;
 				if (contentHashType === "css") {
-					const CssModulesPlugin = require("../css/CssModulesPlugin");
-
-					filenameTemplate = CssModulesPlugin.getChunkFilenameTemplate(
+					filenameTemplate = getCssModulesPlugin().getChunkFilenameTemplate(
 						chunk,
 						outputOptions
 					);
@@ -238,25 +241,53 @@ class HtmlGenerator extends Generator {
 
 	/**
 	 * Processes the provided module.
-	 * @param {NormalModule} module the current module
 	 * @param {Dependency} dependency the dependency 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 render context
+	 * @param {DependencyTemplateContext} templateContext the template context (shared across all dependencies of the module)
 	 * @returns {void}
 	 */
-	sourceDependency(module, dependency, initFragments, source, generateContext) {
+	sourceDependency(dependency, source, templateContext) {
 		const constructor =
 			/** @type {DependencyConstructor} */
 			(dependency.constructor);
-		const template = generateContext.dependencyTemplates.get(constructor);
+		const template = templateContext.dependencyTemplates.get(constructor);
 		if (!template) {
 			throw new Error(
 				`No template for dependency: ${dependency.constructor.name}`
 			);
 		}
 
-		/** @type {DependencyTemplateContext} */
+		template.apply(dependency, source, templateContext);
+	}
+
+	/**
+	 * Processes the provided dependencies block.
+	 * @param {import("../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}
+	 */
+	sourceBlock(block, source, templateContext) {
+		for (const dependency of block.dependencies) {
+			this.sourceDependency(dependency, source, templateContext);
+		}
+
+		for (const childBlock of block.blocks) {
+			this.sourceBlock(childBlock, source, templateContext);
+		}
+	}
+
+	/**
+	 * Processes the provided module.
+	 * @param {NormalModule} 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
+	 * @returns {void}
+	 */
+	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} */
 		let chunkInitFragments;
 		/** @type {DependencyTemplateContext} */
@@ -289,79 +320,18 @@ class HtmlGenerator extends Generator {
 			}
 		};
 
-		template.apply(dependency, source, templateContext);
-	}
-
-	/**
-	 * Processes the provided dependencies block.
-	 * @param {NormalModule} module the module to generate
-	 * @param {import("../DependenciesBlock")} block the dependencies block which will be processed
-	 * @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
-	 * @returns {void}
-	 */
-	sourceBlock(module, block, initFragments, source, generateContext) {
-		for (const dependency of block.dependencies) {
-			this.sourceDependency(
-				module,
-				dependency,
-				initFragments,
-				source,
-				generateContext
-			);
-		}
-
-		for (const childBlock of block.blocks) {
-			this.sourceBlock(
-				module,
-				childBlock,
-				initFragments,
-				source,
-				generateContext
-			);
-		}
-	}
-
-	/**
-	 * Processes the provided module.
-	 * @param {NormalModule} 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
-	 * @returns {void}
-	 */
-	sourceModule(module, initFragments, source, generateContext) {
 		for (const dependency of module.dependencies) {
-			this.sourceDependency(
-				module,
-				dependency,
-				initFragments,
-				source,
-				generateContext
-			);
+			this.sourceDependency(dependency, source, templateContext);
 		}
 
 		if (module.presentationalDependencies !== undefined) {
 			for (const dependency of module.presentationalDependencies) {
-				this.sourceDependency(
-					module,
-					dependency,
-					initFragments,
-					source,
-					generateContext
-				);
+				this.sourceDependency(dependency, source, templateContext);
 			}
 		}
 
 		for (const childBlock of module.blocks) {
-			this.sourceBlock(
-				module,
-				childBlock,
-				initFragments,
-				source,
-				generateContext
-			);
+			this.sourceBlock(childBlock, source, templateContext);
 		}
 	}
 
@@ -403,7 +373,12 @@ class HtmlGenerator extends Generator {
 
 		// JS-export path — resolve `[webpack/auto]` inline; chunk-URL sentinels
 		// stay for `HtmlModulesPlugin`'s `JavascriptModulesPlugin.render` tap.
-		return rawContent.split(PUBLIC_PATH_AUTO).join(undoPath);
+		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 || "";
+		return rawContent.split(PUBLIC_PATH_AUTO).join(basePrefix + undoPath);
 	}
 
 	/**
@@ -603,10 +578,12 @@ class HtmlGenerator extends Generator {
 		// Source-type set changes when html-type exposure flips; the HMR shim's
 		// `extracting` branch changes when the emit decision flips. They differ
 		// only for `"inline"` (exposes html, but does not emit), so hash both.
-		if (this._shouldExposeHtmlType(updateHashContext.module)) {
+		// One `_shouldExtract` walk covers both checks (expose = extract ∪ inline).
+		const extract = this._shouldExtract(updateHashContext.module);
+		if (extract || this.options.extract === "inline") {
 			hash.update("html-type");
 		}
-		if (this._shouldExtract(updateHashContext.module)) {
+		if (extract) {
 			hash.update("extract");
 		}
 		// The HMR shim emits additional self-accept / DOM-patch code that

package/lib/html/HtmlModule.js

@@ -15,6 +15,7 @@ const makeSerializable = require("../util/makeSerializable");
  * Defines the build info properties specific to html modules.
  * @typedef {object} KnownHtmlModuleBuildInfo
  * @property {Record<string, EntryScriptInfo[]>=} htmlEntryScripts entries collected from the document, grouped by kind
+ * @property {string=} baseUrlPrefix `../` per `<base href>` path segment, prepended to the auto-public-path undo path so a relative base doesn't misdirect bundled URLs
  */
 
 /** @typedef {NormalModuleBuildInfo & KnownHtmlModuleBuildInfo} HtmlModuleBuildInfo */

package/lib/html/HtmlModulesPlugin.js

@@ -568,14 +568,21 @@ class HtmlModulesPlugin {
 							// `main.js` root-relative, so the browser would resolve
 							// them under the HTML's directory instead of the
 							// `output.path` root.
-							const undoPath = getUndoPath(
-								filename,
-								/** @type {string} */ (outputOptions.path),
-								false
-							);
-							const finalContent = resolvedContent
-								.split(autoPlaceholder)
-								.join(undoPath);
+							// A relative `<base href>` prepends `../`s so the base can't
+							// misdirect the rewritten URLs (see `HtmlParser`).
+							const basePrefix =
+								/** @type {HtmlModuleBuildInfo} */ (normalModule.buildInfo)
+									.baseUrlPrefix || "";
+							const undoPath =
+								basePrefix +
+								getUndoPath(
+									filename,
+									/** @type {string} */ (outputOptions.path),
+									false
+								);
+							const finalContent = resolvedContent.includes(autoPlaceholder)
+								? resolvedContent.split(autoPlaceholder).join(undoPath)
+								: resolvedContent;
 							const finalSource = new RawSource(finalContent);
 							// The same HTML module can land in multiple chunks
 							// with different `output.htmlFilename` /
@@ -585,11 +592,15 @@ class HtmlModulesPlugin {
 							// the emitted filename in the asset cache key and
 							// the post-undo-path content in the hash, so the
 							// asset cache can't reuse one variant's bytes at
-							// another variant's URL.
-							const finalContentHash = HtmlModulesPlugin.computeContentHash(
-								finalContent,
-								outputOptions
-							);
+							// another variant's URL. Unchanged content reuses
+							// the memoized hash instead of re-digesting.
+							const finalContentHash =
+								finalContent === resolvedContent
+									? contentHash
+									: HtmlModulesPlugin.computeContentHash(
+											finalContent,
+											outputOptions
+										);
 
 							result.push({
 								render: () => finalSource,