webpack 5.107.1 → 5.108.0

package/lib/dependencies/HtmlInlineHtmlDependency.js

@@ -0,0 +1,107 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const { HTML_TYPE } = require("../ModuleSourceTypeConstants");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../util/Hash")} 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.
+const ATTR_ESCAPE_REGEXP = /[&"']/g;
+/** @type {Record<string, string>} */
+const ATTR_ESCAPES = { "&": "&amp;", '"': "&quot;", "'": "&#39;" };
+/**
+ * @param {string} c matched character
+ * @returns {string} the HTML-attribute-escaped entity
+ */
+const escapeAttrChar = (c) => ATTR_ESCAPES[c];
+
+/**
+ * Represents an `<iframe srcdoc="...">` attribute — an entity-encoded HTML
+ * document. The decoded document is fed back through webpack's HTML pipeline as
+ * a virtual `data:text/html` module so its asset URLs resolve relative to the
+ * host HTML file. At render time the attribute value is replaced with the
+ * processed HTML read from the nested module's `html` code-generation data,
+ * re-escaped so the surrounding attribute stays valid.
+ */
+class HtmlInlineHtmlDependency extends ModuleDependency {
+	/**
+	 * @param {string} request virtual request resolving to the inline HTML (data URI)
+	 * @param {Range} range range of the `srcdoc` attribute value
+	 */
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+	}
+
+	get type() {
+		return "html inline html";
+	}
+
+	get category() {
+		return "html-srcdoc";
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		// Recurse so the inline HTML's transitive deps (assets) propagate up.
+		// The module is guaranteed — it is registered as a code-generation dependency.
+		const module = /** @type {Module} */ (
+			context.chunkGraph.moduleGraph.getModule(this)
+		);
+		module.updateHash(hash, context);
+	}
+}
+
+HtmlInlineHtmlDependency.Template = class HtmlInlineHtmlDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { moduleGraph, runtime, codeGenerationResults }) {
+		const dep = /** @type {HtmlInlineHtmlDependency} */ (dependency);
+		// The module is guaranteed — it is registered as a code-generation dependency.
+		const module = /** @type {Module} */ (moduleGraph.getModule(dep));
+		const codeGen =
+			/** @type {CodeGenerationResults} */
+			(codeGenerationResults).get(module, runtime);
+		const htmlSource = codeGen.sources.get(HTML_TYPE);
+
+		// The attribute value was entity-decoded before parsing, so re-escape the
+		// processed HTML to keep the surrounding `srcdoc="..."` attribute valid.
+		const htmlText = (
+			htmlSource ? /** @type {string} */ (htmlSource.source()) : ""
+		).replace(ATTR_ESCAPE_REGEXP, escapeAttrChar);
+
+		source.replace(dep.range[0], dep.range[1] - 1, htmlText);
+	}
+};
+
+makeSerializable(
+	HtmlInlineHtmlDependency,
+	"webpack/lib/dependencies/HtmlInlineHtmlDependency"
+);
+
+module.exports = HtmlInlineHtmlDependency;

package/lib/dependencies/HtmlInlineScriptDependency.js

@@ -4,8 +4,8 @@
 
 "use strict";
 
+const HtmlGenerator = require("../html/HtmlGenerator");
 const makeSerializable = require("../util/makeSerializable");
-const CssUrlDependency = require("./CssUrlDependency");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -14,8 +14,8 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[number, Range, string, string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[number, Range, string, string]>} ObjectSerializerContext */
 
 /**
  * Represents an inline `<script>...</script>` block in an HTML module. The
@@ -34,9 +34,11 @@ class HtmlInlineScriptDependency extends ModuleDependency {
 	 */
 	constructor(request, insertPos, contentRange, entryName, category) {
 		super(request);
+		/** @type {number} */
 		this.insertPos = insertPos;
 		this.contentRange = contentRange;
 		this.range = contentRange;
+		/** @type {string} */
 		this.entryName = entryName;
 		/** @type {string} */
 		this._category = category || "commonjs";
@@ -55,11 +57,11 @@ class HtmlInlineScriptDependency extends ModuleDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.insertPos);
-		write(this.contentRange);
-		write(this.entryName);
-		write(this._category);
+		context
+			.write(this.insertPos)
+			.write(this.contentRange)
+			.write(this.entryName)
+			.write(this._category);
 		super.serialize(context);
 	}
 
@@ -68,13 +70,15 @@ class HtmlInlineScriptDependency extends ModuleDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.insertPos = read();
-		this.contentRange = read();
+		this.insertPos = context.read();
+		const c1 = context.rest;
+		this.contentRange = c1.read();
 		this.range = this.contentRange;
-		this.entryName = read();
-		this._category = read();
-		super.deserialize(context);
+		const c2 = c1.rest;
+		this.entryName = c2.read();
+		const c3 = c2.rest;
+		this._category = c3.read();
+		super.deserialize(c3.rest);
 	}
 }
 
