webpack 5.110.1 → 5.110.2

package/lib/optimize/RealContentHashPlugin.js

@@ -345,47 +345,68 @@ ${referencingAssets
 						}
 						return hashes;
 					};
+					// Tarjan: hashes naming each other come out as one group where a chain
+					// walk would never end, and groups arrive dependencies-first as needed.
+					/** @type {string[][]} */
+					const groupsInOrder = [];
+					/** @type {Map<string, number>} */
+					const indexOf = new Map();
+					/** @type {Map<string, number>} */
+					const lowOf = new Map();
+					/** @type {Set<string>} */
+					const onStack = new Set();
+					/** @type {string[]} */
+					const stack = [];
 					/**
-					 * Returns the hash info.
+					 * Visits one hash and everything its assets reference.
 					 * @param {string} hash the hash
-					 * @returns {string} the hash info
+					 * @returns {void}
 					 */
-					const hashInfo = (hash) => {
-						const assets = hashToAssets.get(hash);
-						return `${hash} (${Array.from(
-							/** @type {AssetInfoForRealContentHash[]} */ (assets),
-							(a) => a.name
-						)})`;
-					};
-					/** @type {Hashes} */
-					const hashesInOrder = new Set();
-					for (const hash of hashToAssets.keys()) {
-						/**
-						 * Processes the provided hash.
-						 * @param {string} hash the hash
-						 * @param {Set<string>} stack stack of hashes
-						 */
-						const add = (hash, stack) => {
-							const deps = getDependencies(hash);
-							if (!deps) return;
-							stack.add(hash);
+					const strongConnect = (hash) => {
+						const index = indexOf.size;
+						indexOf.set(hash, index);
+						lowOf.set(hash, index);
+						stack.push(hash);
+						onStack.add(hash);
+						// An unowned reference reports the caching problem and stays a leaf.
+						const deps = getDependencies(hash);
+						if (deps) {
 							for (const dep of deps) {
-								if (hashesInOrder.has(dep)) continue;
-								if (stack.has(dep)) {
-									throw new Error(
-										`Circular hash dependency ${Array.from(
-											stack,
-											hashInfo
-										).join(" -> ")} -> ${hashInfo(dep)}`
+								if (!indexOf.has(dep)) {
+									strongConnect(dep);
+									lowOf.set(
+										hash,
+										Math.min(
+											/** @type {number} */ (lowOf.get(hash)),
+											/** @type {number} */ (lowOf.get(dep))
+										)
+									);
+								} else if (onStack.has(dep)) {
+									lowOf.set(
+										hash,
+										Math.min(
+											/** @type {number} */ (lowOf.get(hash)),
+											/** @type {number} */ (indexOf.get(dep))
+										)
 									);
 								}
-								add(dep, stack);
 							}
-							hashesInOrder.add(hash);
-							stack.delete(hash);
-						};
-						if (hashesInOrder.has(hash)) continue;
-						add(hash, new Set());
+						}
+						if (lowOf.get(hash) === indexOf.get(hash)) {
+							/** @type {string[]} */
+							const group = [];
+							/** @type {string} */
+							let member;
+							do {
+								member = /** @type {string} */ (stack.pop());
+								onStack.delete(member);
+								if (hashToAssets.has(member)) group.push(member);
+							} while (member !== hash);
+							if (group.length > 0) groupsInOrder.push(group);
+						}
+					};
+					for (const hash of hashToAssets.keys()) {
+						if (!indexOf.has(hash)) strongConnect(hash);
 					}
 					/** @type {Map<string, string>} */
 					const hashToNewHash = new Map();
@@ -474,7 +495,62 @@ ${referencingAssets
 					};
 					/** @type {Comparator<AssetInfoForRealContentHash>} */
 					const comparator = compareSelect((a) => a.name, compareStrings);
-					for (const oldHash of hashesInOrder) {
+					for (const group of groupsInOrder) {
+						// A cycle is assigned as one group: members are told apart by stable
+						// markers, so the group hashes to a fixed point instead of chasing one.
+						if (group.length > 1) {
+							const members = group.sort();
+							/** @type {Map<string, string>} */
+							const markerOf = new Map(
+								members.map((hash, i) => [hash, `|webpack/scc/${i}|`])
+							);
+							for (let i = 0; i < members.length; i++) {
+								const oldHash = members[i];
+								const memberAssets =
+									/** @type {AssetInfoForRealContentHash[]} */
+									(hashToAssets.get(oldHash));
+								memberAssets.sort(comparator);
+								const hash = createHash(this._hashFunction);
+								if (compilation.outputOptions.hashSalt) {
+									hash.update(compilation.outputOptions.hashSalt);
+								}
+								// Two members can normalize to the same text; the position keeps
+								// their hashes apart, and sorting keeps the position stable.
+								hash.update(`${i}`);
+								for (const asset of memberAssets) {
+									if (Buffer.isBuffer(asset.content)) {
+										hash.update(asset.content);
+										continue;
+									}
+									const withoutOwn =
+										/** @type {Hashes} */
+										(asset.ownHashes).has(oldHash);
+									hash.update(
+										asset.content.replace(hashRegExp, (matched) => {
+											// Its own occurrences vanish, exactly as a lone hash's do.
+											if (
+												withoutOwn &&
+												/** @type {Hashes} */ (asset.ownHashes).has(matched)
+											) {
+												return "";
+											}
+											const marker = markerOf.get(matched);
+											if (marker !== undefined) return marker;
+											const mapped = hashToNewHash.get(matched);
+											return mapped === undefined ? matched : mapped;
+										})
+									);
+								}
+								const digest = hash.digest(
+									/** @type {HashDigest} */ (
+										hashToDigest.get(oldHash) || this._hashDigest
+									)
+								);
+								hashToNewHash.set(oldHash, digest.slice(0, oldHash.length));
+							}
+							continue;
+						}
+						const oldHash = group[0];
 						const assets =
 							/** @type {AssetInfoForRealContentHash[]} */
 							(hashToAssets.get(oldHash));

package/lib/prefetch/ResourceHintPlugin.js

@@ -481,19 +481,13 @@ const collectStartupAssetHintLines = (
 				seenWorkerChunks.add(workerChunk.id);
 				// The same specifier the `new Worker(...)` call site bakes, asked of the
 				// same module, so the two agree on whether a literal is spellable.
-				const specifier = runtimeTemplate.supportsAnalyzable(
-					"url",
+				const specifier = runtimeTemplate.getAnalyzableWorkerUrl(
+					dep.options.publicPath,
+					workerChunk,
+					module,
 					chunkGraph,
-					module
-				)
-					? runtimeTemplate._getAnalyzableChunkSpecifier(
-							dep.options.publicPath,
-							workerChunk,
-							module,
-							chunkGraph,
-							set
-						)
-					: null;
+					set
+				);
 				// Without one the call site keeps the runtime form, where it wraps its own
 				// href — firing the `<link>` here too would emit the call twice.
 				if (specifier === null) continue;

package/lib/typescript/TypeScriptPlugin.js

@@ -14,7 +14,7 @@ const {
 } = require("../ModuleTypeConstants");
 const NormalModule = require("../NormalModule");
 const memoize = require("../util/memoize");
-const removeBOM = require("../util/removeBOM");
+const { removeBOMFromResult } = require("../util/removeBOM");
 
 const getModuleBuildError = memoize(() =>
 	require("../errors/ModuleBuildError")
@@ -133,15 +133,11 @@ const stripTypes = (input) => {
 };
 
 /**
- * Coerce a Buffer-or-string source to a UTF-8 string, dropping any BOM.
  * @param {string | Buffer} source raw source from the loader pipeline
- * @returns {string} UTF-8 string without BOM
+ * @returns {string} UTF-8 string
  */
-const toBomFreeString = (source) => {
-	const text = Buffer.isBuffer(source) ? source.toString("utf8") : source;
-	const stripped = removeBOM(text);
-	return typeof stripped === "string" ? stripped : stripped.toString("utf8");
-};
+const asString = (source) =>
+	Buffer.isBuffer(source) ? source.toString("utf8") : source;
 
 class TypeScriptPlugin {
 	/**
@@ -181,8 +177,10 @@ class TypeScriptPlugin {
 			throw new (getModuleBuildError())(new Error(NODE_API_MISSING));
 		}
 
-		const [rawSource, loaderSourceMap, ...rest] = result;
-		const preStripSource = toBomFreeString(rawSource);
+		// A BOM must be off the source before it is stripped of types, and its
+		// map moved with it.
+		const [rawSource, loaderSourceMap, ...rest] = removeBOMFromResult(result);
+		const preStripSource = asString(rawSource);
 		const strippedSource = stripTypes(preStripSource);
 
 		const needSourceMap = module.useSourceMap || module.useSimpleSourceMap;

package/lib/util/SourceProcessor.js

@@ -99,6 +99,23 @@ const expandDeferredWrites = (text, resolve, infix) => {
 	return out + text.slice(from);
 };
 
+/**
+ * The text this print spells with every deferred write declined: each marker
+ * replaced by what would stand there had no renderer answered. What a print
+ * verifying itself by re-parsing has to read, since a marker otherwise parses
+ * as text where its node stood. `build` rather than `source` so a write inside
+ * an attribute comes back escaped for where it sits.
+ * @param {string} text the printed output, holding this print's markers
+ * @param {DeferredWrite[]} writes what the print deferred, indexed by id
+ * @returns {string} the text with every marker put back
+ */
+const declineDeferredWrites = (text, writes) =>
+	expandDeferredWrites(
+		text,
+		(id) => (id < writes.length ? writes[id].build(undefined) : undefined),
+		deferredInfix
+	);
+
 /**
  * Babel-style visitor map keyed by a numeric node-type discriminator; a bucket
  * is a function (enter-only) or `{ enter?, exit? }`.
@@ -389,16 +406,14 @@ class PrintContext {
 	_growStore(need) {
 		// From empty: a context that prints one inline `style=""` must not pay for
 		// a stylesheet's worth of columns.
-		const size = Math.max(need, this._storeText.length * 2, 16);
-		// Appended, which keeps the column packed for the read every composed child
-		// makes, and carries what it already holds across in the same pass.
-		const held = this._storeText;
-		const text = [];
-		for (let i = 0; i < held.length; i++) text.push(held[i]);
-		for (let i = held.length; i < size; i++) text.push("");
+		const text = this._storeText;
+		const size = Math.max(need, text.length * 2, 16);
+		// Appended in place: `push` keeps the column packed for the read every
+		// composed child makes, and what it already holds never moves — where
+		// filling a second array would copy every slot again at each growth.
+		for (let i = text.length; i < size; i++) text.push("");
 		const gen = new Int32Array(size);
 		gen.set(this._storeGen);
-		this._storeText = text;
 		this._storeGen = gen;
 	}
 
@@ -1142,4 +1157,5 @@ class SourceProcessor {
 SourceProcessor.PrintContext = PrintContext;
 
 module.exports = SourceProcessor;
+module.exports.declineDeferredWrites = declineDeferredWrites;
 module.exports.deferredWrite = deferredWrite;

package/lib/util/createMappings.js

@@ -13,9 +13,9 @@
  * while richer call sites can pass arrays of segments.
  *
  * TODO move this encoder into `webpack-sources` and replace the body of this
- * file with re-exports. The public shape (`encodeVLQ`, `encodeMappings(lines)`,
- * `MappingSegment`, `LineMappings`) is intended to match what would land
- * upstream so call sites don't have to change.
+ * file with re-exports. The public shape (`encodeVLQ`, `decodeVLQ`,
+ * `encodeMappings(lines)`, `MappingSegment`, `LineMappings`) is intended to
+ * match what would land upstream so call sites don't have to change.
  */
 
 const VLQ_BASE64 =
@@ -38,6 +38,27 @@ const encodeVLQ = (value) => {
 	return result;
 };
 
+/**
+ * Decode one base64 VLQ value per the source-map V3 spec.
+ * @param {string} mappings a VLQ encoded `mappings` string
+ * @param {number} start index of the value's first character
+ * @returns {{ value: number, end: number }} the decoded value and the index just past it; `end` equals `start` when there is no valid value at `start`
+ */
+const decodeVLQ = (mappings, start) => {
+	let value = 0;
+	let shift = 0;
+	let index = start;
+	let digit;
+	do {
+		digit = index < mappings.length ? VLQ_BASE64.indexOf(mappings[index]) : -1;
+		if (digit < 0) return { value: 0, end: start };
+		value += (digit & 0x1f) << shift;
+		shift += 5;
+		index++;
+	} while (digit & 0x20);
+	return { value: value & 1 ? -(value >>> 1) : value >>> 1, end: index };
+};
+
 /**
  * @typedef {object} MappingSegment
  * @property {number=} generatedColumn 0-based generated column (defaults to 0)
@@ -114,5 +135,6 @@ const encodeMappings = (lines) => {
 	return encodedLines.join(";");
 };
 
+module.exports.decodeVLQ = decodeVLQ;
 module.exports.encodeMappings = encodeMappings;
 module.exports.encodeVLQ = encodeVLQ;

package/lib/util/removeBOM.js

@@ -5,12 +5,17 @@
 
 "use strict";
 
+const { decodeVLQ, encodeVLQ } = require("./createMappings");
+
+/** @import { RawSourceMap } from "webpack-sources" */
+/** @import { Result } from "../NormalModule" */
+
 /**
  * Returns result without BOM.
  * @param {string | Buffer} strOrBuffer string or buffer
  * @returns {string | Buffer} result without BOM
  */
-module.exports = (strOrBuffer) => {
+const removeBOM = (strOrBuffer) => {
 	if (typeof strOrBuffer === "string" && strOrBuffer.charCodeAt(0) === 0xfeff) {
 		return strOrBuffer.slice(1);
 	} else if (
@@ -24,3 +29,79 @@ module.exports = (strOrBuffer) => {
 
 	return strOrBuffer;
 };
+
+/**
+ * A BOM occupies generated column 0 of the first line, so a map describing
+ * BOM-prefixed content starts that line at column 1 or later. Removing the BOM
+ * moves the line one column left; the segments after the first are encoded
+ * relative to it, so only the first is rewritten. A map already starting at
+ * column 0 describes the content without its BOM and is left alone.
+ * @param {string} mappings VLQ encoded `mappings` of a map for BOM-prefixed content
+ * @returns {string} `mappings` for the same content without its BOM
+ */
+const shiftMappings = (mappings) => {
+	const { value, end } = decodeVLQ(mappings, 0);
+	if (end === 0 || value <= 0) return mappings;
+	return encodeVLQ(value - 1) + mappings.slice(end);
+};
+
+/**
+ * Adjust a source map that accompanied BOM-prefixed content for the removal of
+ * that BOM. Anything without VLQ `mappings` is passed through untouched, as is
+ * a map declaring a version other than 3 — earlier versions spell `mappings`
+ * differently. A map that declares no version at all is taken as version 3.
+ * @param {(string | RawSourceMap)=} sourceMap the map, as an object or as JSON
+ * @returns {(string | RawSourceMap)=} the adjusted map
+ */
+const adjustSourceMapForRemovedBOM = (sourceMap) => {
+	if (!sourceMap) return sourceMap;
+
+	if (typeof sourceMap === "string") {
+		/** @type {RawSourceMap} */
+		let parsed;
+		try {
+			parsed = JSON.parse(sourceMap);
+		} catch (_err) {
+			return sourceMap;
+		}
+		const adjusted = adjustSourceMapForRemovedBOM(parsed);
+		return adjusted === parsed ? sourceMap : JSON.stringify(adjusted);
+	}
+
+	if (sourceMap.version !== undefined && sourceMap.version !== 3) {
+		return sourceMap;
+	}
+
+	if (typeof sourceMap.mappings !== "string") return sourceMap;
+
+	const mappings = shiftMappings(sourceMap.mappings);
+
+	return mappings === sourceMap.mappings
+		? sourceMap
+		: { ...sourceMap, mappings };
+};
+
+/**
+ * @param {Result} result a loader result: content, an optional source map, extra info
+ * @returns {Result} the result with a leading BOM removed from its content and its source map kept in sync
+ */
+const removeBOMFromResult = (result) => {
+	const content = result[0];
+	const withoutBOM = removeBOM(content);
+
+	if (withoutBOM === content) return result;
+
+	// Copied rather than rebuilt, so a result carrying no source map keeps its
+	// arity.
+	const adjusted = /** @type {Result} */ ([...result]);
+
+	adjusted[0] = withoutBOM;
+
+	if (adjusted[1]) adjusted[1] = adjustSourceMapForRemovedBOM(adjusted[1]);
+
+	return adjusted;
+};
+
+module.exports.adjustSourceMapForRemovedBOM = adjustSourceMapForRemovedBOM;
+module.exports.removeBOM = removeBOM;
+module.exports.removeBOMFromResult = removeBOMFromResult;

package/lib/wasm-async/AsyncWasmCompileRuntimeModule.js

@@ -11,11 +11,12 @@ const Template = require("../Template");
 const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
 /** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
 /** @import Compilation from "../Compilation" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec, analyzable: boolean) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeCompileStreaming */
 
 /**
@@ -69,7 +70,7 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		// Analyzable output bakes the binary's URL into the call site instead.
 		const analyzable = runtimeTemplate.supportsAnalyzable(
 			"wasm",
-			undefined,
+			/** @type {ChunkGraph} */ (this.chunkGraph),
 			undefined,
 			chunk.runtime
 		);
@@ -92,7 +93,8 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 
 		const loader = this.generateLoadBinaryCode(
 			wasmModuleSrcPath,
-			chunk.runtime
+			chunk.runtime,
+			analyzable
 		);
 
 		// Fallback path: fetch -> arrayBuffer -> WebAssembly.compile

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -11,11 +11,12 @@ const Template = require("../Template");
 const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
 /** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
 /** @import Compilation from "../Compilation" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec, analyzable: boolean) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeInstantiateStreaming */
 
 /**
@@ -70,7 +71,7 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		// Analyzable output bakes the binary's URL into the call site instead.
 		const analyzable = runtimeTemplate.supportsAnalyzable(
 			"wasm",
-			undefined,
+			/** @type {ChunkGraph} */ (this.chunkGraph),
 			undefined,
 			chunk.runtime
 		);
@@ -93,7 +94,8 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 
 		const loader = this.generateLoadBinaryCode(
 			wasmModuleSrcPath,
-			chunk.runtime
+			chunk.runtime,
+			analyzable
 		);
 		const fallback = [
 			`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,

package/lib/wasm-async/UniversalCompileAsyncWasmPlugin.js

@@ -67,31 +67,26 @@ class UniversalCompileAsyncWasmPlugin {
 			// per call: it depends on parse results, so it is not settled while the plugin
 			// is being applied.
 			/**
-			 * @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 = (runtime) =>
-				compilation.runtimeTemplate.supportsAnalyzable(
-					"wasm",
-					undefined,
-					undefined,
-					runtime
-				)
+			const wasmUrlArg = (analyzable) =>
+				analyzable
 					? "wasmUrl"
 					: compilation.runtimeTemplate.importMetaUrl("wasmUrl");
 			/**
 			 * Generates the runtime expression that fetches the binary in browsers
 			 * or reads it from the filesystem in Node.js.
-			 * @type {(path: string, runtime: RuntimeSpec) => string}
+			 * @type {(path: string, runtime: RuntimeSpec, analyzable: boolean) => string}
 			 */
-			const generateLoadBinaryCode = (path, runtime) =>
+			const generateLoadBinaryCode = (path, runtime, analyzable) =>
 				Template.asString([
 					"(useFetch",
-					Template.indent([`? fetch(${wasmUrlArg(runtime)})`]),
+					Template.indent([`? fetch(${wasmUrlArg(analyzable)})`]),
 					Template.indent([
 						": Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 						Template.indent([
-							`readFile(${wasmUrlArg(runtime)}, (err, buffer) => {`,
+							`readFile(${wasmUrlArg(analyzable)}, (err, buffer) => {`,
 							Template.indent([
 								"if (err) return reject(err);",
 								"",

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -91,12 +91,14 @@ class FetchCompileAsyncWasmPlugin {
 					}
 					const baked = compilation.runtimeTemplate.supportsAnalyzable(
 						"wasm",
-						undefined,
+						chunkGraph,
 						undefined,
 						chunk.runtime
 					);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					// A baked URL carries the public path already, and a settled one is written
 					// out below; only a path nothing but the global knows asks for it.
 					const constant =
@@ -151,12 +153,14 @@ class FetchCompileAsyncWasmPlugin {
 					}
 					const baked = compilation.runtimeTemplate.supportsAnalyzable(
 						"wasm",
-						undefined,
+						chunkGraph,
 						undefined,
 						chunk.runtime
 					);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					// A baked URL carries the public path already, and a settled one is written
 					// out below; only a path nothing but the global knows asks for it.
 					const constant =

package/lib/web/FetchCompileWasmPlugin.js

@@ -99,8 +99,10 @@ class FetchCompileWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.moduleCache);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					const constant = analyzable
 						? undefined
 						: compilation.runtimeTemplate.constantPublicPath();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.110.1",
+  "version": "5.110.2",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "homepage": "https://github.com/webpack/webpack",
   "bugs": "https://github.com/webpack/webpack/issues",