webpack 5.110.0 → 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/serialization/ObjectMiddleware.js

@@ -461,7 +461,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 			return buf;
 		};
 		let currentPosTypeLookup = 0;
-		/** @type {Map<ComplexSerializableType, number>} */
+		/** @type {Map<SerializerConfigWithSerializer, number>} */
 		let objectTypeLookup = new Map();
 		/** @type {Set<ComplexSerializableType>} */
 		const cycleStack = new Set();
@@ -573,140 +573,160 @@ class ObjectMiddleware extends SerializerMiddleware {
 			...context
 		};
 		this.extendContext(ctx);
+		// Dispatched on `typeof` first: two thirds of the items are numbers,
+		// booleans and `undefined`, and only 3% are buffers.
 		/**
 		 * Processes the provided item.
 		 * @param {ComplexSerializableType} item item to serialize
 		 */
 		const process = (item) => {
-			if (Buffer.isBuffer(item)) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
+			switch (typeof item) {
+				case "number":
+				case "boolean":
+					result.push(item);
 					return;
-				}
-				const alreadyUsedBuffer = dedupeBuffer(item);
-				if (alreadyUsedBuffer !== item) {
-					const ref = referenceable.get(alreadyUsedBuffer);
-					if (ref !== undefined) {
-						referenceable.set(item, ref);
-						result.push(ESCAPE, ref - currentPos);
-						return;
+				case "string": {
+					if (item.length > 1) {
+						// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
+						// check if we can emit a reference
+						const ref = referenceable.get(item);
+						if (ref !== undefined) {
+							const offset = ref - currentPos;
+							if (
+								// One far ref → 5 bytes (`null` + offset), one near ref -> 2/3 bytes
+								offset >= -32768 ||
+								// long enough that the ref wins, keep it
+								item.length >= 4 ||
+								// multibyte → inline would be even bigger, keep it
+								Buffer.byteLength(item) !== item.length
+							) {
+								// A back-reference is `null` + the offset.
+								result.push(ESCAPE, offset);
+								return;
+							}
+						}
+						addReferenceable(item);
 					}
-					item = alreadyUsedBuffer;
-				}
-				addReferenceable(item);
 
-				result.push(/** @type {Buffer} */ (item));
-			} else if (item === ESCAPE) {
-				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
-			} else if (
-				typeof item === "object"
-				// We don't have to check for null as ESCAPE is null and this has been checked before
-			) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
+					if (item.length > 102400 && context.logger) {
+						context.logger.warn(
+							`Serializing big strings (${Math.round(
+								item.length / 1024
+							)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
+						);
+					}
+
+					result.push(item);
 					return;
 				}
+				case "undefined":
+					result.push(ESCAPE, ESCAPE_UNDEFINED);
+					return;
+				case "object": {
+					// ESCAPE is null, so this covers null too
+					if (item === ESCAPE) {
+						result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
+						return;
+					}
 
-				if (cycleStack.has(item)) {
-					throw new Error(
-						"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
-					);
-				}
+					if (Buffer.isBuffer(item)) {
+						// check if we can emit a reference
+						const ref = referenceable.get(item);
+						if (ref !== undefined) {
+							result.push(ESCAPE, ref - currentPos);
+							return;
+						}
+						const alreadyUsedBuffer = dedupeBuffer(item);
+						if (alreadyUsedBuffer !== item) {
+							const ref = referenceable.get(alreadyUsedBuffer);
+							if (ref !== undefined) {
+								referenceable.set(item, ref);
+								result.push(ESCAPE, ref - currentPos);
+								return;
+							}
+							item = alreadyUsedBuffer;
+						}
+						addReferenceable(item);
 
-				const { request, name, serializer } = ObjectMiddleware.getSerializerFor(
-					/** @type {Constructor} */
-					(item)
-				);
-				const key = `${request}/${name}`;
-				const lastIndex = objectTypeLookup.get(key);
+						result.push(/** @type {Buffer} */ (item));
+						return;
+					}
 
-				if (lastIndex === undefined) {
-					objectTypeLookup.set(key, currentPosTypeLookup++);
+					// check if we can emit a reference
+					const ref = referenceable.get(item);
+					if (ref !== undefined) {
+						result.push(ESCAPE, ref - currentPos);
+						return;
+					}
 
-					result.push(ESCAPE, request, name);
-				} else {
-					result.push(ESCAPE, currentPosTypeLookup - lastIndex);
-				}
+					if (cycleStack.has(item)) {
+						throw new Error(
+							"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
+						);
+					}
 
-				cycleStack.add(item);
+					// Keyed by the registration itself: one per class, so it stands in for
+					// `${request}/${name}` without building that string per object.
+					const config = ObjectMiddleware.getSerializerFor(
+						/** @type {Constructor} */
+						(item)
+					);
+					const { request, name, serializer } = config;
+					const lastIndex = objectTypeLookup.get(config);
 
-				try {
-					serializer.serialize(item, ctx);
-				} finally {
-					cycleStack.delete(item);
-				}
+					if (lastIndex === undefined) {
+						objectTypeLookup.set(config, currentPosTypeLookup++);
 
-				result.push(ESCAPE, ESCAPE_END_OBJECT);
+						result.push(ESCAPE, request, name);
+					} else {
+						result.push(ESCAPE, currentPosTypeLookup - lastIndex);
+					}
 
-				addReferenceable(item);
-			} else if (typeof item === "string") {
-				if (item.length > 1) {
-					// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
-					// check if we can emit a reference
-					const ref = referenceable.get(item);
-					if (ref !== undefined) {
-						const offset = ref - currentPos;
-						if (
-							// One far ref → 5 bytes (`null` + offset), one near ref -> 2/3 bytes
-							offset >= -32768 ||
-							// long enough that the ref wins, keep it
-							item.length >= 4 ||
-							// multibyte → inline would be even bigger, keep it
-							Buffer.byteLength(item) !== item.length
-						) {
-							// A back-reference is `null` + the offset.
-							result.push(ESCAPE, offset);
-							return;
-						}
+					cycleStack.add(item);
+
+					try {
+						serializer.serialize(item, ctx);
+					} finally {
+						cycleStack.delete(item);
 					}
-					addReferenceable(item);
-				}
 
-				if (item.length > 102400 && context.logger) {
-					context.logger.warn(
-						`Serializing big strings (${Math.round(
-							item.length / 1024
-						)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
-					);
-				}
+					result.push(ESCAPE, ESCAPE_END_OBJECT);
 
-				result.push(item);
-			} else if (typeof item === "function") {
-				if (!SerializerMiddleware.isLazy(item)) {
-					throw new Error(`Unexpected function ${item}`);
+					addReferenceable(item);
+					return;
 				}
+				case "function": {
+					if (!SerializerMiddleware.isLazy(item)) {
+						throw new Error(`Unexpected function ${item}`);
+					}
 
-				/** @type {SerializedType | undefined} */
-				const serializedData =
-					SerializerMiddleware.getLazySerializedValue(item);
+					/** @type {SerializedType | undefined} */
+					const serializedData =
+						SerializerMiddleware.getLazySerializedValue(item);
 
-				if (serializedData !== undefined) {
-					if (typeof serializedData === "function") {
-						result.push(serializedData);
-					} else {
+					if (serializedData !== undefined) {
+						if (typeof serializedData === "function") {
+							result.push(serializedData);
+						} else {
+							throw new Error("Not implemented");
+						}
+					} else if (SerializerMiddleware.isLazy(item, this)) {
 						throw new Error("Not implemented");
+					} else {
+						const data =
+							/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
+							(
+								SerializerMiddleware.serializeLazy(item, (data) =>
+									this.serialize([data], context)
+								)
+							);
+						SerializerMiddleware.setLazySerializedValue(item, data);
+						result.push(data);
 					}
-				} else if (SerializerMiddleware.isLazy(item, this)) {
-					throw new Error("Not implemented");
-				} else {
-					const data =
-						/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
-						(
-							SerializerMiddleware.serializeLazy(item, (data) =>
-								this.serialize([data], context)
-							)
-						);
-					SerializerMiddleware.setLazySerializedValue(item, data);
-					result.push(data);
+					return;
 				}
-			} else if (item === undefined) {
-				result.push(ESCAPE, ESCAPE_UNDEFINED);
-			} else {
-				result.push(item);
+				default:
+					result.push(item);
 			}
 		};
 

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;