@@ -101,19 +105,8 @@ HtmlInlineScriptDependency.Template = class HtmlInlineScriptDependencyTemplate e
 
 		if (entrypoint) {
 			const chunk = /** @type {Chunk} */ (entrypoint.getEntrypointChunk());
-			const outputOptions = runtimeTemplate.outputOptions;
-			const filenameTemplate =
-				chunk.filenameTemplate ||
-				(chunk.canBeInitial()
-					? outputOptions.filename
-					: outputOptions.chunkFilename);
-
-			const filename = compilation.getPath(filenameTemplate, {
-				chunk,
-				contentHashType: "javascript"
-			});
-
-			url = `${CssUrlDependency.PUBLIC_PATH_AUTO}${filename}`;
+			// Defer chunk-URL substitution to renderManifest — chunk hashes aren't ready yet.
+			url = HtmlGenerator.makeChunkUrlSentinel(chunk, "javascript");
 		}
 
 		// Insert ` src="…"` right after `<script` so the inline body is

package/lib/dependencies/HtmlInlineStyleDependency.js

@@ -10,31 +10,54 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<boolean[]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<boolean[]>} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+const TRAILING_WHITESPACE_REGEXP = /\s+$/;
+// 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
+// while avoiding two extra full-string scans + intermediate strings.
+const ATTR_ESCAPE_REGEXP = /[&"']/g;
+/** @type {Record<string, string>} */
+const ATTR_ESCAPES = { "&": "&amp;", '"': "&quot;", "'": "&#39;" };
 /**
- * Represents an inline `<style>...</style>` block in an HTML module. The
- * tag's content is fed into webpack's CSS pipeline as a virtual CSS module
- * with `exportType: "text"` so `url()` and `\@import` references are
- * resolved relative to the HTML file. At render time the original content
- * range is replaced with the processed CSS text read from the CSS module's
- * code generation data.
+ * @param {string} c matched character
+ * @returns {string} the HTML-attribute-escaped entity
+ */
+const escapeAttrChar = (c) => ATTR_ESCAPES[c];
+
+/**
+ * Represents inline CSS in an HTML module — either a `<style>...</style>`
+ * block (a stylesheet) or an element's `style="..."` attribute (a CSS
+ * block's contents). The content is fed into webpack's CSS pipeline as a
+ * virtual CSS module with `exportType: "text"` so `url()` and `\@import`
+ * references are resolved relative to the HTML file. At render time the
+ * original content range is replaced with the processed CSS text read from
+ * the CSS module's code generation data.
  */
 class HtmlInlineStyleDependency extends ModuleDependency {
 	/**
 	 * Creates an instance of HtmlInlineStyleDependency.
 	 * @param {string} request virtual request resolving to the inline CSS (data URI)
-	 * @param {Range} range range of the inline CSS content (between `<style>` and `</style>`)
+	 * @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
 	 */
-	constructor(request, range) {
+	constructor(request, range, attribute = false, inAttribute = attribute) {
 		super(request);
 		this.range = range;
+		/** @type {boolean} */
+		this.attribute = attribute;
+		/** @type {boolean} */
+		this.inAttribute = inAttribute;
 	}
 
 	get type() {
@@ -42,7 +65,21 @@ class HtmlInlineStyleDependency extends ModuleDependency {
 	}
 
 	get category() {
-		return "html-style";
+		return this.attribute ? "html-style-attribute" : "html-style";
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		// Recurse so the inline CSS's transitive deps (e.g. `url(asset)`) propagate up.
+		const { chunkGraph } = context;
+		const module = chunkGraph.moduleGraph.getModule(this);
+		if (!module) return;
+		module.updateHash(hash, context);
 	}
 
 	/**
@@ -51,6 +88,8 @@ class HtmlInlineStyleDependency extends ModuleDependency {
 	 */
 	serialize(context) {
 		super.serialize(context);
+		context.write(this.attribute);
+		context.write(this.inAttribute);
 	}
 
 	/**
@@ -59,6 +98,8 @@ class HtmlInlineStyleDependency extends ModuleDependency {
 	 */
 	deserialize(context) {
 		super.deserialize(context);
+		this.attribute = context.read();
+		this.inAttribute = context.read();
 	}
 }
 
@@ -89,6 +130,16 @@ HtmlInlineStyleDependency.Template = class HtmlInlineStyleDependencyTemplate ext
 			}
 		}
 
+		// An attribute value was entity-decoded before parsing, so re-escape
+		// the processed CSS to keep the surrounding markup valid in any
+		// quoting context, and drop the trailing newline the CSS generator
+		// appends so the rewritten attribute stays on one line.
+		if (dep.inAttribute) {
+			cssText = cssText
+				.replace(TRAILING_WHITESPACE_REGEXP, "")
+				.replace(ATTR_ESCAPE_REGEXP, escapeAttrChar);
+		}
+
 		source.replace(dep.range[0], dep.range[1] - 1, cssText);
 	}
 };

