webpack 5.110.1 → 5.110.2

package/lib/html/syntax.js

@@ -12,7 +12,7 @@ const {
 } = require("../ModuleSourceTypeConstants");
 const GenericSourceProcessor = require("../util/SourceProcessor");
 
-const { deferredWrite } = GenericSourceProcessor;
+const { deferredWrite, declineDeferredWrites } = GenericSourceProcessor;
 
 /** @import { CssEnvironment, CssProcessOptions, CssTransformOptions } from "../css/syntax" */
 /** @import { OutputHtmlOptions } from "../../declarations/WebpackOptions" */
@@ -11508,11 +11508,19 @@ const _settleFosteredRuns = (path) => {
 	_fosterHolders = holders;
 };
 
+// Stands in for what the print chooses the bytes of: a raw-text body it
+// rewrites whole, or an attribute value it respells.
+const _DIGEST_OPAQUE = "\u0003";
+
 /**
  * The tree as a string, for the one check the printer cannot make from the tree
- * alone: whether what it printed parses back to what it printed from. Values are
- * compared as the DOM holds them, so the same attribute written with a different
- * quote or escape is the same attribute.
+ * alone: whether what it printed parses back to what it printed from. Read in
+ * the form the print is licensed to leave — comments gone, a run of text
+ * collapsed and joined, the elements and attributes the options drop dropped,
+ * every value the printer respells standing in for itself — so an equal digest
+ * says the print moved nothing, not that it changed nothing. What a repair does
+ * move (a node under another parent, an attribute a bad quote swallowed)
+ * reshapes the tree, and that is what parts the two.
  * @param {HtmlNodeRef} root the node whose children are read
  * @returns {string} a rendering equal for equal trees
  */
