@depup/webpack-sources 3.3.4-depup.0 → 3.6.0-depup.0

package/lib/RawSource.js

@@ -12,6 +12,7 @@ const {
 	isDualStringBufferCachingEnabled,
 } = require("./helpers/stringBufferUtils");
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -30,36 +31,32 @@ class RawSource extends Source {
 	constructor(value, convertToString = false) {
 		super();
 		const isBuffer = Buffer.isBuffer(value);
-		if (!isBuffer && typeof value !== "string") {
+		if (isBuffer) {
+			/**
+			 * @type {boolean}
+			 */
+			this._valueIsBuffer = !convertToString;
+			/**
+			 * @type {undefined | string | Buffer}
+			 */
+			this._value = convertToString ? undefined : value;
+			/**
+			 * @type {undefined | Buffer}
+			 */
+			this._valueAsBuffer = value;
+			/**
+			 * @type {undefined | string}
+			 */
+			this._valueAsString = undefined;
+		} else if (typeof value === "string") {
+			const interned = internString(value);
+			this._valueIsBuffer = false;
+			this._value = interned;
+			this._valueAsBuffer = undefined;
+			this._valueAsString = interned;
+		} else {
 			throw new TypeError("argument 'value' must be either string or Buffer");
 		}
-		/**
-		 * @private
-		 * @type {boolean}
-		 */
-		this._valueIsBuffer = !convertToString && isBuffer;
-		const internedString =
-			typeof value === "string" ? internString(value) : undefined;
-		/**
-		 * @private
-		 * @type {undefined | string | Buffer}
-		 */
-		this._value =
-			convertToString && isBuffer
-				? undefined
-				: typeof value === "string"
-					? internedString
-					: value;
-		/**
-		 * @private
-		 * @type {undefined | Buffer}
-		 */
-		this._valueAsBuffer = isBuffer ? value : undefined;
-		/**
-		 * @private
-		 * @type {undefined | string}
-		 */
-		this._valueAsString = isBuffer ? undefined : internedString;
 	}
 
 	isBuffer() {
@@ -82,6 +79,9 @@ class RawSource extends Source {
 		return this._value;
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
 		if (this._valueAsBuffer === undefined) {
 			const value = Buffer.from(/** @type {string} */ (this._value), "utf8");
@@ -93,6 +93,20 @@ class RawSource extends Source {
 		return this._valueAsBuffer;
 	}
 
+	/**
+	 * @returns {number} size
+	 */
+	size() {
+		if (this._cachedSize !== undefined) return this._cachedSize;
+		if (this._valueAsBuffer !== undefined) {
+			return (this._cachedSize = this._valueAsBuffer.length);
+		}
+		return (this._cachedSize = Buffer.byteLength(
+			/** @type {string} */ (this._valueAsString),
+			"utf8",
+		));
+	}
+
 	/**
 	 * @param {MapOptions=} options map options
 	 * @returns {RawSourceMap | null} map
@@ -127,13 +141,55 @@ class RawSource extends Source {
 		);
 	}
 
+	/**
+	 * Release cached data held by this source. clearCache is a memory
+	 * hint: it never affects correctness or output, only how expensive
+	 * the next read is. Subclasses override; the base is a no-op so
+	 * every Source supports the call. Composite sources always recurse
+	 * into wrapped sources. When the same child is reachable via several
+	 * parents (e.g. modules shared across webpack chunks), pass a shared
+	 * `visited` WeakSet so each subtree is walked at most once.
+	 * Not safe to call concurrently with source/map/sourceAndMap/
+	 * streamChunks/updateHash on the same instance.
+	 * @param {ClearCacheOptions=} options selectors
+	 * @param {WeakSet<Source>=} visited de-duplication set shared across calls
+	 * @returns {void}
+	 */
+	clearCache(options, visited) {
+		if (visited !== undefined) {
+			if (visited.has(this)) return;
+			visited.add(this);
+		}
+		if (options !== undefined && options.source === false) return;
+		if (this._valueIsBuffer) {
+			// Buffer is the primary representation (and lives in `_value`);
+			// only the string form, populated lazily by streamChunks, is
+			// safe to drop.
+			this._valueAsString = undefined;
+		} else if (this._valueAsBuffer !== undefined && this._value !== undefined) {
+			// The source was constructed from a string (so `_value` and
+			// `_valueAsString` reference the same interned string) and the
+			// buffer form was materialized later by `buffer()` /
+			// `updateHash()`. The buffer is therefore safe to drop.
+			this._valueAsBuffer = undefined;
+		}
+	}
+
 	/**
 	 * @param {HashLike} hash hash
 	 * @returns {void}
 	 */
 	updateHash(hash) {
 		hash.update("RawSource");
-		hash.update(this.buffer());
+		// A string is hashed as utf8, which is what `buffer()` would have
+		// encoded it to, so hashing never has to materialize the buffer.
+		// One of the two forms is always set: the constructor sets whichever
+		// matches its input, and `clearCache` only drops the derived one.
+		if (this._valueAsBuffer === undefined) {
+			hash.update(/** @type {string} */ (this._valueAsString));
+		} else {
+			hash.update(this._valueAsBuffer);
+		}
 	}
 }
 

package/lib/ReplaceSource.js

@@ -10,6 +10,7 @@ const { getMap, getSourceAndMap } = require("./helpers/getFromStreamChunks");
 const splitIntoLines = require("./helpers/splitIntoLines");
 const streamChunks = require("./helpers/streamChunks");
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -31,6 +32,38 @@ const hasStableSort =
 // This is larger than max string length
 const MAX_SOURCE_POSITION = 0x20000000;
 
+/**
+ * Stable comparator hoisted to module scope so each `_sortReplacements()`
+ * call doesn't allocate a fresh closure.
+ * @param {Replacement} a a
+ * @param {Replacement} b b
+ * @returns {number} order
+ */
+const compareStable = (a, b) => {
+	const diff1 = a.start - b.start;
+	if (diff1 !== 0) return diff1;
+	const diff2 = a.end - b.end;
+	if (diff2 !== 0) return diff2;
+	return 0;
+};
+
+/**
+ * Index-stabilising comparator for v8 < 7.0 (pre-stable Array.prototype.sort).
+ * Unreachable on any supported Node — the `hasStableSort` guard always
+ * wins so coverage tools never see this execute.
+ * @param {Replacement} a a
+ * @param {Replacement} b b
+ * @returns {number} order
+ */
+/* istanbul ignore next */
+const compareUnstableFallback = (a, b) => {
+	const diff1 = a.start - b.start;
+	if (diff1 !== 0) return diff1;
+	const diff2 = a.end - b.end;
+	if (diff2 !== 0) return diff2;
+	return /** @type {number} */ (a.index) - /** @type {number} */ (b.index);
+};
+
 class Replacement {
 	/**
 	 * @param {number} start start
@@ -43,6 +76,8 @@ class Replacement {
 		this.end = end;
 		this.content = content;
 		this.name = name;
+		// V8 < 7.0 only — unreachable on any supported Node.
+		/* istanbul ignore if */
 		if (!hasStableSort) {
 			this.index = -1;
 		}
@@ -57,19 +92,16 @@ class ReplaceSource extends Source {
 	constructor(source, name) {
 		super();
 		/**
-		 * @private
 		 * @type {Source}
 		 */
 		this._source = source;
 		/**
-		 * @private
 		 * @type {string | undefined}
 		 */
 		this._name = name;
 		/** @type {Replacement[]} */
 		this._replacements = [];
 		/**
-		 * @private
 		 * @type {boolean}
 		 */
 		this._isSorted = true;
@@ -124,7 +156,7 @@ class ReplaceSource extends Source {
 		if (this._replacements.length === 0) {
 			return this._source.source();
 		}
-		let current = this._source.source();
+		const current = /** @type {string} */ (this._source.source());
 		let pos = 0;
 		const result = [];
 
@@ -133,22 +165,45 @@ class ReplaceSource extends Source {
 			const start = Math.floor(replacement.start);
 			const end = Math.floor(replacement.end + 1);
 			if (pos < start) {
-				const offset = start - pos;
-				result.push(current.slice(0, offset));
-				current = current.slice(offset);
+				// slice directly from the original string rather than repeatedly
+				// producing smaller intermediate strings, which avoids O(n) copies.
+				result.push(current.slice(pos, start));
 				pos = start;
 			}
 			result.push(replacement.content);
 			if (pos < end) {
-				const offset = end - pos;
-				current = current.slice(offset);
 				pos = end;
 			}
 		}
-		result.push(current);
+		if (pos < current.length) {
+			result.push(pos === 0 ? current : current.slice(pos));
+		}
 		return result.join("");
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
+	buffer() {
+		if (this._replacements.length === 0) {
+			return this._source.buffer();
+		}
+		return super.buffer();
+	}
+
+	/**
+	 * @returns {Buffer[]} buffers
+	 */
+	buffers() {
+		if (this._replacements.length === 0) {
+			// TODO remove in the next major release
+			return typeof this._source.buffers === "function"
+				? this._source.buffers()
+				: [this._source.buffer()];
+		}
+		return [this.buffer()];
+	}
+
 	/**
 	 * @param {MapOptions=} options map options
 	 * @returns {RawSourceMap | null} map
@@ -177,25 +232,34 @@ class ReplaceSource extends Source {
 
 	_sortReplacements() {
 		if (this._isSorted) return;
+		const replacements = this._replacements;
+		// Replacements are usually appended in source order (ties keep
+		// insertion order, matching a stable sort), so an O(n) pre-scan
+		// often lets us skip the sort and its per-element comparator calls.
+		let isPresorted = true;
+		for (let i = 1; i < replacements.length; i++) {
+			const prev = replacements[i - 1];
+			const repl = replacements[i];
+			if (
+				repl.start < prev.start ||
+				(repl.start === prev.start && repl.end < prev.end)
+			) {
+				isPresorted = false;
+				break;
+			}
+		}
+		if (isPresorted) {
+			this._isSorted = true;
+			return;
+		}
 		if (hasStableSort) {
-			this._replacements.sort((a, b) => {
-				const diff1 = a.start - b.start;
-				if (diff1 !== 0) return diff1;
-				const diff2 = a.end - b.end;
-				if (diff2 !== 0) return diff2;
-				return 0;
-			});
+			this._replacements.sort(compareStable);
 		} else {
+			// V8 < 7.0 only — unreachable on any supported Node.
+			/* istanbul ignore next */
 			for (const [i, repl] of this._replacements.entries()) repl.index = i;
-			this._replacements.sort((a, b) => {
-				const diff1 = a.start - b.start;
-				if (diff1 !== 0) return diff1;
-				const diff2 = a.end - b.end;
-				if (diff2 !== 0) return diff2;
-				return (
-					/** @type {number} */ (a.index) - /** @type {number} */ (b.index)
-				);
-			});
+			/* istanbul ignore next */
+			this._replacements.sort(compareUnstableFallback);
 		}
 		this._isSorted = true;
 	}
@@ -209,6 +273,18 @@ class ReplaceSource extends Source {
 	 */
 	streamChunks(options, onChunk, onSource, onName) {
 		this._sortReplacements();
+		// When the consumer only wants the final source (map() /
+		// sourceAndMap()), emit position-only chunks (chunk === undefined,
+		// like OriginalSource and RawSource do) and hand back the whole
+		// replaced source once at the end. This avoids allocating boundary
+		// slices for emission and — more importantly — the per-chunk
+		// `code += chunk` cons-string chain in every enclosing consumer.
+		// With `source: false` the caller (getMap) additionally promises not
+		// to read the returned source, so its assembly is skipped entirely;
+		// streamAndGetSourceAndMap overrides that flag because it caches the
+		// text.
+		const finalSource = Boolean(options && options.finalSource);
+		const needSource = !options || options.source !== false;
 		const replacements = this._replacements;
 		let pos = 0;
 		let i = 0;
@@ -220,8 +296,15 @@ class ReplaceSource extends Source {
 		let generatedLineOffset = 0;
 		let generatedColumnOffset = 0;
 		let generatedColumnOffsetLine = 0;
-		/** @type {(string | string[] | undefined)[]} */
+		/** @type {(string | undefined)[]} */
 		const sourceContents = [];
+		/**
+		 * Lazily-built line-start offsets per source content. One number per
+		 * line instead of one substring per line (`splitIntoLines`), and the
+		 * chunk comparison below runs allocation-free via `startsWith`.
+		 * @type {(number[] | undefined)[]}
+		 */
+		const sourceContentLineStarts = [];
 		/** @type {Map<string, number>} */
 		const nameMapping = new Map();
 		/** @type {number[]} */
@@ -234,22 +317,34 @@ class ReplaceSource extends Source {
 		 * @returns {boolean} result
 		 */
 		const checkOriginalContent = (sourceIndex, line, column, expectedChunk) => {
-			/** @type {undefined | string | string[]} */
-			let content =
+			const content =
 				sourceIndex < sourceContents.length
 					? sourceContents[sourceIndex]
 					: undefined;
 			if (content === undefined) return false;
-			if (typeof content === "string") {
-				content = splitIntoLines(content);
-				sourceContents[sourceIndex] = content;
+			let lineStarts = sourceContentLineStarts[sourceIndex];
+			if (lineStarts === undefined) {
+				// Line boundaries mirror `splitIntoLines`: every line includes
+				// its trailing "\n"; a final line without "\n" still counts.
+				lineStarts = [];
+				const { length } = content;
+				let offset = 0;
+				while (offset < length) {
+					lineStarts.push(offset);
+					const newline = content.indexOf("\n", offset);
+					if (newline === -1) break;
+					offset = newline + 1;
+				}
+				sourceContentLineStarts[sourceIndex] = lineStarts;
 			}
-			const contentLine = line <= content.length ? content[line - 1] : null;
-			if (contentLine === null) return false;
-			return (
-				contentLine.slice(column, column + expectedChunk.length) ===
-				expectedChunk
-			);
+			if (line > lineStarts.length) return false;
+			const lineStart = lineStarts[line - 1];
+			const lineEnd =
+				line < lineStarts.length ? lineStarts[line] : content.length;
+			// The expected chunk never spans lines, so a match must fit into
+			// the current line (mirrors the old per-line slice comparison).
+			if (column + expectedChunk.length > lineEnd - lineStart) return false;
+			return content.startsWith(expectedChunk, lineStart + column);
 		};
 		const { generatedLine, generatedColumn } = streamChunks(
 			this._source,
@@ -281,7 +376,9 @@ class ReplaceSource extends Source {
 						} else if (generatedColumnOffsetLine === line) {
 							generatedColumnOffset -= chunk.length;
 						} else {
+							/* istanbul ignore next: pre-existing chunk-skipping cross-line case (also untested on main) */
 							generatedColumnOffset = -chunk.length;
+							/* istanbul ignore next: pre-existing chunk-skipping cross-line case (also untested on main) */
 							generatedColumnOffsetLine = line;
 						}
 						pos = endPos;
@@ -302,6 +399,7 @@ class ReplaceSource extends Source {
 					}
 					pos += chunkPos;
 					const line = generatedLine + generatedLineOffset;
+					/* istanbul ignore else: pre-existing chunk-skipping cross-line case (also untested on main) */
 					if (generatedColumnOffsetLine === line) {
 						generatedColumnOffset -= chunkPos;
 					} else {
@@ -320,7 +418,7 @@ class ReplaceSource extends Source {
 							const offset = nextReplacement - pos;
 							const chunkSlice = chunk.slice(chunkPos, chunkPos + offset);
 							onChunk(
-								chunkSlice,
+								finalSource ? undefined : chunkSlice,
 								line,
 								generatedColumn +
 									(line === generatedColumnOffsetLine
@@ -350,7 +448,6 @@ class ReplaceSource extends Source {
 
 						// Insert replacement content splitted into chunks by lines
 						const { content, name } = replacements[i];
-						const matches = splitIntoLines(content);
 						let replacementNameIndex = nameIndex;
 						if (sourceIndex >= 0 && name) {
 							let globalIndex = nameMapping.get(name);
@@ -361,10 +458,16 @@ class ReplaceSource extends Source {
 							}
 							replacementNameIndex = globalIndex;
 						}
-						for (let m = 0; m < matches.length; m++) {
-							const contentLine = matches[m];
+						// Fast path: most replacements (renamed identifiers,
+						// short inserts) carry single-line content. Skip
+						// `splitIntoLines` — and its array allocation — when
+						// we can tell the content has no embedded newline.
+						// `splitIntoLines("")` returns `[]`; emitting a zero-
+						// length chunk would still walk the loop, so handle
+						// it as a no-op explicitly.
+						if (content.length > 0 && !content.includes("\n")) {
 							onChunk(
-								contentLine,
+								finalSource ? undefined : content,
 								line,
 								generatedColumn +
 									(line === generatedColumnOffsetLine
@@ -375,22 +478,51 @@ class ReplaceSource extends Source {
 								originalColumn,
 								replacementNameIndex,
 							);
+							if (generatedColumnOffsetLine === line) {
+								generatedColumnOffset += content.length;
+							} else {
+								generatedColumnOffset = content.length;
+								generatedColumnOffsetLine = line;
+							}
+						} else if (content.length === 0) {
+							// Empty replacement: no chunk to emit, no column
+							// movement. `splitIntoLines("")` is `[]` so the
+							// existing loop already does nothing — explicit
+							// guard skips the per-call array allocation.
+						} else {
+							const matches = splitIntoLines(content);
+							for (let m = 0; m < matches.length; m++) {
+								const contentLine = matches[m];
+								onChunk(
+									finalSource ? undefined : contentLine,
+									line,
+									generatedColumn +
+										(line === generatedColumnOffsetLine
+											? generatedColumnOffset
+											: 0),
+									sourceIndex,
+									originalLine,
+									originalColumn,
+									replacementNameIndex,
+								);
 
-							// Only the first chunk has name assigned
-							replacementNameIndex = -1;
+								// Only the first chunk has name assigned
+								replacementNameIndex = -1;
 
-							if (m === matches.length - 1 && !contentLine.endsWith("\n")) {
-								if (generatedColumnOffsetLine === line) {
-									generatedColumnOffset += contentLine.length;
+								if (m === matches.length - 1 && !contentLine.endsWith("\n")) {
+									/* istanbul ignore else: pre-existing multi-line replacement cross-line case (also untested on main) */
+									if (generatedColumnOffsetLine === line) {
+										generatedColumnOffset += contentLine.length;
+									} else {
+										generatedColumnOffset = contentLine.length;
+										generatedColumnOffsetLine = line;
+									}
 								} else {
-									generatedColumnOffset = contentLine.length;
+									generatedLineOffset++;
+									line++;
+									generatedColumnOffset = -generatedColumn;
 									generatedColumnOffsetLine = line;
 								}
-							} else {
-								generatedLineOffset++;
-								line++;
-								generatedColumnOffset = -generatedColumn;
-								generatedColumnOffsetLine = line;
 							}
 						}
 
@@ -456,7 +588,11 @@ class ReplaceSource extends Source {
 
 				// Emit remaining chunk
 				if (chunkPos < chunk.length) {
-					const chunkSlice = chunkPos === 0 ? chunk : chunk.slice(chunkPos);
+					const chunkSlice = finalSource
+						? undefined
+						: chunkPos === 0
+							? chunk
+							: chunk.slice(chunkPos);
 					const line = generatedLine + generatedLineOffset;
 					onChunk(
 						chunkSlice,
@@ -471,12 +607,13 @@ class ReplaceSource extends Source {
 				}
 				pos = endPos;
 			},
-			(sourceIndex, source, sourceContent) => {
+			(sourceIndex, source, sourceContent, scopeBindings) => {
+				/* istanbul ignore next: non-sequential sourceIndex emission is not produced by any in-tree Source */
 				while (sourceContents.length < sourceIndex) {
 					sourceContents.push(undefined);
 				}
 				sourceContents[sourceIndex] = sourceContent;
-				onSource(sourceIndex, source, sourceContent);
+				onSource(sourceIndex, source, sourceContent, scopeBindings);
 			},
 			(nameIndex, name) => {
 				let globalIndex = nameMapping.get(name);
@@ -497,11 +634,13 @@ class ReplaceSource extends Source {
 
 		// Insert remaining replacements content splitted into chunks by lines
 		let line = /** @type {number} */ (generatedLine) + generatedLineOffset;
-		const matches = splitIntoLines(remainer);
-		for (let m = 0; m < matches.length; m++) {
-			const contentLine = matches[m];
+		// Fast path mirroring the in-chunk replacement loop above: skip
+		// splitIntoLines + per-match loop when the trailing content has no
+		// newlines (the common case when remaining replacements are single
+		// inserts).
+		if (remainer.length > 0 && !remainer.includes("\n")) {
 			onChunk(
-				contentLine,
+				finalSource ? undefined : remainer,
 				line,
 				/** @type {number} */
 				(generatedColumn) +
@@ -511,19 +650,43 @@ class ReplaceSource extends Source {
 				-1,
 				-1,
 			);
+			/* istanbul ignore else: trailing-remainer cross-line case (also untested on main) */
+			if (generatedColumnOffsetLine === line) {
+				generatedColumnOffset += remainer.length;
+			} else {
+				generatedColumnOffset = remainer.length;
+				generatedColumnOffsetLine = line;
+			}
+		} else {
+			const matches = splitIntoLines(remainer);
+			for (let m = 0; m < matches.length; m++) {
+				const contentLine = matches[m];
+				onChunk(
+					finalSource ? undefined : contentLine,
+					line,
+					/** @type {number} */
+					(generatedColumn) +
+						(line === generatedColumnOffsetLine ? generatedColumnOffset : 0),
+					-1,
+					-1,
+					-1,
+					-1,
+				);
 
-			if (m === matches.length - 1 && !contentLine.endsWith("\n")) {
-				if (generatedColumnOffsetLine === line) {
-					generatedColumnOffset += contentLine.length;
+				if (m === matches.length - 1 && !contentLine.endsWith("\n")) {
+					/* istanbul ignore else: trailing-remainer multi-line cross-line case (also untested on main) */
+					if (generatedColumnOffsetLine === line) {
+						generatedColumnOffset += contentLine.length;
+					} else {
+						generatedColumnOffset = contentLine.length;
+						generatedColumnOffsetLine = line;
+					}
 				} else {
-					generatedColumnOffset = contentLine.length;
+					generatedLineOffset++;
+					line++;
+					generatedColumnOffset = -(/** @type {number} */ (generatedColumn));
 					generatedColumnOffsetLine = line;
 				}
-			} else {
-				generatedLineOffset++;
-				line++;
-				generatedColumnOffset = -(/** @type {number} */ (generatedColumn));
-				generatedColumnOffsetLine = line;
 			}
 		}
 
@@ -533,9 +696,38 @@ class ReplaceSource extends Source {
 				/** @type {number} */
 				(generatedColumn) +
 				(line === generatedColumnOffsetLine ? generatedColumnOffset : 0),
+			// The streamed chunks reproduce source() exactly, so the final
+			// source can be assembled in O(replacements) string operations
+			// instead of re-concatenating every emitted chunk downstream.
+			source:
+				finalSource && needSource
+					? /** @type {string} */ (this.source())
+					: undefined,
 		};
 	}
 
+	/**
+	 * Release cached data held by this source. clearCache is a memory
+	 * hint: it never affects correctness or output, only how expensive
+	 * the next read is. Subclasses override; the base is a no-op so
+	 * every Source supports the call. Composite sources always recurse
+	 * into wrapped sources. When the same child is reachable via several
+	 * parents (e.g. modules shared across webpack chunks), pass a shared
+	 * `visited` WeakSet so each subtree is walked at most once.
+	 * Not safe to call concurrently with source/map/sourceAndMap/
+	 * streamChunks/updateHash on the same instance.
+	 * @param {ClearCacheOptions=} options selectors
+	 * @param {WeakSet<Source>=} visited de-duplication set shared across calls
+	 * @returns {void}
+	 */
+	clearCache(options, visited) {
+		if (visited !== undefined && visited.has(this)) return;
+		let v = visited;
+		if (v === undefined) v = new WeakSet();
+		v.add(this);
+		this._source.clearCache(options, v);
+	}
+
 	/**
 	 * @param {HashLike} hash hash
 	 * @returns {void}
@@ -545,10 +737,14 @@ class ReplaceSource extends Source {
 		hash.update("ReplaceSource");
 		this._source.updateHash(hash);
 		hash.update(this._name || "");
+		// Feed each replacement as multiple updates instead of building one
+		// combined template literal per replacement. The resulting digest is
+		// identical (hash.update is additive over bytes), but we avoid
+		// allocating a new string per replacement.
 		for (const repl of this._replacements) {
-			hash.update(
-				`${repl.start}${repl.end}${repl.content}${repl.name ? repl.name : ""}`,
-			);
+			hash.update(`${repl.start}${repl.end}`);
+			hash.update(repl.content);
+			if (repl.name) hash.update(repl.name);
 		}
 	}
 }