package/lib/dependencies/HtmlSourceDependency.js

@@ -13,14 +13,17 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 const getIgnoredRawDataUrlModule = memoize(
@@ -55,6 +58,21 @@ class HtmlSourceDependency extends ModuleDependency {
 		return getIgnoredRawDataUrlModule();
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		// Fold in the asset's hash so the HTML invalidates when the embedded URL changes.
+		const { chunkGraph } = context;
+		const module = chunkGraph.moduleGraph.getModule(this);
+		if (!module) return;
+		const { hash: buildHash } = /** @type {BuildInfo} */ (module.buildInfo);
+		if (buildHash) hash.update(buildHash);
+	}
+
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context

package/lib/dependencies/ImportContextDependency.js

@@ -10,8 +10,8 @@ const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
 
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range]>} ObjectSerializerContext */
 /** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
 class ImportContextDependency extends ContextDependency {
@@ -55,9 +55,7 @@ class ImportContextDependency extends ContextDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.valueRange);
+		context.write(this.valueRange);
 
 		super.serialize(context);
 	}
@@ -67,11 +65,9 @@ class ImportContextDependency extends ContextDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.valueRange = read();
+		this.valueRange = context.read();
 
-		super.deserialize(context);
+		super.deserialize(context.rest);
 	}
 }
 

package/lib/dependencies/ImportDependency.js

@@ -7,11 +7,13 @@
 
 const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
 const { ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
@@ -23,8 +25,11 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./HarmonyImportGuard").DependencyGuard} DependencyGuard */
 /** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
+const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
+
 class ImportDependency extends ModuleDependency {
 	/**
 	 * Creates an instance of ImportDependency.
@@ -37,9 +42,14 @@ class ImportDependency extends ModuleDependency {
 	constructor(request, range, referencedExports, phase, attributes) {
 		super(request);
 		this.range = range;
+		/** @type {RawReferencedExports | null} */
 		this.referencedExports = referencedExports;
+		/** @type {ImportPhaseType} */
 		this.phase = phase;
+		/** @type {ImportAttributes | undefined} */
 		this.attributes = attributes;
+		/** @type {DependencyGuard[] | undefined} */
+		this.branchGuards = undefined;
 	}
 
 	get type() {
@@ -50,6 +60,18 @@ class ImportDependency extends ModuleDependency {
 		return "esm";
 	}
 
+	/**
+	 * Returns function to determine if the connection is active.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		const guards = this.branchGuards;
+		if (guards === undefined) return null;
+		return (connection, runtime) =>
+			!getHarmonyImportGuard().isDeadByGuards(guards, moduleGraph, runtime);
+	}
+
 	/**
 	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests
@@ -98,7 +120,8 @@ class ImportDependency extends ModuleDependency {
 			}
 			refs.push({
 				name: referencedExport,
-				canMangle: false
+				canMangle: false,
+				canInline: false
 			});
 		}
 		return refs;
@@ -113,6 +136,7 @@ class ImportDependency extends ModuleDependency {
 		context.write(this.referencedExports);
 		context.write(this.phase);
 		context.write(this.attributes);
+		context.write(this.branchGuards);
 		super.serialize(context);
 	}
 
@@ -125,6 +149,7 @@ class ImportDependency extends ModuleDependency {
 		this.referencedExports = context.read();
 		this.phase = context.read();
 		this.attributes = context.read();
+		this.branchGuards = context.read();
 		super.deserialize(context);
 	}
 }
@@ -144,9 +169,26 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 	apply(
 		dependency,
 		source,
-		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+		{
+			runtimeTemplate,
+			module,
+			moduleGraph,
+			chunkGraph,
+			runtimeRequirements,
+			runtime
+		}
 	) {
 		const dep = /** @type {ImportDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		// Dead branch: module is excluded and has no id; code is never executed.
+		if (connection && !connection.isTargetActive(runtime)) {
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				"Promise.resolve(/* dead branch */)"
+			);
+			return;
+		}
 		const block = /** @type {AsyncDependenciesBlock} */ (
 			moduleGraph.getParentBlock(dep)
 		);

package/lib/dependencies/ImportMetaHotAcceptDependency.js

@@ -20,6 +20,7 @@ class ImportMetaHotAcceptDependency extends ModuleDependency {
 	constructor(request, range) {
 		super(request);
 		this.range = range;
+		/** @type {boolean} */
 		this.weak = true;
 	}
 

package/lib/dependencies/ImportMetaHotDeclineDependency.js

@@ -21,6 +21,7 @@ class ImportMetaHotDeclineDependency extends ModuleDependency {
 		super(request);
 
 		this.range = range;
+		/** @type {boolean} */
 		this.weak = true;
 	}