@@ -11525,6 +11533,15 @@ const _digest = (root) => {
 	const stack = [];
 	const first = A.firstChild(root);
 	if (first !== 0) stack.push(first, 0);
+	// A run of text siblings reads as one string: dropping the comment or the
+	// empty element between two of them is what joins them in the output.
+	let pendingText = "";
+	let pendingDepth = 0;
+	const flushText = () => {
+		const text = _asciiTrim(pendingText);
+		pendingText = "";
+		if (text !== "") out.push(`${pendingDepth}\u0001t\u0001${text}`);
+	};
 	while (stack.length !== 0) {
 		const depth = /** @type {number} */ (stack.pop());
 		const node = /** @type {HtmlNodeRef} */ (stack.pop());
@@ -11532,27 +11549,87 @@ const _digest = (root) => {
 		const next = A.nextSibling(node);
 		if (next !== 0) stack.push(next, depth);
 		const type = A.type(node);
-		if (type !== NodeType.Element) {
-			out.push(`${depth}\u0001${type}\u0001${A.data(node)}`);
+		// Not flushed: a comment minifying drops leaves the text around it one run.
+		if (type === NodeType.Comment) continue;
+		if (type === NodeType.Text) {
+			if (depth !== pendingDepth) flushText();
+			pendingDepth = depth;
+			const parent = A.parentOf(node);
+			pendingText +=
+				parent !== 0 && LITERAL_TEXT_PARENTS.has(A.tagName(parent))
+					? _DIGEST_OPAQUE
+					: collapseWhitespaceRuns(A.data(node));
 			continue;
 		}
-		out.push(
-			`${depth}\u0001e\u0001${A.namespace(node)}\u0001${A.tagName(node)}`
-		);
-		const attributes = [];
-		for (const a of A.attributes(node)) {
-			// The value as the DOM holds it: the same value can be written with a
-			// different quote and a different escape and still be the same attribute.
-			attributes.push(
-				`${a.serializedName || a.name}=${decodeEntities(a.value, true)}`
-			);
+		if (type === NodeType.Element) {
+			// Same as a comment: an element the print drops joins what surrounds it.
+			if (
+				_isRemovableEmptyElement(A, node) ||
+				(_absorbedStyles !== null && _absorbedStyles.has(node))
+			) {
+				continue;
+			}
+			flushText();
+			const elementName = A.tagName(node);
+			const html = A.namespace(node) === NS_HTML;
+			out.push(`${depth}\u0001e\u0001${A.namespace(node)}\u0001${elementName}`);
+			// Per element, as in `_minifyOpenTag`: every attribute of one tag gets the
+			// same answer out of these tables.
+			const markers =
+				html && _removeRedundantAttributes !== "none"
+					? REDUNDANT_TYPE_ATTRIBUTES[elementName]
+					: undefined;
+			const defaults =
+				html && _removeRedundantAttributes === "all"
+					? REDUNDANT_DEFAULT_ATTRIBUTES[elementName]
+					: undefined;
+			const attributes = [];
+			for (const a of A.attributes(node)) {
+				if (
+					html &&
+					(((markers !== undefined || defaults !== undefined) &&
+						_isRedundantAttribute(
+							markers,
+							defaults,
+							elementName,
+							a.name,
+							a.value
+						)) ||
+						_isRemovableEmptyAttribute(elementName, a.name, a.value))
+				) {
+					continue;
+				}
+				const name = a.serializedName || a.name;
+				if (REWRITABLE_ATTRIBUTES.has(a.name) || a.name === "srcdoc") {
+					attributes.push(`${name}=${_DIGEST_OPAQUE}`);
+					continue;
+				}
+				// The value as the DOM holds it — the same value can be written with a
+				// different quote and a different escape and still be the same
+				// attribute — with a boolean spelled by its own name as the bare
+				// presence the printer writes it back as.
+				attributes.push(
+					`${name}=${
+						html &&
+						a.value.length === a.name.length &&
+						_isBooleanAttribute(elementName, a.name) &&
+						_asciiLowerCase(a.value) === a.name
+							? ""
+							: decodeEntities(a.value, true)
+					}`
+				);
+			}
+			attributes.sort();
+			out.push(attributes.join("\u0002"));
+			const content = A.templateContent(node);
+			const inner = content !== 0 ? A.firstChild(content) : A.firstChild(node);
+			if (inner !== 0) stack.push(inner, depth + 1);
+			continue;
 		}
-		attributes.sort();
-		out.push(attributes.join("\u0002"));
-		const content = A.templateContent(node);
-		const inner = content !== 0 ? A.firstChild(content) : A.firstChild(node);
-		if (inner !== 0) stack.push(inner, depth + 1);
+		flushText();
+		out.push(`${depth}\u0001${type}\u0001${A.data(node)}`);
 	}
+	flushText();
 	return out.join("\n");
 };
 
@@ -12549,12 +12626,11 @@ const grammar = (input, visitors, writer, options) => {
 	_printDepth = 0;
 	try {
 		const root = parseHtml(input, 0, options);
-		let digest = "";
 		if (writer !== undefined) {
 			if (_fosteredLog !== null) _settleFosteredRuns(A);
 			// A shape no arrangement of tags reaches, or foster parenting — whose repair
 			// is checked, not trusted. No real document reaches either.
-			if (_printFromSource || _fosteredLog !== null) digest = _digest(root);
+			const verify = _printFromSource || _fosteredLog !== null;
 			_walkRun(_nodeParents[root], root, _nodeNextSiblings[root]);
 			// A single root: take its text as the output (the printer read every node's
 			// source into the store during the walk, so this needs no source). A root
@@ -12562,9 +12638,20 @@ const grammar = (input, visitors, writer, options) => {
 			if (_printOpen[0] === 1) writer.dropStore();
 			else writer.take(root);
 			// Print, then read the output back: the source always parses to its own
-			// tree, so it stands in when the printed form does not.
-			if (digest !== "") {
-				const printed = writer.result();
+			// tree, so it stands in when the printed form does not. Digested after the
+			// walk, which is what settles the elements the print left out.
+			if (verify) {
+				const digest = _digest(root);
+				// A deferred body prints as a marker, which reads back as text where
+				// its node stood — put it back, or the whole document is handed back.
+				const printed =
+					_deferEmbeddedSource === undefined ||
+					_deferEmbeddedSource.length === 0
+						? writer.result()
+						: declineDeferredWrites(writer.result(), _deferEmbeddedSource);
+				// Both are keyed by node id, which the next parse hands out afresh.
+				_emptyElements.clear();
+				_absorbedStyles = null;
 				if (_digest(parseHtml(printed, 0, options)) !== digest) {
 					writer.replaceAll(input);
 				}

package/lib/javascript/JavascriptModulesPlugin.js

@@ -50,7 +50,7 @@ const {
 const createHash = require("../util/createHash");
 const createHooksRegistry = require("../util/createHooksRegistry");
 const { digestNonNumericOnlyWithFull } = require("../util/nonNumericOnlyHash");
-const removeBOM = require("../util/removeBOM");
+const { removeBOMFromResult } = require("../util/removeBOM");
 const { intersectRuntime } = require("../util/runtime");
 const { getAllChunks } = require("./ChunkHelpers");
 const JavascriptGenerator = require("./JavascriptGenerator");
@@ -528,15 +528,8 @@ class JavascriptModulesPlugin {
 
 					NormalModule.getCompilationHooks(compilation).processResult.tap(
 						PLUGIN_NAME,
-						(result, module) => {
-							if (module.type === type) {
-								const [source, ...rest] = result;
-
-								return [removeBOM(source), ...rest];
-							}
-
-							return result;
-						}
+						(result, module) =>
+							module.type === type ? removeBOMFromResult(result) : result
 					);
 				}
 

package/lib/loaders/LoaderRunner.js

@@ -7,6 +7,7 @@
 
 const { readFile } = require("fs");
 const { parseResource } = require("../util/identifier");
+const { adjustSourceMapForRemovedBOM } = require("../util/removeBOM");
 const loadLoader = require("./loadLoader");
 
 // Set on a loader context to have each loader's own run measured. Absent
@@ -59,6 +60,8 @@ const HASH_ESCAPE_REGEXP = /#/g;
 const UTF8_BOM_0 = 0xef;
 const UTF8_BOM_1 = 0xbb;
 const UTF8_BOM_2 = 0xbf;
+// U+FEFF, the BOM once decoded
+const BOM_CHAR_CODE = 0xfeff;
 
 /**
  * @param {Buffer} buf buffer
@@ -76,6 +79,14 @@ function utf8BufferToString(buf) {
 	return buf.toString("utf8");
 }
 
+/**
+ * @param {string} str string
+ * @returns {string} string, with a leading BOM removed
+ */
+function stringWithoutBOM(str) {
+	return str.charCodeAt(0) === BOM_CHAR_CODE ? str.slice(1) : str;
+}
+
 /**
  * Escape `#` with a preceding `\0` byte; short-circuits when there is no `#`.
  * @param {string} str input string
@@ -292,9 +303,19 @@ function runSyncOrAsync(fn, context, args, callback) {
 /**
  * @param {EXPECTED_ANY[]} args arguments
  * @param {boolean | null=} raw whether the loader wants a Buffer
+ * @param {boolean=} fromLoader whether args came from a loader rather than the resource
  * @returns {void}
  */
-function convertArgs(args, raw) {
+function convertArgs(args, raw, fromLoader) {
+	// A BOM only means anything at the start of a file, so one a loader produced
+	// is content the next loader must not see. The resource keeps its own.
+	if (fromLoader && typeof args[0] === "string") {
+		const withoutBOM = stringWithoutBOM(args[0]);
+		if (withoutBOM !== args[0]) {
+			args[0] = withoutBOM;
+			if (args[1]) args[1] = adjustSourceMapForRemovedBOM(args[1]);
+		}
+	}
 	if (!raw && Buffer.isBuffer(args[0])) {
 		args[0] = utf8BufferToString(args[0]);
 	} else if (raw && typeof args[0] === "string") {
@@ -307,9 +328,16 @@ function convertArgs(args, raw) {
  * @param {LoaderContext} loaderContext the loader context
  * @param {EXPECTED_ANY[]} args arguments
  * @param {(err: Error | null, args?: EXPECTED_ANY[]) => void} callback callback
+ * @param {boolean=} fromLoader whether args came from a loader rather than the resource
  * @returns {void}
  */
-function iterateNormalLoaders(options, loaderContext, args, callback) {
+function iterateNormalLoaders(
+	options,
+	loaderContext,
+	args,
+	callback,
+	fromLoader
+) {
 	while (loaderContext.loaderIndex >= 0) {
 		const currentLoaderObject =
 			loaderContext.loaders[loaderContext.loaderIndex];
@@ -327,11 +355,11 @@ function iterateNormalLoaders(options, loaderContext, args, callback) {
 			continue;
 		}
 
-		convertArgs(args, currentLoaderObject.raw);
+		convertArgs(args, currentLoaderObject.raw, fromLoader);
 
 		return runSyncOrAsync(fn, loaderContext, args, (err, ...nextArgs) => {
 			if (err) return callback(err);
-			iterateNormalLoaders(options, loaderContext, nextArgs, callback);
+			iterateNormalLoaders(options, loaderContext, nextArgs, callback, true);
 		});
 	}
 
@@ -410,7 +438,7 @@ function iteratePitchingLoaders(options, loaderContext, callback) {
 					}
 					if (hasArg) {
 						loaderContext.loaderIndex--;
-						iterateNormalLoaders(options, loaderContext, args, callback);
+						iterateNormalLoaders(options, loaderContext, args, callback, true);
 					} else {
 						iteratePitchingLoaders(options, loaderContext, callback);
 					}

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -62,27 +62,20 @@ class ReadFileCompileAsyncWasmPlugin {
 			// settled while the plugin is being applied.
 			/**
 			 * @param {string} path rendered path to the wasm file
-			 * @param {RuntimeSpec} runtime the runtime this loader serves
+			 * @param {boolean} analyzable whether the call site bakes a complete URL
 			 * @returns {string} the argument to hand the reader
 			 */
-			const wasmUrlArg = (path, runtime) =>
-				compilation.runtimeTemplate.supportsAnalyzable(
-					"wasm",
-					undefined,
-					undefined,
-					runtime
-				)
-					? path
-					: compilation.runtimeTemplate.importMetaUrl(path);
+			const wasmUrlArg = (path, analyzable) =>
+				analyzable ? path : compilation.runtimeTemplate.importMetaUrl(path);
 			/**
-			 * @type {(path: string, runtime: RuntimeSpec) => string} callback to generate code to load the wasm file
+			 * @type {(path: string, runtime: RuntimeSpec, analyzable: boolean) => string} callback to generate code to load the wasm file
 			 */
 			const generateLoadBinaryCode = this._import
-				? (path, runtime) =>
+				? (path, runtime, analyzable) =>
 						Template.asString([
 							"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 							Template.indent([
-								`readFile(${wasmUrlArg(path, runtime)}, (err, buffer) => {`,
+								`readFile(${wasmUrlArg(path, analyzable)}, (err, buffer) => {`,
 								Template.indent([
 									"if (err) return reject(err);",
 									"",
@@ -154,7 +147,7 @@ class ReadFileCompileAsyncWasmPlugin {
 					if (
 						!compilation.runtimeTemplate.supportsAnalyzable(
 							"wasm",
-							undefined,
+							chunkGraph,
 							undefined,
 							chunk.runtime
 						) &&
@@ -196,7 +189,7 @@ class ReadFileCompileAsyncWasmPlugin {
 					if (
 						!compilation.runtimeTemplate.supportsAnalyzable(
 							"wasm",
-							undefined,
+							chunkGraph,
 							undefined,
 							chunk.runtime
 						) &&

package/lib/optimize/ConcatenatedModule.js

@@ -1415,10 +1415,18 @@ class ConcatenatedModule extends Module {
 					runtimeCondition,
 					runtime
 				);
+				const wasDeferredOnly = !entry.nonDeferAccess;
 				entry.nonDeferAccess = mergeNonDeferAccess(
 					entry.nonDeferAccess,
 					nonDeferAccess
 				);
+				// A deferred import does not evaluate, so the first eager reference
+				// fixes the position; insertion order is emit order.
+				if (wasDeferredOnly && nonDeferAccess) {
+					entry.connection = connection;
+					referencesMap.delete(module);
+					referencesMap.set(module, entry);
+				}
 			}
 			if (targets !== undefined) importConnections.set(module, targets);
 			return referencesMap.values();

package/lib/optimize/ConstExportsPlugin.js

@@ -15,6 +15,7 @@ const { VariableInfoFlags } = require("../javascript/JavascriptParser");
 const {
 	InlinedUsedName,
 	enableInlineExports,
+	findModulesInCycles,
 	toInlinedValue
 } = require("./InlineExports");
 
@@ -162,11 +163,15 @@ class ConstExportsPlugin {
 
 				const moduleGraph = compilation.moduleGraph;
 				compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, (modules) => {
+					// A cycle peer may read an export during its temporal dead zone,
+					// where the binding must throw and a literal would answer.
+					const inCycle = findModulesInCycles(moduleGraph, modules);
 					/** @type {Set<ExportsInfo>} */
 					const visited = new Set();
 					/** @type {ExportsInfo[]} */
 					let queue = [];
 					for (const module of modules) {
+						if (inCycle.has(module)) continue;
 						queue.push(moduleGraph.getExportsInfo(module));
 					}
 					while (queue.length > 0) {

package/lib/optimize/InlineExports.js

@@ -172,10 +172,131 @@ const isExportInlined = (moduleGraph, module, ids, runtime) => {
 	return moduleGraph.getExportsInfo(module).hasInlinedUsedName(ids, runtime);
 };
 
+/**
+ * Collects, by an iterative Tarjan pass, the modules a cycle peer may read in
+ * their dead zone. A cycle of bare side-effect imports still inlines.
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {Iterable<Module>} modules all modules of the compilation
+ * @returns {Set<Module>} modules whose exports must not be inlined
+ */
+const findModulesInCycles = (moduleGraph, modules) => {
+	const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+	const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
+
+	/** @type {Set<Module>} */
+	const inCycle = new Set();
+	/** @type {[Module, Module][]} */
+	const bindingReads = [];
+	/** @type {Map<Module, number>} */
+	const componentOf = new Map();
+	let nextComponent = 0;
+	/** @type {Map<Module, number>} */
+	const index = new Map();
+	/** @type {Map<Module, number>} */
+	const low = new Map();
+	/** @type {Set<Module>} */
+	const onStack = new Set();
+	/** @type {Module[]} */
+	const componentStack = [];
+	let counter = 0;
+	/**
+	 * @param {Module} module the module
+	 * @returns {Module[]} modules it imports, self included when self-importing
+	 */
+	const targetsOf = (module) => {
+		const connections = moduleGraph.getOutgoingConnectionsByModule(module);
+		if (!connections) return [];
+		/** @type {Module[]} */
+		const targets = [];
+		for (const [target, moduleConnections] of connections) {
+			if (
+				!target ||
+				!moduleConnections.some(
+					(c) => c.dependency instanceof HarmonyImportDependency
+				)
+			) {
+				continue;
+			}
+			// Anything but a bare side-effect import may observe the binding.
+			if (
+				moduleConnections.some(
+					(c) =>
+						c.dependency instanceof HarmonyImportDependency &&
+						!(c.dependency instanceof HarmonyImportSideEffectDependency)
+				)
+			) {
+				bindingReads.push([module, target]);
+			}
+			targets.push(target);
+		}
+		return targets;
+	};
+	/** @type {{ node: Module, targets: Module[], i: number }[]} */
+	const work = [];
+	/**
+	 * @param {Module} node node to open
+	 */
+	const open = (node) => {
+		index.set(node, counter);
+		low.set(node, counter);
+		counter++;
+		componentStack.push(node);
+		onStack.add(node);
+		work.push({ node, targets: targetsOf(node), i: 0 });
+	};
+	for (const seed of modules) {
+		if (index.has(seed)) continue;
+		open(seed);
+		while (work.length > 0) {
+			const frame = work[work.length - 1];
+			if (frame.i < frame.targets.length) {
+				const next = frame.targets[frame.i++];
+				if (!index.has(next)) {
+					open(next);
+				} else if (onStack.has(next)) {
+					const nodeLow = /** @type {number} */ (low.get(frame.node));
+					const nextIndex = /** @type {number} */ (index.get(next));
+					if (nextIndex < nodeLow) low.set(frame.node, nextIndex);
+				}
+				continue;
+			}
+			work.pop();
+			const node = frame.node;
+			const nodeLow = /** @type {number} */ (low.get(node));
+			if (work.length > 0) {
+				const parent = work[work.length - 1].node;
+				if (nodeLow < /** @type {number} */ (low.get(parent))) {
+					low.set(parent, nodeLow);
+				}
+			}
+			if (nodeLow === index.get(node)) {
+				const id = nextComponent++;
+				let member;
+				do {
+					member = /** @type {Module} */ (componentStack.pop());
+					onStack.delete(member);
+					componentOf.set(member, id);
+				} while (member !== node);
+			}
+		}
+	}
+	// Reader and target evaluate together exactly when they share a component.
+	for (const [origin, target] of bindingReads) {
+		if (
+			origin === target ||
+			componentOf.get(origin) === componentOf.get(target)
+		) {
+			inCycle.add(target);
+		}
+	}
+	return inCycle;
+};
+
 module.exports.InlinedUsedName = InlinedUsedName;
 module.exports.InlinedValue = InlinedValue;
 module.exports.MAX_INLINE_BYTES = MAX_INLINE_BYTES;
 module.exports.enableInlineExports = enableInlineExports;
+module.exports.findModulesInCycles = findModulesInCycles;
 module.exports.isExportInlined = isExportInlined;
 module.exports.isInlineEnabled = isInlineEnabled;
 module.exports.isInlineExportsEnabled = isInlineExportsEnabled;